@junwu168/openshell 0.1.3 → 0.1.4

package/src/product/opencode-config.ts

@@ -1,118 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises"
-import { dirname } from "node:path"
-
-export const defaultBashPermissions = {
-  "*": "ask",
-  "cat *": "allow",
-  "grep *": "allow",
-  "find *": "allow",
-  "ls *": "allow",
-  pwd: "allow",
-  "uname *": "allow",
-  "df *": "allow",
-  "free *": "allow",
-  "ps *": "allow",
-  "systemctl status *": "allow",
-} as const
-
-type OpenCodeConfig = {
-  plugin?: string[]
-  permission?: {
-    edit?: unknown
-    bash?: unknown
-    [key: string]: unknown
-  }
-  [key: string]: unknown
-}
-
-const readConfig = async (opencodeConfigFile: string): Promise<OpenCodeConfig> => {
-  try {
-    return JSON.parse(await readFile(opencodeConfigFile, "utf8")) as OpenCodeConfig
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      return {}
-    }
-
-    throw error
-  }
-}
-
-const writeConfig = async (opencodeConfigFile: string, config: OpenCodeConfig) => {
-  await mkdir(dirname(opencodeConfigFile), { recursive: true })
-  await writeFile(opencodeConfigFile, JSON.stringify(config, null, 2) + "\n")
-}
-
-export const installIntoOpenCodeConfig = async (opencodeConfigFile: string) => {
-  const current = await readConfig(opencodeConfigFile)
-  const plugins = Array.isArray(current.plugin) ? [...current.plugin] : []
-  if (!plugins.includes("@junwu168/openshell")) {
-    plugins.push("@junwu168/openshell")
-  }
-
-  const currentPermissions =
-    typeof current.permission === "object" && current.permission !== null ? current.permission : {}
-  const currentBash =
-    typeof currentPermissions.bash === "object" && currentPermissions.bash !== null
-      ? currentPermissions.bash
-      : {}
-
-  await writeConfig(opencodeConfigFile, {
-    ...current,
-    plugin: plugins,
-    permission: {
-      ...currentPermissions,
-      edit: currentPermissions.edit ?? "ask",
-      bash: {
-        ...defaultBashPermissions,
-        ...currentBash,
-      },
-    },
-  })
-}
-
-export const uninstallFromOpenCodeConfig = async (opencodeConfigFile: string) => {
-  const current = await readConfig(opencodeConfigFile)
-  const plugins = Array.isArray(current.plugin)
-    ? current.plugin.filter((plugin) => plugin !== "@junwu168/openshell")
-    : []
-  const currentPermissions =
-    typeof current.permission === "object" && current.permission !== null ? { ...current.permission } : {}
-  const currentBash =
-    typeof currentPermissions.bash === "object" && currentPermissions.bash !== null
-      ? { ...(currentPermissions.bash as Record<string, unknown>) }
-      : null
-
-  if (currentBash) {
-    for (const [pattern, permission] of Object.entries(defaultBashPermissions)) {
-      if (currentBash[pattern] === permission) {
-        delete currentBash[pattern]
-      }
-    }
-
-    if (Object.keys(currentBash).length === 0) {
-      delete currentPermissions.bash
-    } else {
-      currentPermissions.bash = currentBash
-    }
-  }
-
-  if (currentPermissions.edit === "ask") {
-    delete currentPermissions.edit
-  }
-
-  const nextConfig: OpenCodeConfig = { ...current }
-
-  if (plugins.length > 0) {
-    nextConfig.plugin = plugins
-  } else {
-    delete nextConfig.plugin
-  }
-
-  if (Object.keys(currentPermissions).length > 0) {
-    nextConfig.permission = currentPermissions
-  } else {
-    delete nextConfig.permission
-  }
-
-  await writeConfig(opencodeConfigFile, nextConfig)
-}

package/src/product/uninstall.ts

