chad-code 1.3.1

package/src/plugin/index.ts

@@ -0,0 +1,106 @@
+import type { Hooks, PluginInput, Plugin as PluginInstance } from "@opencode-ai/plugin"
+import { Config } from "../config/config"
+import { Bus } from "../bus"
+import { Log } from "../util/log"
+import { createOpencodeClient } from "@opencode-ai/sdk"
+import { Server } from "../server/server"
+import { BunProc } from "../bun"
+import { Instance } from "../project/instance"
+import { Flag } from "../flag/flag"
+
+export namespace Plugin {
+  const log = Log.create({ service: "plugin" })
+
+  // CoreThink doesn't need external auth plugins
+  const BUILTIN: string[] = []
+
+  const state = Instance.state(async () => {
+    const client = createOpencodeClient({
+      baseUrl: "http://localhost:4096",
+      // @ts-ignore - fetch type incompatibility
+      fetch: async (...args) => Server.App().fetch(...args),
+    })
+    const config = await Config.get()
+    const hooks = []
+    const input: PluginInput = {
+      client,
+      project: Instance.project,
+      worktree: Instance.worktree,
+      directory: Instance.directory,
+      serverUrl: Server.url(),
+      $: Bun.$,
+    }
+    const plugins = [...(config.plugin ?? [])]
+    if (!Flag.OPENCODE_DISABLE_DEFAULT_PLUGINS) {
+      plugins.push(...BUILTIN)
+    }
+    for (let plugin of plugins) {
+      log.info("loading plugin", { path: plugin })
+      if (!plugin.startsWith("file://")) {
+        const lastAtIndex = plugin.lastIndexOf("@")
+        const pkg = lastAtIndex > 0 ? plugin.substring(0, lastAtIndex) : plugin
+        const version = lastAtIndex > 0 ? plugin.substring(lastAtIndex + 1) : "latest"
+        const builtin = BUILTIN.some((x) => x.startsWith(pkg + "@"))
+        plugin = await BunProc.install(pkg, version).catch((err) => {
+          if (builtin) return ""
+          throw err
+        })
+        if (!plugin) continue
+      }
+      const mod = await import(plugin)
+      // Prevent duplicate initialization when plugins export the same function
+      // as both a named export and default export (e.g., `export const X` and `export default X`).
+      // Object.entries(mod) would return both entries pointing to the same function reference.
+      const seen = new Set<PluginInstance>()
+      for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
+        if (seen.has(fn)) continue
+        seen.add(fn)
+        const init = await fn(input)
+        hooks.push(init)
+      }
+    }
+
+    return {
+      hooks,
+      input,
+    }
+  })
+
+  export async function trigger<
+    Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
+    Input = Parameters<Required<Hooks>[Name]>[0],
+    Output = Parameters<Required<Hooks>[Name]>[1],
+  >(name: Name, input: Input, output: Output): Promise<Output> {
+    if (!name) return output
+    for (const hook of await state().then((x) => x.hooks)) {
+      const fn = hook[name]
+      if (!fn) continue
+      // @ts-expect-error if you feel adventurous, please fix the typing, make sure to bump the try-counter if you
+      // give up.
+      // try-counter: 2
+      await fn(input, output)
+    }
+    return output
+  }
+
+  export async function list() {
+    return state().then((x) => x.hooks)
+  }
+
+  export async function init() {
+    const hooks = await state().then((x) => x.hooks)
+    const config = await Config.get()
+    for (const hook of hooks) {
+      // @ts-expect-error this is because we haven't moved plugin to sdk v2
+      await hook.config?.(config)
+    }
+    Bus.subscribeAll(async (input) => {
+      const hooks = await state().then((x) => x.hooks)
+      for (const hook of hooks) {
+        hook["event"]?.({
+          event: input,
+        })
+      }
+    })
+  }
+}

package/src/project/bootstrap.ts

@@ -0,0 +1,31 @@
+import { Plugin } from "../plugin"
+import { Share } from "../share/share"
+import { Format } from "../format"
+import { LSP } from "../lsp"
+import { FileWatcher } from "../file/watcher"
+import { File } from "../file"
+import { Project } from "./project"
+import { Bus } from "../bus"
+import { Command } from "../command"
+import { Instance } from "./instance"
+import { Vcs } from "./vcs"
+import { Log } from "@/util/log"
+import { ShareNext } from "@/share/share-next"
+
+export async function InstanceBootstrap() {
+  Log.Default.info("bootstrapping", { directory: Instance.directory })
+  await Plugin.init()
+  Share.init()
+  ShareNext.init()
+  Format.init()
+  await LSP.init()
+  FileWatcher.init()
+  File.init()
+  Vcs.init()
+
+  Bus.subscribe(Command.Event.Executed, async (payload) => {
+    if (payload.properties.name === Command.Default.INIT) {
+      await Project.setInitialized(Instance.project.id)
+    }
+  })
+}

