cerebras-cli 1.0.1 → 1.0.3

package/src/permission/index.ts

@@ -1,198 +0,0 @@
-import z from "zod"
-import { Bus } from "../bus"
-import { Log } from "../util/log"
-import { Identifier } from "../id/id"
-import { Plugin } from "../plugin"
-import { Instance } from "../project/instance"
-import { Wildcard } from "../util/wildcard"
-
-export namespace Permission {
-  const log = Log.create({ service: "permission" })
-
-  function toKeys(pattern: Info["pattern"], type: string): string[] {
-    return pattern === undefined ? [type] : Array.isArray(pattern) ? pattern : [pattern]
-  }
-
-  function covered(keys: string[], approved: Record<string, boolean>): boolean {
-    const pats = Object.keys(approved)
-    return keys.every((k) => pats.some((p) => Wildcard.match(k, p)))
-  }
-
-  export const Info = z
-    .object({
-      id: z.string(),
-      type: z.string(),
-      pattern: z.union([z.string(), z.array(z.string())]).optional(),
-      sessionID: z.string(),
-      messageID: z.string(),
-      callID: z.string().optional(),
-      title: z.string(),
-      metadata: z.record(z.string(), z.any()),
-      time: z.object({
-        created: z.number(),
-      }),
-    })
-    .meta({
-      ref: "Permission",
-    })
-  export type Info = z.infer<typeof Info>
-
-  export const Event = {
-    Updated: Bus.event("permission.updated", Info),
-    Replied: Bus.event(
-      "permission.replied",
-      z.object({
-        sessionID: z.string(),
-        permissionID: z.string(),
-        response: z.string(),
-      }),
-    ),
-  }
-
-  const state = Instance.state(
-    () => {
-      const pending: {
-        [sessionID: string]: {
-          [permissionID: string]: {
-            info: Info
-            resolve: () => void
-            reject: (e: any) => void
-          }
-        }
-      } = {}
-
-      const approved: {
-        [sessionID: string]: {
-          [permissionID: string]: boolean
-        }
-      } = {}
-
-      return {
-        pending,
-        approved,
-      }
-    },
-    async (state) => {
-      for (const pending of Object.values(state.pending)) {
-        for (const item of Object.values(pending)) {
-          item.reject(new RejectedError(item.info.sessionID, item.info.id, item.info.callID, item.info.metadata))
-        }
-      }
-    },
-  )
-
-  export function pending() {
-    return state().pending
-  }
-
-  export async function ask(input: {
-    type: Info["type"]
-    title: Info["title"]
-    pattern?: Info["pattern"]
-    callID?: Info["callID"]
-    sessionID: Info["sessionID"]
-    messageID: Info["messageID"]
-    metadata: Info["metadata"]
-  }) {
-    const { pending, approved } = state()
-    log.info("asking", {
-      sessionID: input.sessionID,
-      messageID: input.messageID,
-      toolCallID: input.callID,
-      pattern: input.pattern,
-    })
-    const approvedForSession = approved[input.sessionID] || {}
-    const keys = toKeys(input.pattern, input.type)
-    if (covered(keys, approvedForSession)) return
-    const info: Info = {
-      id: Identifier.ascending("permission"),
-      type: input.type,
-      pattern: input.pattern,
-      sessionID: input.sessionID,
-      messageID: input.messageID,
-      callID: input.callID,
-      title: input.title,
-      metadata: input.metadata,
-      time: {
-        created: Date.now(),
-      },
-    }
-
-    switch (
-      await Plugin.trigger("permission.ask", info, {
-        status: "ask",
-      }).then((x) => x.status)
-    ) {
-      case "deny":
-        throw new RejectedError(info.sessionID, info.id, info.callID, info.metadata)
-      case "allow":
-        return
-    }
-
-    pending[input.sessionID] = pending[input.sessionID] || {}
-    return new Promise<void>((resolve, reject) => {
-      pending[input.sessionID][info.id] = {
-        info,
-        resolve,
-        reject,
-      }
-      Bus.publish(Event.Updated, info)
-    })
-  }
-
-  export const Response = z.enum(["once", "always", "reject"])
-  export type Response = z.infer<typeof Response>
-
-  export function respond(input: { sessionID: Info["sessionID"]; permissionID: Info["id"]; response: Response }) {
-    log.info("response", input)
-    const { pending, approved } = state()
-    const match = pending[input.sessionID]?.[input.permissionID]
-    if (!match) return
-    delete pending[input.sessionID][input.permissionID]
-    Bus.publish(Event.Replied, {
-      sessionID: input.sessionID,
-      permissionID: input.permissionID,
-      response: input.response,
-    })
-    if (input.response === "reject") {
-      match.reject(new RejectedError(input.sessionID, input.permissionID, match.info.callID, match.info.metadata))
-      return
-    }
-    match.resolve()
-    if (input.response === "always") {
-      approved[input.sessionID] = approved[input.sessionID] || {}
-      const approveKeys = toKeys(match.info.pattern, match.info.type)
-      for (const k of approveKeys) {
-        approved[input.sessionID][k] = true
-      }
-      const items = pending[input.sessionID]
-      if (!items) return
-      for (const item of Object.values(items)) {
-        const itemKeys = toKeys(item.info.pattern, item.info.type)
-        if (covered(itemKeys, approved[input.sessionID])) {
-          respond({
-            sessionID: item.info.sessionID,
-            permissionID: item.info.id,
-            response: input.response,
-          })
-        }
-      }
-    }
-  }
-
-  export class RejectedError extends Error {
-    constructor(
-      public readonly sessionID: string,
-      public readonly permissionID: string,
-      public readonly toolCallID?: string,
-      public readonly metadata?: Record<string, any>,
-      public readonly reason?: string,
-    ) {
-      super(
-        reason !== undefined
-          ? reason
-          : `The user rejected permission to use this specific tool call. You may try again with different parameters.`,
-      )
-    }
-  }
-}