@@ -1,47 +0,0 @@
-import { rm } from "node:fs/promises"
-import { cwd, stdout } from "node:process"
-import { createRuntimePaths } from "../core/paths.js"
-import { uninstallFromOpenCodeConfig } from "./opencode-config.js"
-import { createWorkspaceTracker } from "./workspace-tracker.js"
-
-type WritableLike = {
-  write(chunk: string): void
-}
-
-type RuntimePaths = ReturnType<typeof createRuntimePaths>
-
-type UninstallOptions = {
-  runtimePaths: RuntimePaths
-  stdout: WritableLike
-}
-
-export const uninstallOpenShell = async ({ runtimePaths, stdout }: UninstallOptions) => {
-  const tracker = createWorkspaceTracker(runtimePaths.workspaceTrackerFile)
-  const trackedWorkspaces = await tracker.list()
-
-  await uninstallFromOpenCodeConfig(runtimePaths.opencodeConfigFile)
-
-  for (const entry of trackedWorkspaces) {
-    await rm(entry.managedPath, { recursive: true, force: true })
-  }
-
-  await rm(runtimePaths.configDir, { recursive: true, force: true })
-  await rm(runtimePaths.dataDir, { recursive: true, force: true })
-
-  stdout.write(
-    [
-      "Removed openshell.",
-      `OpenShell config: ${runtimePaths.configDir}`,
-      `OpenShell data: ${runtimePaths.dataDir}`,
-    ].join("\n") + "\n",
-  )
-}
-
-export const runUninstallCli = async (_argv: string[] = [], stream: WritableLike = stdout) => {
-  await uninstallOpenShell({
-    runtimePaths: createRuntimePaths(cwd()),
-    stdout: stream,
-  })
-
-  return 0
-}

package/src/product/workspace-tracker.ts

@@ -1,69 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises"
-import { dirname } from "node:path"
-
-export type WorkspaceTrackerEntry = {
-  workspaceRoot: string
-  managedPath: string
-}
-
-export type WorkspaceTracker = {
-  list(): Promise<WorkspaceTrackerEntry[]>
-  record(entry: WorkspaceTrackerEntry): Promise<void>
-  remove(workspaceRoot: string): Promise<void>
-  clear(): Promise<void>
-}
-
-const readEntries = async (trackerFile: string): Promise<WorkspaceTrackerEntry[]> => {
-  try {
-    const raw = await readFile(trackerFile, "utf8")
-    const parsed = JSON.parse(raw) as unknown
-    if (!Array.isArray(parsed)) {
-      return []
-    }
-
-    return parsed.filter((entry): entry is WorkspaceTrackerEntry => {
-      if (typeof entry !== "object" || entry === null) {
-        return false
-      }
-
-      const candidate = entry as Record<string, unknown>
-      return typeof candidate.workspaceRoot === "string" && typeof candidate.managedPath === "string"
-    })
-  } catch (error: unknown) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      return []
-    }
-
-    throw error
-  }
-}
-
-const writeEntries = async (trackerFile: string, entries: WorkspaceTrackerEntry[]) => {
-  await mkdir(dirname(trackerFile), { recursive: true })
-  await writeFile(trackerFile, JSON.stringify(entries, null, 2) + "\n")
-}
-
-export const createWorkspaceTracker = (trackerFile: string): WorkspaceTracker => ({
-  async list() {
-    return readEntries(trackerFile)
-  },
-  async record(entry) {
-    const entries = await readEntries(trackerFile)
-    const next = [
-      ...entries.filter((existing) => existing.workspaceRoot !== entry.workspaceRoot),
-      entry,
-    ]
-
-    await writeEntries(trackerFile, next)
-  },
-  async remove(workspaceRoot) {
-    const entries = await readEntries(trackerFile)
-    await writeEntries(
-      trackerFile,
-      entries.filter((entry) => entry.workspaceRoot !== workspaceRoot),
-    )
-  },
-  async clear() {
-    await writeEntries(trackerFile, [])
-  },
-})

package/tests/integration/fake-ssh-server.ts

@@ -1,97 +0,0 @@
-import { Client, type ConnectConfig } from "ssh2"
-import { GenericContainer, Wait } from "testcontainers"
-
-const SSH_IMAGE = "linuxserver/openssh-server:10.2_p1-r0-ls219"
-
-const waitForSshReady = async (connection: ConnectConfig, timeoutMs = 15_000) => {
-  const deadline = Date.now() + timeoutMs
-  let lastError: unknown
-
-  while (Date.now() < deadline) {
-    try {
-      await new Promise<void>((resolve, reject) => {
-        const client = new Client()
-        let settled = false
-
-        const finish = (handler: () => void) => {
-          if (settled) {
-            return
-          }
-
-          settled = true
-          handler()
-          client.end()
-        }
-
-        client
-          .on("ready", () => finish(resolve))
-          .on("error", (error) => finish(() => reject(error)))
-          .connect({
-            ...connection,
-            readyTimeout: Math.min(2_000, Math.max(1, deadline - Date.now())),
-          })
-      })
-
-      return
-    } catch (error) {
-      lastError = error
-      await Bun.sleep(250)
-    }
-  }
-
-  throw lastError ?? new Error("ssh readiness timed out")
-}
-
-export const startFakeSshServer = async () => {
-  const container = await new GenericContainer(SSH_IMAGE)
-    .withCopyContentToContainer([
-      {
-        content: [
-          "#!/usr/bin/env sh",
-          "set -eu",
-          "",
-          "mkdir -p /tmp/open-code",
-          "chmod 1777 /tmp/open-code",
-          "cat <<'EOF' >/tmp/open-code/hosts",
-          "127.0.0.1 localhost",
-          "EOF",
-          "cat <<'EOF' >/tmp/open-code/app.conf",
-          "port=80",
-          "EOF",
-          "chown open:open /tmp/open-code/hosts /tmp/open-code/app.conf",
-          "chmod 0644 /tmp/open-code/hosts /tmp/open-code/app.conf",
-          "",
-        ].join("\n"),
-        target: "/custom-cont-init.d/10-seed-open-code.sh",
-        mode: 0o755,
-      },
-    ])
-    .withEnvironment({
-      USER_NAME: "open",
-      USER_PASSWORD: "openpass",
-      PASSWORD_ACCESS: "true",
-      SUDO_ACCESS: "false",
-    })
-    .withExposedPorts(2222)
-    .withWaitStrategy(Wait.forLogMessage("sshd is listening on port 2222"))
-    .start()
-
-  const connection = {
-    host: container.getHost(),
-    port: container.getMappedPort(2222),
-    username: "open",
-    password: "openpass",
-  }
-
-  try {
-    await waitForSshReady(connection)
-  } catch (error) {
-    await container.stop().catch(() => undefined)
-    throw error
-  }
-
-  return {
-    connection,
-    stop: () => container.stop(),
-  }
-}

