nikcli 0.0.6

package/src/plugin/shared.ts

@@ -0,0 +1,188 @@
+import path from "path"
+import { fileURLToPath, pathToFileURL } from "url"
+import semver from "semver"
+import { BunProc } from "@/bun"
+import { Filesystem } from "@/util/filesystem"
+import { isRecord } from "@/util/record"
+
+// Old npm package names for plugins that are now built-in
+export const DEPRECATED_PLUGIN_PACKAGES = ["nikcli-openai-codex-auth", "nikcli-copilot-auth"]
+
+export function isDeprecatedPlugin(spec: string) {
+  return DEPRECATED_PLUGIN_PACKAGES.some((pkg) => spec.includes(pkg))
+}
+
+export function parsePluginSpecifier(spec: string) {
+  const lastAt = spec.lastIndexOf("@")
+  const pkg = lastAt > 0 ? spec.substring(0, lastAt) : spec
+  const version = lastAt > 0 ? spec.substring(lastAt + 1) : "latest"
+  return { pkg, version }
+}
+
+export type PluginSource = "file" | "npm"
+export type PluginKind = "server" | "tui"
+type PluginMode = "strict" | "detect"
+
+export function pluginSource(spec: string): PluginSource {
+  return spec.startsWith("file://") ? "file" : "npm"
+}
+
+function hasEntrypoint(json: Record<string, unknown>, kind: PluginKind) {
+  if (!isRecord(json.exports)) return false
+  return `./${kind}` in json.exports
+}
+
+function resolveExportPath(raw: string, dir: string) {
+  if (raw.startsWith("./") || raw.startsWith("../")) return path.resolve(dir, raw)
+  if (raw.startsWith("file://")) return fileURLToPath(raw)
+  return raw
+}
+
+function extractExportValue(value: unknown): string | undefined {
+  if (typeof value === "string") return value
+  if (!isRecord(value)) return undefined
+  for (const key of ["import", "default"]) {
+    const nested = value[key]
+    if (typeof nested === "string") return nested
+  }
+  return undefined
+}
+
+export async function resolvePluginEntrypoint(spec: string, target: string, kind: PluginKind) {
+  const pkg = await readPluginPackage(target).catch(() => undefined)
+  if (!pkg) return target
+  if (!hasEntrypoint(pkg.json, kind)) return target
+
+  const exports = pkg.json.exports
+  if (!isRecord(exports)) return target
+  const raw = extractExportValue(exports[`./${kind}`])
+  if (!raw) return target
+
+  const resolved = resolveExportPath(raw, pkg.dir)
+  const root = Filesystem.resolve(pkg.dir)
+  const next = Filesystem.resolve(resolved)
+  if (!Filesystem.contains(root, next)) {
+    throw new Error(`Plugin ${spec} resolved ${kind} entry outside plugin directory`)
+  }
+
+  return pathToFileURL(next).href
+}
+
+export function isPathPluginSpec(spec: string) {
+  return spec.startsWith("file://") || spec.startsWith(".") || path.isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec)
+}
+
+export async function resolvePathPluginTarget(spec: string) {
+  const raw = spec.startsWith("file://") ? fileURLToPath(spec) : spec
+  const file = path.isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw) ? raw : path.resolve(raw)
+  const stat = await Filesystem.stat(file)
+  if (!stat?.isDirectory()) {
+    if (spec.startsWith("file://")) return spec
+    return pathToFileURL(file).href
+  }
+
+  const pkg = await Filesystem.readJson<Record<string, unknown>>(path.join(file, "package.json")).catch(() => undefined)
+  if (!pkg) throw new Error(`Plugin directory ${file} is missing package.json`)
+  if (typeof pkg.main !== "string" || !pkg.main.trim()) {
+    throw new Error(`Plugin directory ${file} must define package.json main`)
+  }
+  return pathToFileURL(path.resolve(file, pkg.main)).href
+}
+
+export async function checkPluginCompatibility(target: string, opencodeVersion: string) {
+  if (!semver.valid(opencodeVersion) || semver.major(opencodeVersion) === 0) return
+  const pkg = await readPluginPackage(target).catch(() => undefined)
+  if (!pkg) return
+  const engines = pkg.json.engines
+  if (!isRecord(engines)) return
+  const range = engines.opencode
+  if (typeof range !== "string") return
+  if (!semver.satisfies(opencodeVersion, range)) {
+    throw new Error(`Plugin requires opencode ${range} but running ${opencodeVersion}`)
+  }
+}
+
+export async function resolvePluginTarget(spec: string, parsed = parsePluginSpecifier(spec)) {
+  if (isPathPluginSpec(spec)) return resolvePathPluginTarget(spec)
+  return BunProc.install(parsed.pkg, parsed.version)
+}
+
+export async function readPluginPackage(target: string) {
+  const file = target.startsWith("file://") ? fileURLToPath(target) : target
+  const stat = await Filesystem.stat(file)
+  const dir = stat?.isDirectory() ? file : path.dirname(file)
+  const pkg = path.join(dir, "package.json")
+  const json = await Filesystem.readJson<Record<string, unknown>>(pkg)
+  return { dir, pkg, json }
+}
+
+export function readPluginId(id: unknown, spec: string) {
+  if (id === undefined) return
+  if (typeof id !== "string") throw new TypeError(`Plugin ${spec} has invalid id type ${typeof id}`)
+  const value = id.trim()
+  if (!value) throw new TypeError(`Plugin ${spec} has an empty id`)
+  return value
+}
+
+export async function getPluginIdFromPackage(target: string, spec: string): Promise<string | undefined> {
+  try {
+    const pkg = await readPluginPackage(target)
+    if (typeof pkg.json.name !== "string" || !pkg.json.name.trim()) {
+      return undefined
+    }
+    return pkg.json.name.trim()
+  } catch {
+    return undefined
+  }
+}
+
+export function readV1Plugin(
+  mod: Record<string, unknown>,
+  spec: string,
+  kind: PluginKind,
+  mode: PluginMode = "strict",
+) {
+  const value = mod.default
+  if (!isRecord(value)) {
+    if (mode === "detect") return
+    throw new TypeError(`Plugin ${spec} must default export an object with ${kind}()`)
+  }
+  if (mode === "detect" && !("id" in value) && !("server" in value) && !("tui" in value)) return
+
+  const server = "server" in value ? value.server : undefined
+  const tui = "tui" in value ? value.tui : undefined
+  if (server !== undefined && typeof server !== "function") {
+    if (mode === "detect") return
+    throw new TypeError(`Plugin ${spec} has invalid server export`)
+  }
+  if (tui !== undefined && typeof tui !== "function") {
+    if (mode === "detect") return
+    throw new TypeError(`Plugin ${spec} has invalid tui export`)
+  }
+  if (server !== undefined && tui !== undefined) {
+    if (mode === "detect") return
+    throw new TypeError(`Plugin ${spec} must default export either server() or tui(), not both`)
+  }
+  if (kind === "server" && server === undefined) {
+    if (mode === "detect") return
+    throw new TypeError(`Plugin ${spec} must default export an object with server()`)
+  }
+  if (kind === "tui" && tui === undefined) {
+    if (mode === "detect") return undefined
+  }
+
+  return value
+}
+
+export async function resolvePluginId(source: PluginSource, spec: string, target: string, id: string | undefined) {
+  if (source === "file") {
+    if (id) return id
+    throw new TypeError(`Path plugin ${spec} must export id`)
+  }
+  if (id) return id
+  const pkg = await readPluginPackage(target)
+  if (typeof pkg.json.name !== "string" || !pkg.json.name.trim()) {
+    throw new TypeError(`Plugin package ${pkg.pkg} is missing name`)
+  }
+  return pkg.json.name.trim()
+}

