opencode/packages/opencode/src/app/app.ts

import { Log } from "../util/log"
import { Context } from "../util/context"
import { Filesystem } from "../util/filesystem"
import { Global } from "../global"
import path from "path"
import os from "os"
import { z } from "zod"

export namespace App {
  const log = Log.create({ service: "app" })

  export const Info = z
    .object({
      user: z.string(),
      git: z.boolean(),
      path: z.object({
        config: z.string(),
        data: z.string(),
        root: z.string(),
        cwd: z.string(),
      }),
      time: z.object({
        initialized: z.number().optional(),
      }),
    })
    .openapi({
      ref: "App.Info",
    })
  export type Info = z.infer<typeof Info>

  const ctx = Context.create<Awaited<ReturnType<typeof create>>>("app")

  const APP_JSON = "app.json"

  async function create(input: { cwd: string; version: string }) {
    log.info("creating", {
      cwd: input.cwd,
      version: input.version,
    })
    const git = await Filesystem.findUp(".git", input.cwd).then(([x]) =>
      x ? path.dirname(x) : undefined,
    )
    log.info("git", { git })

    const data = path.join(
      Global.Path.data,
      "project",
      git ? git.split(path.sep).join("-") : "global",
    )
    const stateFile = Bun.file(path.join(data, APP_JSON))
    const state = (await stateFile.json().catch(() => ({}))) as {
      initialized: number
      version: string
    }
    state.version = input.version
    await stateFile.write(JSON.stringify(state))

    const services = new Map<
      any,
      {
        state: any
        shutdown?: (input: any) => Promise<void>
      }
    >()

    const info: Info = {
      user: os.userInfo().username,
      time: {
        initialized: state.initialized,
      },
      git: git !== undefined,
      path: {
        config: Global.Path.config,
        data,
        root: git ?? input.cwd,
        cwd: input.cwd,
      },
    }
    const result = {
      version: input.version,
      services,
      info,
    }

    return result
  }

  export function state<State>(
    key: any,
    init: (app: Info) => State,
    shutdown?: (state: Awaited<State>) => Promise<void>,
  ) {
    return () => {
      const app = ctx.use()
      const services = app.services
      if (!services.has(key)) {
        log.info("registering service", { name: key })
        services.set(key, {
          state: init(app.info),
          shutdown: shutdown,
        })
      }
      return services.get(key)?.state as State
    }
  }

  export function info() {
    return ctx.use().info
  }

  export async function provide<T extends (app: Info) => any>(
    input: { cwd: string; version: string },
    cb: T,
  ) {
    const app = await create(input)
    return ctx.provide(app, async () => {
      const result = await cb(app.info)
      for (const [key, entry] of app.services.entries()) {
        log.info("shutdown", { name: key })
        await entry.shutdown?.(await entry.state)
      }
      return result
    })
  }

  export async function initialize() {
    const { info, version } = ctx.use()
    info.time.initialized = Date.now()
    await Bun.write(
      path.join(info.path.data, APP_JSON),
      JSON.stringify({
        version,
        initialized: Date.now(),
      }),
    )
  }
}