@toolkit-cli/toolkode 1.3.8 → 1.3.10

package/test/plugin/meta.test.ts

@@ -1,137 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { pathToFileURL } from "url"
-
-import { tmpdir } from "../fixture/fixture"
-import { Process } from "../../src/util/process"
-import { Filesystem } from "../../src/util/filesystem"
-
-const { PluginMeta } = await import("../../src/plugin/meta")
-const root = path.join(import.meta.dir, "../..")
-const worker = path.join(import.meta.dir, "../fixture/plugin-meta-worker.ts")
-
-function run(input: { file: string; spec: string; target: string; id: string }) {
-  return Process.run([process.execPath, worker, JSON.stringify(input)], {
-    cwd: root,
-    nothrow: true,
-  })
-}
-
-async function map<Value>(file: string): Promise<Record<string, Value>> {
-  return Filesystem.readJson<Record<string, Value>>(file)
-}
-
-afterEach(() => {
-  delete process.env.OPENCODE_PLUGIN_META_FILE
-})
-
-describe("plugin.meta", () => {
-  test("tracks file plugin loads and changes", async () => {
-    await using tmp = await tmpdir<{ file: string }>({
-      init: async (dir) => {
-        const file = path.join(dir, "plugin.ts")
-        await Bun.write(file, "export default async () => ({})\n")
-        return { file }
-      },
-    })
-
-    process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "state", "plugin-meta.json")
-    const file = process.env.OPENCODE_PLUGIN_META_FILE!
-    const spec = pathToFileURL(tmp.extra.file).href
-
-    const one = await PluginMeta.touch(spec, spec, "demo.file")
-    expect(one.state).toBe("first")
-    expect(one.entry.source).toBe("file")
-    expect(one.entry.id).toBe("demo.file")
-    expect(one.entry.modified).toBeDefined()
-
-    const two = await PluginMeta.touch(spec, spec, "demo.file")
-    expect(two.state).toBe("same")
-    expect(two.entry.load_count).toBe(2)
-
-    await Bun.write(tmp.extra.file, "export default async () => ({ ok: true })\n")
-    const stamp = new Date(Date.now() + 10_000)
-    await fs.utimes(tmp.extra.file, stamp, stamp)
-
-    const three = await PluginMeta.touch(spec, spec, "demo.file")
-    expect(three.state).toBe("updated")
-    expect(three.entry.load_count).toBe(3)
-    expect((three.entry.modified ?? 0) > (one.entry.modified ?? 0)).toBe(true)
-
-    const all = await PluginMeta.list()
-    expect(Object.values(all).some((item) => item.spec === spec && item.source === "file")).toBe(true)
-    const saved = await map<{ spec: string; load_count: number }>(file)
-    expect(saved["demo.file"]?.spec).toBe(spec)
-    expect(saved["demo.file"]?.load_count).toBe(3)
-  })
-
-  test("tracks npm plugin versions", async () => {
-    await using tmp = await tmpdir<{ mod: string; pkg: string }>({
-      init: async (dir) => {
-        const mod = path.join(dir, "node_modules", "acme-plugin")
-        const pkg = path.join(mod, "package.json")
-        await fs.mkdir(mod, { recursive: true })
-        await Bun.write(pkg, JSON.stringify({ name: "acme-plugin", version: "1.0.0" }, null, 2))
-        return { mod, pkg }
-      },
-    })
-
-    process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "state", "plugin-meta.json")
-    const file = process.env.OPENCODE_PLUGIN_META_FILE!
-
-    const one = await PluginMeta.touch("acme-plugin@latest", tmp.extra.mod, "acme-plugin")
-    expect(one.state).toBe("first")
-    expect(one.entry.source).toBe("npm")
-    expect(one.entry.requested).toBe("latest")
-    expect(one.entry.version).toBe("1.0.0")
-
-    await Bun.write(tmp.extra.pkg, JSON.stringify({ name: "acme-plugin", version: "1.1.0" }, null, 2))
-
-    const two = await PluginMeta.touch("acme-plugin@latest", tmp.extra.mod, "acme-plugin")
-    expect(two.state).toBe("updated")
-    expect(two.entry.version).toBe("1.1.0")
-    expect(two.entry.load_count).toBe(2)
-
-    const all = await PluginMeta.list()
-    expect(Object.values(all).some((item) => item.id === "acme-plugin" && item.version === "1.1.0")).toBe(true)
-    const saved = await map<{ id: string; version?: string }>(file)
-    expect(Object.values(saved).some((item) => item.id === "acme-plugin" && item.version === "1.1.0")).toBe(true)
-  })
-
-  test("serializes concurrent metadata updates across processes", async () => {
-    await using tmp = await tmpdir<{ file: string }>({
-      init: async (dir) => {
-        const file = path.join(dir, "plugin.ts")
-        await Bun.write(file, "export default async () => ({})\n")
-        return { file }
-      },
-    })
-
-    process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "state", "plugin-meta.json")
-    const file = process.env.OPENCODE_PLUGIN_META_FILE!
-    const spec = pathToFileURL(tmp.extra.file).href
-    const n = 12
-
-    const out = await Promise.all(
-      Array.from({ length: n }, () =>
-        run({
-          file,
-          spec,
-          target: spec,
-          id: "demo.file",
-        }),
-      ),
-    )
-
-    expect(out.map((item) => item.code)).toEqual(Array.from({ length: n }, () => 0))
-    expect(out.map((item) => item.stderr.toString()).filter(Boolean)).toEqual([])
-
-    const all = await PluginMeta.list()
-    const hit = Object.values(all).find((item) => item.spec === spec)
-    expect(hit?.load_count).toBe(n)
-
-    const saved = await map<{ spec: string; load_count: number }>(file)
-    expect(Object.values(saved).find((item) => item.spec === spec)?.load_count).toBe(n)
-  }, 20_000)
-})