package/tests/integration/install-lifecycle.test.ts

@@ -1,85 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-
-const tempDirs: string[] = []
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
-})
-
-const createWritable = () => {
-  let buffer = ""
-
-  return {
-    write(chunk: string) {
-      buffer += chunk
-    },
-    toString() {
-      return buffer
-    },
-  }
-}
-
-describe("openshell install lifecycle", () => {
-  test("install creates openshell state and uninstall removes tracked workspaces", async () => {
-    const tempDir = await mkdtemp(join(tmpdir(), "openshell-install-lifecycle-"))
-    tempDirs.push(tempDir)
-
-    const configDir = join(tempDir, "config", "openshell")
-    const dataDir = join(tempDir, "data", "openshell")
-    const opencodeConfigDir = join(tempDir, "config", "opencode")
-    const opencodeConfigFile = join(opencodeConfigDir, "opencode.json")
-    const workspaceRoot = join(tempDir, "workspace")
-    const managedPath = join(workspaceRoot, ".open-code")
-
-    await mkdir(managedPath, { recursive: true })
-    await writeFile(join(managedPath, "servers.json"), "[]")
-    await mkdir(opencodeConfigDir, { recursive: true })
-    await writeFile(opencodeConfigFile, JSON.stringify({ plugin: ["existing-plugin"] }))
-
-    const runtimePaths = {
-      configDir,
-      dataDir,
-      globalRegistryFile: join(configDir, "servers.json"),
-      workspaceTrackerFile: join(dataDir, "workspaces.json"),
-      opencodeConfigDir,
-      opencodeConfigFile,
-      workspaceRegistryDir: join(workspaceRoot, ".open-code"),
-      workspaceRegistryFile: join(workspaceRoot, ".open-code", "servers.json"),
-      auditLogFile: join(dataDir, "audit", "actions.jsonl"),
-      auditRepoDir: join(dataDir, "audit", "repo"),
-    }
-
-    const stdout = createWritable()
-    const { installOpenShell } = await import("../../src/product/install")
-    await installOpenShell({ runtimePaths, stdout })
-
-    const installedConfig = JSON.parse(await readFile(opencodeConfigFile, "utf8"))
-    expect(installedConfig.plugin).toContain("@junwu168/openshell")
-    expect(stdout.toString()).toContain("Installed openshell")
-
-    const trackerFile = join(dataDir, "workspaces.json")
-    await writeFile(
-      trackerFile,
-      JSON.stringify([
-        {
-          workspaceRoot,
-          managedPath,
-        },
-      ]),
-    )
-
-    const uninstallStdout = createWritable()
-    const { uninstallOpenShell } = await import("../../src/product/uninstall")
-    await uninstallOpenShell({ runtimePaths, stdout: uninstallStdout })
-
-    await expect(readFile(opencodeConfigFile, "utf8")).resolves.toContain("existing-plugin")
-    await expect(readFile(opencodeConfigFile, "utf8")).resolves.not.toContain("@junwu168/openshell")
-    await expect(rm(managedPath, { recursive: false })).rejects.toMatchObject({ code: "ENOENT" })
-    await expect(rm(configDir, { recursive: false })).rejects.toMatchObject({ code: "ENOENT" })
-    await expect(rm(dataDir, { recursive: false })).rejects.toMatchObject({ code: "ENOENT" })
-    expect(uninstallStdout.toString()).toContain("Removed openshell")
-  })
-})