@junwu168/openshell 0.1.3 → 0.1.4

package/tests/unit/opencode-plugin.test.ts

@@ -1,358 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { access, mkdtemp, readFile, rm } from "node:fs/promises"
-import { chdir, cwd } from "node:process"
-import type { ToolContext } from "@opencode-ai/plugin"
-import { join } from "node:path"
-import { tmpdir } from "node:os"
-
-const toolNames = [
-  "list_servers",
-  "remote_exec",
-  "remote_read_file",
-  "remote_write_file",
-  "remote_patch_file",
-  "remote_list_dir",
-  "remote_stat",
-  "remote_find",
-]
-
-const createRuntimeDependencies = () => ({
-  registry: {
-    list: async () => [],
-    resolve: async () => ({
-      id: "prod-a",
-      host: "prod-a.example",
-      port: 22,
-      username: "open",
-      auth: {
-        kind: "password" as const,
-        secret: "openpass",
-      },
-    }),
-  },
-  ssh: {
-    exec: async () => ({ stdout: "", stderr: "", exitCode: 0 }),
-    readFile: async () => "",
-    writeFile: async () => {},
-    listDir: async () => [],
-    stat: async () => ({ size: 0, mode: 0o644, isFile: true, isDirectory: false }),
-  },
-  audit: {
-    preflightLog: async () => {},
-    appendLog: async () => {},
-    preflightSnapshots: async () => {},
-    captureSnapshots: async () => {},
-  },
-})
-
-const createToolContext = (overrides: Partial<ToolContext> = {}): ToolContext => ({
-  sessionID: "session-1",
-  messageID: "message-1",
-  agent: "default",
-  directory: "/tmp/project",
-  worktree: "/tmp/project",
-  abort: new AbortController().signal,
-  metadata: () => {},
-  ask: async () => {},
-  ...overrides,
-})
-
-const exists = async (path: URL) => {
-  try {
-    await access(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
-describe("OpenCode plugin", () => {
-  test("registers explicit remote tools in plan order and serializes results", async () => {
-    const { OpenCodePlugin } = await import("../../src/index")
-    const { createOpenCodePlugin } = await import("../../src/opencode/plugin")
-    const plugin = createOpenCodePlugin({
-      ensureRuntimeDirs: async () => {},
-      createRuntimeDependencies,
-    })
-
-    expect(typeof OpenCodePlugin).toBe("function")
-
-    const hooks = await plugin({
-      client: {} as never,
-      project: {} as never,
-      directory: "/tmp/project",
-      worktree: "/tmp/project",
-      serverUrl: new URL("http://localhost"),
-      $: {} as never,
-    })
-
-    expect(Object.keys(hooks.tool ?? {})).toEqual(toolNames)
-    expect(typeof hooks.tool?.list_servers?.execute).toBe("function")
-
-    const serialized = await hooks.tool?.list_servers?.execute({}, {} as never)
-    expect(JSON.parse(serialized ?? "null")).toMatchObject({
-      status: "ok",
-      tool: "list_servers",
-      data: [],
-      execution: { attempted: true, completed: true },
-      audit: { logWritten: true, snapshotStatus: "not-applicable" },
-    })
-  })
-
-  test("builds runtime dependencies from the plugin worktree", async () => {
-    const { createOpenCodePlugin } = await import("../../src/opencode/plugin")
-    const tempDir = await mkdtemp(join(tmpdir(), "opencode-plugin-root-"))
-    const originalCwd = cwd()
-    const workspaceRoots: Array<string | undefined> = []
-
-    try {
-      chdir(tempDir)
-
-      const plugin = createOpenCodePlugin({
-        ensureRuntimeDirs: async () => {},
-        createRuntimeDependencies: (workspaceRoot) => {
-          workspaceRoots.push(workspaceRoot)
-          return createRuntimeDependencies()
-        },
-      })
-
-      await plugin({
-        client: {} as never,
-        project: {} as never,
-        directory: "/tmp/project",
-        worktree: "/tmp/project-worktree",
-        serverUrl: new URL("http://localhost"),
-        $: {} as never,
-      })
-    } finally {
-      chdir(originalCwd)
-      await rm(tempDir, { recursive: true, force: true })
-    }
-
-    expect(workspaceRoots).toEqual(["/tmp/project-worktree"])
-  })
-
-  test("derives runtime registry paths from the OpenCode worktree at call time", async () => {
-    const tempDir = await mkdtemp(join(tmpdir(), "opencode-plugin-env-"))
-    const firstConfigDir = join(tempDir, "config-a")
-    const firstDataDir = join(tempDir, "data-a")
-    const secondConfigDir = join(tempDir, "config-b")
-    const secondDataDir = join(tempDir, "data-b")
-    const registryCalls: Array<Record<string, unknown>> = []
-    const runtimePathCalls: string[] = []
-
-    try {
-      mock.module("../../src/core/paths", () => ({
-        createRuntimePaths: (workspaceRoot: string) => {
-          runtimePathCalls.push(workspaceRoot)
-          return {
-            configDir: secondConfigDir,
-            dataDir: secondDataDir,
-            globalRegistryFile: join(secondConfigDir, "servers.json"),
-            workspaceRegistryFile: join(workspaceRoot, ".open-code", "servers.json"),
-            auditLogFile: join(secondDataDir, "audit", "actions.jsonl"),
-            auditRepoDir: join(secondDataDir, "audit", "repo"),
-          }
-        },
-        runtimePaths: {
-          configDir: firstConfigDir,
-          dataDir: firstDataDir,
-          globalRegistryFile: join(firstConfigDir, "servers.json"),
-          workspaceRegistryFile: join(firstConfigDir, ".open-code", "servers.json"),
-          auditLogFile: join(firstDataDir, "audit", "actions.jsonl"),
-          auditRepoDir: join(firstDataDir, "audit", "repo"),
-        },
-        workspaceRegistryFile: (workspaceRoot: string) => join(workspaceRoot, ".open-code", "servers.json"),
-        ensureRuntimeDirs: async () => {},
-      }))
-      mock.module("../../src/core/registry/server-registry", () => ({
-        createServerRegistry: (options: Record<string, unknown>) => {
-          registryCalls.push(options)
-          return createRuntimeDependencies().registry
-        },
-      }))
-      mock.module("../../src/core/audit/log-store", () => ({
-        createAuditLogStore: () => ({
-          preflight: async () => {},
-          append: async () => {},
-        }),
-      }))
-      mock.module("../../src/core/audit/git-audit-repo", () => ({
-        createGitAuditRepo: () => ({
-          preflight: async () => {},
-          captureChange: async () => {},
-        }),
-      }))
-      mock.module("../../src/core/ssh/ssh-runtime", () => ({
-        createSshRuntime: () => createRuntimeDependencies().ssh,
-      }))
-
-      const { createOpenCodePlugin } = await import("../../src/opencode/plugin?runtime-path-check")
-      const plugin = createOpenCodePlugin({
-        ensureRuntimeDirs: async () => {},
-      })
-
-      await plugin({
-        client: {} as never,
-        project: {} as never,
-        directory: "/tmp/project",
-        worktree: "/tmp/project-worktree",
-        serverUrl: new URL("http://localhost"),
-        $: {} as never,
-      })
-
-      expect(runtimePathCalls).toEqual(["/tmp/project-worktree"])
-      expect(registryCalls).toHaveLength(1)
-      expect(registryCalls[0]).toMatchObject({
-        globalRegistryFile: join(secondConfigDir, "servers.json"),
-        workspaceRegistryFile: "/tmp/project-worktree/.open-code/servers.json",
-        workspaceRoot: "/tmp/project-worktree",
-      })
-    } finally {
-      mock.restore()
-      await rm(tempDir, { recursive: true, force: true })
-    }
-  })
-
-  test("does not ask for approval before safe remote exec commands", async () => {
-    const { createOpenCodePlugin } = await import("../../src/opencode/plugin")
-    const asks: Array<Record<string, unknown>> = []
-    const plugin = createOpenCodePlugin({
-      ensureRuntimeDirs: async () => {},
-      createRuntimeDependencies,
-    })
-
-    const hooks = await plugin({
-      client: {} as never,
-      project: {} as never,
-      directory: "/tmp/project",
-      worktree: "/tmp/project",
-      serverUrl: new URL("http://localhost"),
-      $: {} as never,
-    })
-
-    await hooks.tool?.remote_exec?.execute(
-      {
-        server: "prod-a",
-        command: "cat /etc/hosts",
-      },
-      createToolContext({
-        ask: async (request) => {
-          asks.push(request)
-        },
-      }),
-    )
-
-    expect(asks).toHaveLength(0)
-  })
-
-  test("asks OpenCode for bash approval before approval-required remote exec commands", async () => {
-    const { createOpenCodePlugin } = await import("../../src/opencode/plugin")
-    const asks: Array<Record<string, unknown>> = []
-    const plugin = createOpenCodePlugin({
-      ensureRuntimeDirs: async () => {},
-      createRuntimeDependencies,
-    })
-
-    const hooks = await plugin({
-      client: {} as never,
-      project: {} as never,
-      directory: "/tmp/project",
-      worktree: "/tmp/project",
-      serverUrl: new URL("http://localhost"),
-      $: {} as never,
-    })
-
-    await hooks.tool?.remote_exec?.execute(
-      {
-        server: "prod-a",
-        command: "kubectl get pods",
-      },
-      createToolContext({
-        ask: async (request) => {
-          asks.push(request)
-        },
-      }),
-    )
-
-    expect(asks).toEqual([
-      expect.objectContaining({
-        permission: "bash",
-        patterns: ["kubectl get pods"],
-        always: [],
-        metadata: expect.objectContaining({
-          tool: "remote_exec",
-          server: "prod-a",
-          command: "kubectl get pods",
-        }),
-      }),
-    ])
-  })
-
-  test("asks OpenCode for edit approval before remote writes", async () => {
-    const { createOpenCodePlugin } = await import("../../src/opencode/plugin")
-    const asks: Array<Record<string, unknown>> = []
-    const plugin = createOpenCodePlugin({
-      ensureRuntimeDirs: async () => {},
-      createRuntimeDependencies,
-    })
-
-    const hooks = await plugin({
-      client: {} as never,
-      project: {} as never,
-      directory: "/tmp/project",
-      worktree: "/tmp/project",
-      serverUrl: new URL("http://localhost"),
-      $: {} as never,
-    })
-
-    await hooks.tool?.remote_write_file?.execute(
-      {
-        server: "prod-a",
-        path: "/tmp/open-code-smoke.txt",
-        content: "hello",
-      },
-      createToolContext({
-        ask: async (request) => {
-          asks.push(request)
-        },
-      }),
-    )
-
-    expect(asks).toEqual([
-      expect.objectContaining({
-        permission: "edit",
-        patterns: ["/tmp/open-code-smoke.txt"],
-        always: [],
-        metadata: expect.objectContaining({
-          tool: "remote_write_file",
-          server: "prod-a",
-          path: "/tmp/open-code-smoke.txt",
-        }),
-      }),
-    ])
-  })
-
-  test("uses built-in bash and edit permission families in the local OpenCode example config", async () => {
-    const raw = await readFile(new URL("../../examples/opencode-local/opencode.json", import.meta.url), "utf8")
-    const config = JSON.parse(raw)
-
-    expect(config.permission.edit).toBe("ask")
-    expect(config.permission.bash).toMatchObject({
-      "*": "ask",
-      "cat *": "allow",
-      "systemctl status *": "allow",
-    })
-    expect(config.permission.remote_write_file).toBeUndefined()
-    expect(config.permission.remote_exec).toBeUndefined()
-  })
-
-  test("removes the checked-in local smoke package in favor of the global install flow", async () => {
-    expect(
-      await exists(new URL("../../examples/opencode-local/.opencode/package.json", import.meta.url)),
-    ).toBe(false)
-    expect(
-      await exists(new URL("../../examples/opencode-local/.opencode/bun.lock", import.meta.url)),
-    ).toBe(false)
-  })
-})

package/tests/unit/openshell-cli.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-const createWritable = () => {
-  let buffer = ""
-
-  return {
-    write(chunk: string) {
-      buffer += chunk
-    },
-    toString() {
-      return buffer
-    },
-  }
-}
-
-describe("openshell cli", () => {
-  test("routes server-registry subcommands", async () => {
-    const stdout = createWritable()
-    const stderr = createWritable()
-    const serverRegistryCalls: string[][] = []
-    const { runOpenShellCli } = await import("../../src/cli/openshell")
-
-    await expect(
-      runOpenShellCli(["server-registry", "list"], {
-        stdout,
-        stderr,
-        runServerRegistryCli: async (argv: string[]) => {
-          serverRegistryCalls.push(argv)
-          return 0
-        },
-      }),
-    ).resolves.toBe(0)
-
-    expect(serverRegistryCalls).toEqual([["list"]])
-    expect(stdout.toString()).toBe("")
-    expect(stderr.toString()).toBe("")
-  })
-
-  test("prints top-level usage with no args", async () => {
-    const stdout = createWritable()
-    const stderr = createWritable()
-    const { runOpenShellCli } = await import("../../src/cli/openshell")
-
-    await expect(runOpenShellCli([], { stdout, stderr })).resolves.toBe(0)
-
-    expect(stdout.toString()).toContain("Usage: openshell")
-    expect(stderr.toString()).toBe("")
-  })
-
-  test("returns non-zero for unknown subcommands", async () => {
-    const stdout = createWritable()
-    const stderr = createWritable()
-    const { runOpenShellCli } = await import("../../src/cli/openshell")
-
-    await expect(runOpenShellCli(["wat"], { stdout, stderr })).resolves.toBe(1)
-
-    expect(stderr.toString()).toContain("Usage: openshell")
-    expect(stdout.toString()).toBe("")
-  })
-})

package/tests/unit/paths.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { mkdtemp, rm, stat } from "node:fs/promises"
-import { join } from "node:path"
-import { tmpdir } from "node:os"
-
-describe("runtime paths", () => {
-  test("runtime paths use openshell app directories and expose OpenCode config", async () => {
-    const tempRoot = await mkdtemp(join(tmpdir(), "opencode-paths-"))
-    try {
-      const openshellConfigDir = join(tempRoot, "openshell-config")
-      const openshellDataDir = join(tempRoot, "openshell-data")
-      const opencodeConfigDir = join(tempRoot, "opencode-config")
-
-      mock.module("env-paths", () => ({
-        default: (name: string) => {
-          if (name === "openshell") {
-            return { config: openshellConfigDir, data: openshellDataDir }
-          }
-
-          if (name === "opencode") {
-            return { config: opencodeConfigDir, data: join(tempRoot, "opencode-data") }
-          }
-
-          throw new Error(`unexpected env-paths name: ${name}`)
-        },
-      }))
-
-      const { createRuntimePaths, runtimePaths } = await import("../../src/core/paths?runtime-paths-test-1")
-      const runtime = createRuntimePaths("/repo")
-
-      expect(runtime.configDir).toBe(openshellConfigDir)
-      expect(runtime.dataDir).toBe(openshellDataDir)
-      expect(runtime.globalRegistryFile.endsWith("servers.json")).toBe(true)
-      expect(runtime.workspaceRegistryFile).toBe("/repo/.open-code/servers.json")
-      expect(runtime.opencodeConfigDir).toBe(opencodeConfigDir)
-      expect(runtime.opencodeConfigFile).toBe(join(opencodeConfigDir, "opencode.json"))
-      expect(runtimePaths.globalRegistryFile.endsWith("servers.json")).toBe(true)
-    } finally {
-      mock.restore()
-      await rm(tempRoot, { recursive: true, force: true })
-    }
-  })
-
-  test("ensureRuntimeDirs prepares the audit repo directory", async () => {
-    const tempRoot = await mkdtemp(join(tmpdir(), "opencode-paths-"))
-    try {
-      const configDir = join(tempRoot, "config")
-      const dataDir = join(tempRoot, "data")
-
-      mock.module("env-paths", () => ({
-        default: () => ({ config: configDir, data: dataDir }),
-      }))
-
-      const { ensureRuntimeDirs, runtimePaths } = await import("../../src/core/paths?runtime-paths-test-2")
-      await ensureRuntimeDirs()
-
-      const pathStat = await stat(runtimePaths.auditRepoDir)
-      expect(pathStat.isDirectory()).toBe(true)
-    } finally {
-      mock.restore()
-      await rm(tempRoot, { recursive: true, force: true })
-    }
-  })
-})

package/tests/unit/plugin-export.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import OpenShellPlugin, { OpenCodePlugin, OpenShellPlugin as NamedOpenShellPlugin } from "@junwu168/openshell"
-
-describe("package entry", () => {
-  test("exports the OpenShell plugin factory", () => {
-    expect(typeof OpenShellPlugin).toBe("function")
-    expect(typeof NamedOpenShellPlugin).toBe("function")
-    expect(typeof OpenCodePlugin).toBe("function")
-  })
-})

package/tests/unit/policy.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { classifyRemoteExec } from "../../src/core/policy"
-
-describe("remote exec policy", () => {
-  test("auto-allows simple linux inspection commands", () => {
-    expect(classifyRemoteExec("cat /etc/hosts")).toEqual({
-      decision: "auto-allow",
-      reason: "safe inspection command",
-    })
-  })
-
-  test("requires approval for middleware commands", () => {
-    expect(classifyRemoteExec("kubectl get pods -A")).toEqual({
-      decision: "approval-required",
-      reason: "middleware command",
-    })
-  })
-
-  test("requires approval for shell composition", () => {
-    expect(classifyRemoteExec("cat /etc/hosts | grep localhost")).toEqual({
-      decision: "approval-required",
-      reason: "shell composition",
-    })
-  })
-
-  test("rejects empty commands", () => {
-    expect(classifyRemoteExec("   ")).toEqual({
-      decision: "reject",
-      reason: "empty command",
-    })
-  })
-
-  test("auto-allows systemctl status inspection", () => {
-    expect(classifyRemoteExec("systemctl status nginx")).toEqual({
-      decision: "auto-allow",
-      reason: "safe inspection command",
-    })
-  })
-
-  test("does not auto-allow systemctl statusx", () => {
-    expect(classifyRemoteExec("systemctl statusx nginx")).toEqual({
-      decision: "approval-required",
-      reason: "unknown command",
-    })
-  })
-
-  test("requires approval for unknown commands", () => {
-    expect(classifyRemoteExec("uptime now")).toEqual({
-      decision: "approval-required",
-      reason: "unknown command",
-    })
-  })
-})

package/tests/unit/release-docs.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { access, readFile } from "node:fs/promises"
-
-const exists = async (path: string) => {
-  try {
-    await access(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
-describe("release docs", () => {
-  test("README documents the npm install and uninstall flow", async () => {
-    const readme = await readFile(new URL("../../README.md", import.meta.url), "utf8")
-
-    expect(readme).toContain("npm install -g @junwu168/openshell")
-    expect(readme).toContain("openshell install")
-    expect(readme).toContain("openshell server-registry add")
-    expect(readme).toContain("openshell uninstall")
-    expect(readme).toContain("opencode")
-  })
-
-  test("legacy local plugin shim is not part of the release example", async () => {
-    expect(
-      await exists(
-        new URL("../../examples/opencode-local/.opencode/plugins/open-code.ts", import.meta.url).pathname,
-      ),
-    ).toBe(false)
-  })
-})

package/tests/unit/result.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { errorResult, okResult, partialFailureResult } from "../../src/core/result"
-
-describe("tool result helpers", () => {
-  test("builds success payloads", () => {
-    expect(
-      okResult({
-        tool: "list_servers",
-        data: [],
-        execution: { attempted: true, completed: true },
-        audit: { logWritten: true, snapshotStatus: "not-applicable" },
-      }).status,
-    ).toBe("ok")
-  })
-
-  test("builds partial-failure payloads", () => {
-    expect(
-      partialFailureResult({
-        tool: "remote_write_file",
-        message: "remote write succeeded but git commit failed",
-      }).status,
-    ).toBe("partial_failure")
-  })
-
-  test("builds hard-error payloads", () => {
-    expect(errorResult({ tool: "remote_exec", code: "POLICY_REJECTED" }).status).toBe("error")
-  })
-})