package/test/plugin/trigger.test.ts

@@ -1,111 +0,0 @@
-import { afterAll, afterEach, describe, expect, test } from "bun:test"
-import path from "path"
-import { pathToFileURL } from "url"
-import { tmpdir } from "../fixture/fixture"
-
-const disableDefault = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
-process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "1"
-
-const { Plugin } = await import("../../src/plugin/index")
-const { Instance } = await import("../../src/project/instance")
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-afterAll(() => {
-  if (disableDefault === undefined) {
-    delete process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
-    return
-  }
-  process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = disableDefault
-})
-
-async function project(source: string) {
-  return tmpdir({
-    init: async (dir) => {
-      const file = path.join(dir, "plugin.ts")
-      await Bun.write(file, source)
-      await Bun.write(
-        path.join(dir, "opencode.json"),
-        JSON.stringify(
-          {
-            $schema: "https://toolkode.com/config.json",
-            plugin: [pathToFileURL(file).href],
-          },
-          null,
-          2,
-        ),
-      )
-    },
-  })
-}
-
-describe("plugin.trigger", () => {
-  test("runs synchronous hooks without crashing", async () => {
-    await using tmp = await project(
-      [
-        "export default async () => ({",
-        '  "experimental.chat.system.transform": (_input, output) => {',
-        '    output.system.unshift("sync")',
-        "  },",
-        "})",
-        "",
-      ].join("\n"),
-    )
-
-    const out = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const out = { system: [] as string[] }
-        await Plugin.trigger(
-          "experimental.chat.system.transform",
-          {
-            model: {
-              providerID: "anthropic",
-              modelID: "claude-sonnet-4-6",
-            } as any,
-          },
-          out,
-        )
-        return out
-      },
-    })
-
-    expect(out.system).toEqual(["sync"])
-  })
-
-  test("awaits asynchronous hooks", async () => {
-    await using tmp = await project(
-      [
-        "export default async () => ({",
-        '  "experimental.chat.system.transform": async (_input, output) => {',
-        "    await Bun.sleep(1)",
-        '    output.system.unshift("async")',
-        "  },",
-        "})",
-        "",
-      ].join("\n"),
-    )
-
-    const out = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const out = { system: [] as string[] }
-        await Plugin.trigger(
-          "experimental.chat.system.transform",
-          {
-            model: {
-              providerID: "anthropic",
-              modelID: "claude-sonnet-4-6",
-            } as any,
-          },
-          out,
-        )
-        return out
-      },
-    })
-
-    expect(out.system).toEqual(["async"])
-  })
-})

package/test/preload.ts

