bincode-cli 1.0.1

package/src/permission/index.ts

@@ -0,0 +1,199 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import z from "zod"
+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: BusEvent.define("permission.updated", Info),
+    Replied: BusEvent.define(
+      "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

@@ -0,0 +1,101 @@
+import type { Hooks, PluginInput, Plugin as PluginInstance } from "@bincode-ai/plugin"
+import { Config } from "../config/config"
+import { Bus } from "../bus"
+import { Log } from "../util/log"
+import { createBincodeClient } from "@bincode-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 = createBincodeClient({
+      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.BINCODE_DISABLE_DEFAULT_PLUGINS) {
+      plugins.push("bincode-copilot-auth@0.0.9")
+      plugins.push("bincode-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"
+        try {
+          plugin = await BunProc.install(pkg, version)
+        } catch (e) {
+          log.warn("failed to install plugin", { pkg, version, error: e instanceof Error ? e.message : String(e) })
+          continue
+        }
+      }
+      try {
+        const mod = await import(plugin)
+        for (const [_name, fn] of Object.entries<PluginInstance>(mod)) {
+          const init = await fn(input)
+          hooks.push(init)
+        }
+      } catch (e) {
+        log.warn("failed to load plugin", { plugin, error: e instanceof Error ? e.message : String(e) })
+        continue
+      }
+    }
+
+    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) {
+      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 = 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)
+    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,221 @@
+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"
+import { fn } from "@bincode-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(),
+      }),
+    })
+    .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, 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 worktree = path.dirname(git)
+        let id = await Bun.file(path.join(git, "bincode"))
+          .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, "bincode")).write(id)
+        }
+        if (!id)
+          return {
+            id: "global",
+            worktree,
+            vcs: "git",
+          }
+        worktree = await $`git rev-parse --show-toplevel`
+          .quiet()
+          .nothrow()
+          .cwd(worktree)
+          .text()
+          .then((x) => path.resolve(worktree, x.trim()))
+        return { id, worktree, vcs: "git" }
+      }
+
+      return {
+        id: "global",
+        worktree: "/",
+        vcs: Info.shape.vcs.parse(Flag.BINCODE_FAKE_VCS),
+      }
+    })
+
+    let existing = await Storage.read<Info>(["project", id]).catch(() => undefined)
+    if (!existing) {
+      existing = {
+        id,
+        worktree,
+        vcs: vcs as Info["vcs"],
+        time: {
+          created: Date.now(),
+          updated: Date.now(),
+        },
+      }
+      if (id !== "global") {
+        await migrateFromGlobal(id, worktree)
+      }
+    }
+    if (Flag.BINCODE_EXPERIMENTAL_ICON_DISCOVERY) discover(existing)
+    const result: Info = {
+      ...existing,
+      worktree,
+      vcs: vcs as Info["vcs"],
+      time: {
+        ...existing.time,
+        updated: Date.now(),
+      },
+    }
+    await Storage.write<Info>(["project", id], result)
+    GlobalBus.emit("event", {
+      payload: {
+        type: Event.Updated.type,
+        properties: result,
+      },
+    })
+    return result
+  }
+
+  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
+    },
+  )
+}

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 })
+  }
+}