package/src/project/instance.ts

@@ -0,0 +1,78 @@
+import { Log } from "@/util/log"
+import { Context } from "../util/context"
+import { Project } from "./project"
+import { State } from "./state"
+import { iife } from "@/util/iife"
+import { GlobalBus } from "@/bus/global"
+
+interface Context {
+  directory: string
+  worktree: string
+  project: Project.Info
+}
+const context = Context.create<Context>("instance")
+const cache = new Map<string, Promise<Context>>()
+
+export const Instance = {
+  async provide<R>(input: { directory: string; init?: () => Promise<any>; fn: () => R }): Promise<R> {
+    let existing = cache.get(input.directory)
+    if (!existing) {
+      Log.Default.info("creating instance", { directory: input.directory })
+      existing = iife(async () => {
+        const { project, sandbox } = await Project.fromDirectory(input.directory)
+        const ctx = {
+          directory: input.directory,
+          worktree: sandbox,
+          project,
+        }
+        await context.provide(ctx, async () => {
+          await input.init?.()
+        })
+        return ctx
+      })
+      cache.set(input.directory, existing)
+    }
+    const ctx = await existing
+    return context.provide(ctx, async () => {
+      return input.fn()
+    })
+  },
+  get directory() {
+    return context.use().directory
+  },
+  get worktree() {
+    return context.use().worktree
+  },
+  get project() {
+    return context.use().project
+  },
+  state<S>(init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): () => S {
+    return State.create(() => Instance.directory, init, dispose)
+  },
+  async dispose() {
+    Log.Default.info("disposing instance", { directory: Instance.directory })
+    await State.dispose(Instance.directory)
+    cache.delete(Instance.directory)
+    GlobalBus.emit("event", {
+      directory: Instance.directory,
+      payload: {
+        type: "server.instance.disposed",
+        properties: {
+          directory: Instance.directory,
+        },
+      },
+    })
+  },
+  async disposeAll() {
+    Log.Default.info("disposing all instances")
+    for (const [_key, value] of cache) {
+      const awaited = await value.catch(() => {})
+      if (awaited) {
+        await context.provide(await value, async () => {
+          await Instance.dispose()
+        })
+      }
+    }
+    cache.clear()
+  },
+}

package/src/project/project.ts