@@ -1,90 +0,0 @@
-// IMPORTANT: Set env vars BEFORE any imports from src/ directory
-// xdg-basedir reads env vars at import time, so we must set these first
-import os from "os"
-import path from "path"
-import fs from "fs/promises"
-import { setTimeout as sleep } from "node:timers/promises"
-import { afterAll } from "bun:test"
-
-// Set XDG env vars FIRST, before any src/ imports
-const dir = path.join(os.tmpdir(), "opencode-test-data-" + process.pid)
-await fs.mkdir(dir, { recursive: true })
-afterAll(async () => {
-  const { Database } = await import("../src/storage/db")
-  Database.close()
-  const busy = (error: unknown) =>
-    typeof error === "object" && error !== null && "code" in error && error.code === "EBUSY"
-  const rm = async (left: number): Promise<void> => {
-    Bun.gc(true)
-    await sleep(100)
-    return fs.rm(dir, { recursive: true, force: true }).catch((error) => {
-      if (!busy(error)) throw error
-      if (left <= 1) throw error
-      return rm(left - 1)
-    })
-  }
-
-  // Windows can keep SQLite WAL handles alive until GC finalizers run, so we
-  // force GC and retry teardown to avoid flaky EBUSY in test cleanup.
-  await rm(30)
-})
-
-process.env["XDG_DATA_HOME"] = path.join(dir, "share")
-process.env["XDG_CACHE_HOME"] = path.join(dir, "cache")
-process.env["XDG_CONFIG_HOME"] = path.join(dir, "config")
-process.env["XDG_STATE_HOME"] = path.join(dir, "state")
-process.env["OPENCODE_MODELS_PATH"] = path.join(import.meta.dir, "tool", "fixtures", "models-api.json")
-
-// Set test home directory to isolate tests from user's actual home directory
-// This prevents tests from picking up real user configs/skills from ~/.claude/skills
-const testHome = path.join(dir, "home")
-await fs.mkdir(testHome, { recursive: true })
-process.env["OPENCODE_TEST_HOME"] = testHome
-
-// Set test managed config directory to isolate tests from system managed settings
-const testManagedConfigDir = path.join(dir, "managed")
-process.env["OPENCODE_TEST_MANAGED_CONFIG_DIR"] = testManagedConfigDir
-process.env["OPENCODE_DISABLE_DEFAULT_PLUGINS"] = "true"
-
-// Write the cache version file to prevent global/index.ts from clearing the cache
-const cacheDir = path.join(dir, "cache", "opencode")
-await fs.mkdir(cacheDir, { recursive: true })
-await fs.writeFile(path.join(cacheDir, "version"), "14")
-
-// Clear provider and server auth env vars to ensure clean test state
-delete process.env["ANTHROPIC_API_KEY"]
-delete process.env["OPENAI_API_KEY"]
-delete process.env["GOOGLE_API_KEY"]
-delete process.env["GOOGLE_GENERATIVE_AI_API_KEY"]
-delete process.env["AZURE_OPENAI_API_KEY"]
-delete process.env["AWS_ACCESS_KEY_ID"]
-delete process.env["AWS_PROFILE"]
-delete process.env["AWS_REGION"]
-delete process.env["AWS_BEARER_TOKEN_BEDROCK"]
-delete process.env["OPENROUTER_API_KEY"]
-delete process.env["GROQ_API_KEY"]
-delete process.env["MISTRAL_API_KEY"]
-delete process.env["PERPLEXITY_API_KEY"]
-delete process.env["TOGETHER_API_KEY"]
-delete process.env["XAI_API_KEY"]
-delete process.env["DEEPSEEK_API_KEY"]
-delete process.env["FIREWORKS_API_KEY"]
-delete process.env["CEREBRAS_API_KEY"]
-delete process.env["SAMBANOVA_API_KEY"]
-delete process.env["OPENCODE_SERVER_PASSWORD"]
-delete process.env["OPENCODE_SERVER_USERNAME"]
-
-// Use in-memory sqlite
-process.env["OPENCODE_DB"] = ":memory:"
-
-// Now safe to import from src/
-const { Log } = await import("../src/util/log")
-const { initProjectors } = await import("../src/server/projectors")
-
-Log.init({
-  print: false,
-  dev: true,
-  level: "DEBUG",
-})
-
-initProjectors()