package/src/plugin/index.ts

@@ -1,95 +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" })
-
-  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,
-      $: Bun.$,
-    }
-    const plugins = [...(config.plugin ?? [])]
-    if (!Flag.OPENCODE_DISABLE_DEFAULT_PLUGINS) {
-      plugins.push("opencode-copilot-auth@0.0.9")
-      plugins.push("opencode-anthropic-auth@0.0.5")
-    }
-    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"
-        plugin = await BunProc.install(pkg, version)
-      }
-      const mod = await import(plugin)
-      for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
-        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
-      try {
-        // @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)
-      } catch (e) {
-        log.error("failed to trigger hook", { name, error: e })
-      }
-    }
-    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) {
-      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,68 +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"
-
-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 = await Project.fromDirectory(input.directory)
-        const ctx = {
-          directory: input.directory,
-          worktree: project.worktree,
-          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)
-  },
-  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,133 +0,0 @@
-import z from "zod"
-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"
-
-export namespace Project {
-  const log = Log.create({ service: "project" })
-  export const Info = z
-    .object({
-      id: z.string(),
-      worktree: z.string(),
-      vcsDir: z.string().optional(),
-      vcs: z.literal("git").optional(),
-      time: z.object({
-        created: z.number(),
-        initialized: z.number().optional(),
-      }),
-    })
-    .meta({
-      ref: "Project",
-    })
-  export type Info = z.infer<typeof Info>
-
-  export async function fromDirectory(directory: string) {
-    log.info("fromDirectory", { directory })
-    const matches = Filesystem.up({ targets: [".git"], start: directory })
-    const git = await matches.next().then((x) => x.value)
-    await matches.return()
-    if (!git) {
-      const project: Info = {
-        id: "global",
-        worktree: "/",
-        vcs: Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS),
-        time: {
-          created: Date.now(),
-        },
-      }
-      await Storage.write<Info>(["project", "global"], project)
-      return project
-    }
-    let worktree = path.dirname(git)
-    const timer = log.time("git.rev-parse")
-    let id = await Bun.file(path.join(git, "opencode"))
-      .text()
-      .then((x) => x.trim())
-      .catch(() => {})
-    if (!id) {
-      const roots = await $`git rev-list --max-parents=0 --all`
-        .quiet()
-        .nothrow()
-        .cwd(worktree)
-        .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)
-    }
-    timer.stop()
-    worktree = await $`git rev-parse --show-toplevel`
-      .quiet()
-      .nothrow()
-      .cwd(worktree)
-      .text()
-      .then((x) => path.resolve(worktree, x.trim()))
-    const vcsDir = await $`git rev-parse --git-dir`
-      .quiet()
-      .nothrow()
-      .cwd(worktree)
-      .text()
-      .then((x) => path.resolve(worktree, x.trim()))
-    const projectID = id || "global"
-    const existing = id ? await Storage.read<Info>(["project", id]).catch(() => undefined) : undefined
-    if (!existing && id) {
-      await migrateFromGlobal(projectID, worktree)
-    }
-    const project: Info = {
-      id: projectID,
-      worktree,
-      vcsDir,
-      vcs: "git",
-      time: {
-        created: Date.now(),
-      },
-    }
-    await Storage.write<Info>(["project", projectID], project)
-    return project
-  }
-
-  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)))
-  }
-}

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,77 +0,0 @@
-import { $ } from "bun"
-import path from "path"
-import z from "zod"
-import { Log } from "@/util/log"
-import { Bus } from "@/bus"
-import { Instance } from "./instance"
-import { FileWatcher } from "@/file/watcher"
-
-const log = Log.create({ service: "vcs" })
-
-export namespace Vcs {
-  export const Event = {
-    BranchUpdated: Bus.event(
-      "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 () => {
-      const vcsDir = Instance.project.vcsDir
-      if (Instance.project.vcs !== "git" || !vcsDir) {
-        return { branch: async () => undefined, unsubscribe: undefined }
-      }
-      let current = await currentBranch()
-      log.info("initialized", { branch: current })
-
-      const head = path.join(vcsDir, "HEAD")
-      const unsubscribe = Bus.subscribe(FileWatcher.Event.Updated, async (evt) => {
-        if (evt.properties.file !== 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())
-  }
-}