package/src/project/bootstrap.ts

@@ -0,0 +1,35 @@
+import { Plugin } from "../plugin"
+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"
+import { Snapshot } from "../snapshot"
+import { Truncate } from "../tool/truncation"
+import { Todo } from "../session/todo"
+
+export async function InstanceBootstrap() {
+  Log.Default.info("bootstrapping", { directory: Instance.directory })
+  await Plugin.init()
+  ShareNext.init()
+  Format.init()
+  await LSP.init()
+  FileWatcher.init()
+  File.init()
+  Vcs.init()
+  Snapshot.init()
+  Truncate.init()
+  Todo.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,84 @@
+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"
+import { Filesystem } from "@/util/filesystem"
+
+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
+  },
+  containsPath(filepath: string) {
+    if (Filesystem.contains(Instance.directory, filepath)) return true
+    if (Instance.worktree === "/") return false
+    return Filesystem.contains(Instance.worktree, filepath)
+  },
+  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,373 @@
+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 "@nikcli-ai/util/fn"
+import { BusEvent } from "@/bus/bus-event"
+import { iife } from "@/util/iife"
+import { GlobalBus } from "@/bus/global"
+import { existsSync } from "fs"
+
+export namespace Project {
+  const log = Log.create({ service: "project" })
+
+  async function readCachedID(gitDir?: string) {
+    if (!gitDir) return undefined
+
+    const stat = await fs.stat(gitDir).catch(() => undefined)
+    if (!stat?.isDirectory()) return undefined
+
+    return Bun.file(path.join(gitDir, "nikcli"))
+      .text()
+      .then((x) => x.trim())
+      .catch(() => undefined)
+  }
+
+  async function writeCachedID(gitDir: string | undefined, id: string) {
+    if (!gitDir) return
+
+    const stat = await fs.stat(gitDir).catch(() => undefined)
+    if (!stat?.isDirectory()) return
+
+    await Bun.file(path.join(gitDir, "nikcli"))
+      .write(id)
+      .catch(() => undefined)
+  }
+
+  function cacheDirToWorktree(gitDir: string, sandbox: string) {
+    const dirname = path.dirname(path.relative(sandbox, gitDir) || ".")
+    if (dirname === ".") return sandbox
+    return path.resolve(sandbox, dirname)
+  }
+
+  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(),
+          override: 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)
+
+        const gitBinary = Bun.which("git")
+
+        let commonGitDir: string | undefined
+        let id = await readCachedID(git)
+
+        if (gitBinary) {
+          commonGitDir = await $`git rev-parse --git-common-dir`
+            .quiet()
+            .nothrow()
+            .cwd(sandbox)
+            .text()
+            .then((x) => path.resolve(sandbox, x.trim()))
+            .catch(() => undefined)
+
+          if (!id && commonGitDir && commonGitDir !== git) {
+            id = await readCachedID(commonGitDir)
+          }
+        }
+
+        if (!gitBinary) {
+          return {
+            id: id ?? "global",
+            worktree: sandbox,
+            sandbox: sandbox,
+            vcs: Info.shape.vcs.parse(Flag.NIKCLI_FAKE_VCS),
+          }
+        }
+
+        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(),
+            )
+            .catch(() => undefined)
+
+          if (!roots) {
+            return {
+              id: "global",
+              worktree: sandbox,
+              sandbox: sandbox,
+              vcs: Info.shape.vcs.parse(Flag.NIKCLI_FAKE_VCS),
+            }
+          }
+
+          id = roots[0]
+          if (id) {
+            const derivedID = id
+            const cacheDir = commonGitDir ?? git
+            void readCachedID(cacheDir)
+              .then((cached) => {
+                if (cached || !cacheDir) return
+                return writeCachedID(cacheDir, derivedID)
+              })
+              .catch(() => undefined)
+          }
+        }
+
+        if (!id) {
+          return {
+            id: "global",
+            worktree: sandbox,
+            sandbox: sandbox,
+            vcs: "git",
+          }
+        }
+
+        const top = await $`git rev-parse --show-toplevel`
+          .quiet()
+          .nothrow()
+          .cwd(sandbox)
+          .text()
+          .then((x) => path.resolve(sandbox, x.trim()))
+          .catch(() => undefined)
+
+        if (!top) {
+          return {
+            id,
+            sandbox,
+            worktree: sandbox,
+            vcs: Info.shape.vcs.parse(Flag.NIKCLI_FAKE_VCS),
+          }
+        }
+
+        sandbox = top
+
+        const worktree = commonGitDir ? cacheDirToWorktree(commonGitDir, sandbox) : undefined
+
+        if (!worktree) {
+          return {
+            id,
+            sandbox,
+            worktree: sandbox,
+            vcs: Info.shape.vcs.parse(Flag.NIKCLI_FAKE_VCS),
+          }
+        }
+
+        return {
+          id,
+          sandbox,
+          worktree,
+          vcs: "git",
+        }
+      }
+
+      return {
+        id: "global",
+        worktree: "/",
+        sandbox: "/",
+        vcs: Info.shape.vcs.parse(Flag.NIKCLI_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)
+      }
+    }
+
+    if (!existing.sandboxes) existing.sandboxes = []
+
+    if (Flag.NIKCLI_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)
+    result.sandboxes = result.sandboxes.filter((x) => existsSync(x))
+    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?.override) 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"])
+    const projects = await Promise.all(keys.map((x) => Storage.read<Info>(x)))
+    return projects.map((project) => ({
+      ...project,
+      sandboxes: project.sandboxes?.filter((x) => existsSync(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.override !== undefined) draft.icon.override = input.icon.override || undefined
+          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
+  }
+
+  export async function removeSandbox(projectID: string, directory: string) {
+    const result = await Storage.update<Info>(["project", projectID], (draft) => {
+      const sandboxes = draft.sandboxes ?? []
+      draft.sandboxes = sandboxes.filter((sandbox) => sandbox !== directory)
+      draft.time.updated = Date.now()
+    })
+    GlobalBus.emit("event", {
+      payload: {
+        type: Event.Updated.type,
+        properties: result,
+      },
+    })
+    return result
+  }
+}