chad-code 1.3.1 → 1.3.3

package/src/plugin/index.ts

@@ -1,106 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,263 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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())
-  }
-}