@@ -0,0 +1,263 @@
+import z from "zod"
+import fs from "fs/promises"
+import { Filesystem } from "../util/filesystem"
+import path from "path"
+import { $ } from "bun"
+import { Storage } from "../storage/storage"
+import { Log } from "../util/log"
+import { Flag } from "@/flag/flag"
+import { Session } from "../session"
+import { work } from "../util/queue"
+import { fn } from "@opencode-ai/util/fn"
+import { BusEvent } from "@/bus/bus-event"
+import { iife } from "@/util/iife"
+import { GlobalBus } from "@/bus/global"
+
+export namespace Project {
+  const log = Log.create({ service: "project" })
+  export const Info = z
+    .object({
+      id: z.string(),
+      worktree: z.string(),
+      vcs: z.literal("git").optional(),
+      name: z.string().optional(),
+      icon: z
+        .object({
+          url: z.string().optional(),
+          color: z.string().optional(),
+        })
+        .optional(),
+      time: z.object({
+        created: z.number(),
+        updated: z.number(),
+        initialized: z.number().optional(),
+      }),
+      sandboxes: z.array(z.string()),
+    })
+    .meta({
+      ref: "Project",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: BusEvent.define("project.updated", Info),
+  }
+
+  export async function fromDirectory(directory: string) {
+    log.info("fromDirectory", { directory })
+
+    const { id, sandbox, worktree, vcs } = await iife(async () => {
+      const matches = Filesystem.up({ targets: [".git"], start: directory })
+      const git = await matches.next().then((x) => x.value)
+      await matches.return()
+      if (git) {
+        let sandbox = path.dirname(git)
+
+        // cached id calculation
+        let id = await Bun.file(path.join(git, "opencode"))
+          .text()
+          .then((x) => x.trim())
+          .catch(() => {})
+
+        // generate id from root commit
+        if (!id) {
+          const roots = await $`git rev-list --max-parents=0 --all`
+            .quiet()
+            .nothrow()
+            .cwd(sandbox)
+            .text()
+            .then((x) =>
+              x
+                .split("\n")
+                .filter(Boolean)
+                .map((x) => x.trim())
+                .toSorted(),
+            )
+          id = roots[0]
+          if (id) Bun.file(path.join(git, "opencode")).write(id)
+        }
+
+        if (!id)
+          return {
+            id: "global",
+            worktree: sandbox,
+            sandbox: sandbox,
+            vcs: "git",
+          }
+
+        sandbox = await $`git rev-parse --show-toplevel`
+          .quiet()
+          .nothrow()
+          .cwd(sandbox)
+          .text()
+          .then((x) => path.resolve(sandbox, x.trim()))
+        const worktree = await $`git rev-parse --git-common-dir`
+          .quiet()
+          .nothrow()
+          .cwd(sandbox)
+          .text()
+          .then((x) => {
+            const dirname = path.dirname(x.trim())
+            if (dirname === ".") return sandbox
+            return dirname
+          })
+        return {
+          id,
+          sandbox,
+          worktree,
+          vcs: "git",
+        }
+      }
+
+      return {
+        id: "global",
+        worktree: "/",
+        sandbox: "/",
+        vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
+      }
+    })
+
+    let existing = await Storage.read<Info>(["project", id]).catch(() => undefined)
+    if (!existing) {
+      existing = {
+        id,
+        worktree,
+        vcs: vcs as Info["vcs"],
+        sandboxes: [],
+        time: {
+          created: Date.now(),
+          updated: Date.now(),
+        },
+      }
+      if (id !== "global") {
+        await migrateFromGlobal(id, worktree)
+      }
+    }
+
+    // migrate old projects before sandboxes
+    if (!existing.sandboxes) existing.sandboxes = []
+
+    if (Flag.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY) discover(existing)
+    const result: Info = {
+      ...existing,
+      worktree,
+      vcs: vcs as Info["vcs"],
+      time: {
+        ...existing.time,
+        updated: Date.now(),
+      },
+    }
+    if (sandbox !== result.worktree && !result.sandboxes.includes(sandbox)) result.sandboxes.push(sandbox)
+    await Storage.write<Info>(["project", id], result)
+    GlobalBus.emit("event", {
+      payload: {
+        type: Event.Updated.type,
+        properties: result,
+      },
+    })
+    return { project: result, sandbox }
+  }
+
+  export async function discover(input: Info) {
+    if (input.vcs !== "git") return
+    if (input.icon?.url) return
+    const glob = new Bun.Glob("**/{favicon}.{ico,png,svg,jpg,jpeg,webp}")
+    const matches = await Array.fromAsync(
+      glob.scan({
+        cwd: input.worktree,
+        absolute: true,
+        onlyFiles: true,
+        followSymlinks: false,
+        dot: false,
+      }),
+    )
+    const shortest = matches.sort((a, b) => a.length - b.length)[0]
+    if (!shortest) return
+    const file = Bun.file(shortest)
+    const buffer = await file.arrayBuffer()
+    const base64 = Buffer.from(buffer).toString("base64")
+    const mime = file.type || "image/png"
+    const url = `data:${mime};base64,${base64}`
+    await update({
+      projectID: input.id,
+      icon: {
+        url,
+      },
+    })
+    return
+  }
+
+  async function migrateFromGlobal(newProjectID: string, worktree: string) {
+    const globalProject = await Storage.read<Info>(["project", "global"]).catch(() => undefined)
+    if (!globalProject) return
+
+    const globalSessions = await Storage.list(["session", "global"]).catch(() => [])
+    if (globalSessions.length === 0) return
+
+    log.info("migrating sessions from global", { newProjectID, worktree, count: globalSessions.length })
+
+    await work(10, globalSessions, async (key) => {
+      const sessionID = key[key.length - 1]
+      const session = await Storage.read<Session.Info>(key).catch(() => undefined)
+      if (!session) return
+      if (session.directory && session.directory !== worktree) return
+
+      session.projectID = newProjectID
+      log.info("migrating session", { sessionID, from: "global", to: newProjectID })
+      await Storage.write(["session", newProjectID, sessionID], session)
+      await Storage.remove(key)
+    }).catch((error) => {
+      log.error("failed to migrate sessions from global to project", { error, projectId: newProjectID })
+    })
+  }
+
+  export async function setInitialized(projectID: string) {
+    await Storage.update<Info>(["project", projectID], (draft) => {
+      draft.time.initialized = Date.now()
+    })
+  }
+
+  export async function list() {
+    const keys = await Storage.list(["project"])
+    return await Promise.all(keys.map((x) => Storage.read<Info>(x)))
+  }
+
+  export const update = fn(
+    z.object({
+      projectID: z.string(),
+      name: z.string().optional(),
+      icon: Info.shape.icon.optional(),
+    }),
+    async (input) => {
+      const result = await Storage.update<Info>(["project", input.projectID], (draft) => {
+        if (input.name !== undefined) draft.name = input.name
+        if (input.icon !== undefined) {
+          draft.icon = {
+            ...draft.icon,
+          }
+          if (input.icon.url !== undefined) draft.icon.url = input.icon.url
+          if (input.icon.color !== undefined) draft.icon.color = input.icon.color
+        }
+        draft.time.updated = Date.now()
+      })
+      GlobalBus.emit("event", {
+        payload: {
+          type: Event.Updated.type,
+          properties: result,
+        },
+      })
+      return result
+    },
+  )
+
+  export async function sandboxes(projectID: string) {
+    const project = await Storage.read<Info>(["project", projectID]).catch(() => undefined)
+    if (!project?.sandboxes) return []
+    const valid: string[] = []
+    for (const dir of project.sandboxes) {
+      const stat = await fs.stat(dir).catch(() => undefined)
+      if (stat?.isDirectory()) valid.push(dir)
+    }
+    return valid
+  }
+}

package/src/project/state.ts

@@ -0,0 +1,65 @@
+import { Log } from "@/util/log"
+
+export namespace State {
+  interface Entry {
+    state: any
+    dispose?: (state: any) => Promise<void>
+  }
+
+  const log = Log.create({ service: "state" })
+  const recordsByKey = new Map<string, Map<any, Entry>>()
+
+  export function create<S>(root: () => string, init: () => S, dispose?: (state: Awaited<S>) => Promise<void>) {
+    return () => {
+      const key = root()
+      let entries = recordsByKey.get(key)
+      if (!entries) {
+        entries = new Map<string, Entry>()
+        recordsByKey.set(key, entries)
+      }
+      const exists = entries.get(init)
+      if (exists) return exists.state as S
+      const state = init()
+      entries.set(init, {
+        state,
+        dispose,
+      })
+      return state
+    }
+  }
+
+  export async function dispose(key: string) {
+    const entries = recordsByKey.get(key)
+    if (!entries) return
+
+    log.info("waiting for state disposal to complete", { key })
+
+    let disposalFinished = false
+
+    setTimeout(() => {
+      if (!disposalFinished) {
+        log.warn(
+          "state disposal is taking an unusually long time - if it does not complete in a reasonable time, please report this as a bug",
+          { key },
+        )
+      }
+    }, 10000).unref()
+
+    const tasks: Promise<void>[] = []
+    for (const entry of entries.values()) {
+      if (!entry.dispose) continue
+
+      const task = Promise.resolve(entry.state)
+        .then((state) => entry.dispose!(state))
+        .catch((error) => {
+          log.error("Error while disposing state:", { error, key })
+        })
+
+      tasks.push(task)
+    }
+    entries.clear()
+    await Promise.all(tasks)
+    disposalFinished = true
+    log.info("state disposal completed", { key })
+  }
+}

package/src/project/vcs.ts

@@ -0,0 +1,76 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { $ } from "bun"
+import path from "path"
+import z from "zod"
+import { Log } from "@/util/log"
+import { Instance } from "./instance"
+import { FileWatcher } from "@/file/watcher"
+
+const log = Log.create({ service: "vcs" })
+
+export namespace Vcs {
+  export const Event = {
+    BranchUpdated: BusEvent.define(
+      "vcs.branch.updated",
+      z.object({
+        branch: z.string().optional(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      branch: z.string(),
+    })
+    .meta({
+      ref: "VcsInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  async function currentBranch() {
+    return $`git rev-parse --abbrev-ref HEAD`
+      .quiet()
+      .nothrow()
+      .cwd(Instance.worktree)
+      .text()
+      .then((x) => x.trim())
+      .catch(() => undefined)
+  }
+
+  const state = Instance.state(
+    async () => {
+      if (Instance.project.vcs !== "git") {
+        return { branch: async () => undefined, unsubscribe: undefined }
+      }
+      let current = await currentBranch()
+      log.info("initialized", { branch: current })
+
+      const unsubscribe = Bus.subscribe(FileWatcher.Event.Updated, async (evt) => {
+        if (evt.properties.file.endsWith("HEAD")) return
+        const next = await currentBranch()
+        if (next !== current) {
+          log.info("branch changed", { from: current, to: next })
+          current = next
+          Bus.publish(Event.BranchUpdated, { branch: next })
+        }
+      })
+
+      return {
+        branch: async () => current,
+        unsubscribe,
+      }
+    },
+    async (state) => {
+      state.unsubscribe?.()
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  export async function branch() {
+    return await state().then((s) => s.branch())
+  }
+}