package/test/project/migrate-global.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Project } from "../../src/project/project"
-import { Database, eq } from "../../src/storage/db"
-import { SessionTable } from "../../src/session/session.sql"
-import { ProjectTable } from "../../src/project/project.sql"
-import { ProjectID } from "../../src/project/schema"
-import { SessionID } from "../../src/session/schema"
-import { Log } from "../../src/util/log"
-import { $ } from "bun"
-import { tmpdir } from "../fixture/fixture"
-
-Log.init({ print: false })
-
-function uid() {
-  return SessionID.make(crypto.randomUUID())
-}
-
-function seed(opts: { id: SessionID; dir: string; project: ProjectID }) {
-  const now = Date.now()
-  Database.use((db) =>
-    db
-      .insert(SessionTable)
-      .values({
-        id: opts.id,
-        project_id: opts.project,
-        slug: opts.id,
-        directory: opts.dir,
-        title: "test",
-        version: "0.0.0-test",
-        time_created: now,
-        time_updated: now,
-      })
-      .run(),
-  )
-}
-
-function ensureGlobal() {
-  Database.use((db) =>
-    db
-      .insert(ProjectTable)
-      .values({
-        id: ProjectID.global,
-        worktree: "/",
-        time_created: Date.now(),
-        time_updated: Date.now(),
-        sandboxes: [],
-      })
-      .onConflictDoNothing()
-      .run(),
-  )
-}
-
-describe("migrateFromGlobal", () => {
-  test("migrates global sessions on first project creation", async () => {
-    // 1. Start with git init but no commits — creates "global" project row
-    await using tmp = await tmpdir()
-    await $`git init`.cwd(tmp.path).quiet()
-    await $`git config user.name "Test"`.cwd(tmp.path).quiet()
-    await $`git config user.email "test@opencode.test"`.cwd(tmp.path).quiet()
-    const { project: pre } = await Project.fromDirectory(tmp.path)
-    expect(pre.id).toBe(ProjectID.global)
-
-    // 2. Seed a session under "global" with matching directory
-    const id = uid()
-    seed({ id, dir: tmp.path, project: ProjectID.global })
-
-    // 3. Make a commit so the project gets a real ID
-    await $`git commit --allow-empty -m "root"`.cwd(tmp.path).quiet()
-
-    const { project: real } = await Project.fromDirectory(tmp.path)
-    expect(real.id).not.toBe(ProjectID.global)
-
-    // 4. The session should have been migrated to the real project ID
-    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-    expect(row).toBeDefined()
-    expect(row!.project_id).toBe(real.id)
-  })
-
-  test("migrates global sessions even when project row already exists", async () => {
-    // 1. Create a repo with a commit — real project ID created immediately
-    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
-    expect(project.id).not.toBe(ProjectID.global)
-
-    // 2. Ensure "global" project row exists (as it would from a prior no-git session)
-    ensureGlobal()
-
-    // 3. Seed a session under "global" with matching directory.
-    //    This simulates a session created before git init that wasn't
-    //    present when the real project row was first created.
-    const id = uid()
-    seed({ id, dir: tmp.path, project: ProjectID.global })
-
-    // 4. Call fromDirectory again — project row already exists,
-    //    so the current code skips migration entirely. This is the bug.
-    await Project.fromDirectory(tmp.path)
-
-    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-    expect(row).toBeDefined()
-    expect(row!.project_id).toBe(project.id)
-  })
-
-  test("does not claim sessions with empty directory", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
-    expect(project.id).not.toBe(ProjectID.global)
-
-    ensureGlobal()
-
-    // Legacy sessions may lack a directory value.
-    // Without a matching origin directory, they should remain global.
-    const id = uid()
-    seed({ id, dir: "", project: ProjectID.global })
-
-    await Project.fromDirectory(tmp.path)
-
-    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-    expect(row).toBeDefined()
-    expect(row!.project_id).toBe(ProjectID.global)
-  })
-
-  test("does not steal sessions from unrelated directories", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
-    expect(project.id).not.toBe(ProjectID.global)
-
-    ensureGlobal()
-
-    // Seed a session under "global" but for a DIFFERENT directory
-    const id = uid()
-    seed({ id, dir: "/some/other/dir", project: ProjectID.global })
-
-    await Project.fromDirectory(tmp.path)
-
-    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-    expect(row).toBeDefined()
-    // Should remain under "global" — not stolen
-    expect(row!.project_id).toBe(ProjectID.global)
-  })
-})