@junwu168/openshell 0.1.2 → 0.1.4

package/src/core/ssh/ssh-runtime.ts

@@ -1,355 +0,0 @@
-import { constants as osConstants } from "node:os"
-import { Shescape } from "shescape"
-import { Client, type ConnectConfig } from "ssh2"
-
-const shell = new Shescape({ shell: "zsh" })
-const DEFAULT_OPERATION_TIMEOUT_MS = 30_000
-
-type ExecOptions = {
-  cwd?: string
-  timeout?: number
-}
-
-type ExecResult = {
-  stdout: string
-  stderr: string
-  exitCode: number
-}
-
-type DirEntry = {
-  name: string
-  longname: string
-}
-
-type PathStat = {
-  size: number
-  mode: number
-  isFile: boolean
-  isDirectory: boolean
-}
-
-type RuntimeOptions = {
-  operationTimeoutMs?: number
-}
-
-const normalizeShellPath = (path: string) => (path.startsWith("-") ? `./${path}` : path)
-const quoteShellPath = (path: string) => shell.quote(normalizeShellPath(path))
-const clampLimit = (limit: number) => Math.max(0, Math.trunc(limit))
-const joinRemotePath = (parent: string, name: string) => (parent.endsWith("/") ? `${parent}${name}` : `${parent}/${name}`)
-const signalToExitCode = (signal: string | null | undefined) => {
-  if (!signal) {
-    return 0
-  }
-
-  const normalized = signal.startsWith("SIG") ? signal : `SIG${signal}`
-  const signalNumber = osConstants.signals[normalized as keyof typeof osConstants.signals]
-
-  return signalNumber === undefined ? 1 : 128 + signalNumber
-}
-
-const withClient = <T>(
-  connection: ConnectConfig,
-  action: (client: Client) => Promise<T>,
-  timeoutMs: number | null = null,
-) =>
-  new Promise<T>((resolve, reject) => {
-    const client = new Client()
-    let settled = false
-    let timer: ReturnType<typeof setTimeout> | null = null
-
-    const finish = (handler: () => void, close: () => void = () => client.end()) => {
-      if (settled) {
-        return
-      }
-
-      settled = true
-      if (timer) {
-        clearTimeout(timer)
-      }
-      handler()
-      close()
-    }
-
-    if (timeoutMs !== null) {
-      timer = setTimeout(() => {
-        finish(() => reject(new Error(`ssh operation timed out after ${timeoutMs}ms`)), () => client.destroy())
-      }, timeoutMs)
-    }
-
-    client
-      .on("ready", () => {
-        action(client).then(
-          (result) => finish(() => resolve(result)),
-          (error) => finish(() => reject(error)),
-        )
-      })
-      .on("error", (error) => finish(() => reject(error)))
-      .connect(timeoutMs === null ? connection : { ...connection, readyTimeout: connection.readyTimeout ?? timeoutMs })
-  })
-
-export const createSshRuntime = (options: RuntimeOptions = {}) => {
-  const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS
-
-  const exec = (connection: ConnectConfig, command: string, options: ExecOptions = {}) =>
-    withClient<ExecResult>(connection, (client) =>
-      new Promise((resolve, reject) => {
-        const effective = options.cwd ? `cd -- ${quoteShellPath(options.cwd)} && ${command}` : command
-        let settled = false
-        let streamRef: {
-          signal: (signalName: string) => void
-          close: () => void
-        } | null = null
-
-        const finish = (handler: () => void) => {
-          if (settled) {
-            return
-          }
-
-          settled = true
-
-          if (timer) {
-            clearTimeout(timer)
-          }
-
-          handler()
-        }
-
-        const timer =
-          options.timeout === undefined
-            ? null
-            : setTimeout(() => {
-                if (streamRef) {
-                  try {
-                    streamRef.signal("SIGKILL")
-                  } catch {}
-
-                  try {
-                    streamRef.close()
-                  } catch {}
-                }
-
-                finish(() => reject(new Error(`command timed out after ${options.timeout}ms`)))
-              }, options.timeout)
-
-        client.exec(effective, (error, stream) => {
-          if (error) {
-            finish(() => reject(error))
-            return
-          }
-
-          streamRef = stream
-
-          let stdout = ""
-          let stderr = ""
-          let exitCode = 0
-
-          stream.on("data", (chunk: Buffer | string) => {
-            stdout += chunk.toString()
-          })
-
-          stream.stderr.on("data", (chunk: Buffer | string) => {
-            stderr += chunk.toString()
-          })
-
-          stream.on("exit", (code, signal) => {
-            exitCode = code ?? signalToExitCode(signal)
-          })
-
-          stream.on("close", () => {
-            finish(() => resolve({ stdout, stderr, exitCode }))
-          })
-
-          stream.on("error", (streamError: Error) => {
-            finish(() => reject(streamError))
-          })
-        })
-      }),
-      null,
-    )
-
-  const readFile = (connection: ConnectConfig, path: string) =>
-    withClient<string>(connection, (client) =>
-      new Promise((resolve, reject) => {
-        client.sftp((error, sftp) => {
-          if (error) {
-            reject(error)
-            return
-          }
-
-          const chunks: Buffer[] = []
-          const stream = sftp.createReadStream(path)
-
-          stream.on("data", (chunk: Buffer | string) => {
-            chunks.push(Buffer.from(chunk))
-          })
-          stream.on("error", reject)
-          stream.on("close", () => {
-            resolve(Buffer.concat(chunks).toString("utf8"))
-          })
-        })
-      }),
-      operationTimeoutMs,
-    )
-
-  const writeFile = (connection: ConnectConfig, path: string, content: string, mode?: number) =>
-    withClient<void>(connection, (client) =>
-      new Promise((resolve, reject) => {
-        client.sftp((error, sftp) => {
-          if (error) {
-            reject(error)
-            return
-          }
-
-          const stream = sftp.createWriteStream(path, mode === undefined ? undefined : { mode })
-
-          stream.on("error", reject)
-          stream.on("close", () => resolve())
-          stream.end(content)
-        })
-      }),
-      operationTimeoutMs,
-    )
-
-  const listDir = async (connection: ConnectConfig, path: string, recursive = false, limit = 200) => {
-    const boundedLimit = clampLimit(limit)
-
-    if (boundedLimit === 0) {
-      return []
-    }
-
-    if (recursive) {
-      return withClient<string[]>(connection, (client) =>
-        new Promise((resolve, reject) => {
-          client.sftp((error, sftp) => {
-            if (error) {
-              reject(error)
-              return
-            }
-
-            const statPath = (target: string) =>
-              new Promise<any>((resolvePath, rejectPath) => {
-                sftp.stat(target, (statError, stats) => {
-                  if (statError) {
-                    rejectPath(statError)
-                    return
-                  }
-
-                  resolvePath(stats)
-                })
-              })
-
-            const readDir = (target: string) =>
-              new Promise<any[]>((resolvePath, rejectPath) => {
-                sftp.readdir(target, (readError, entries) => {
-                  if (readError) {
-                    rejectPath(readError)
-                    return
-                  }
-
-                  resolvePath(entries)
-                })
-              })
-
-            const visit = async (target: string, output: string[]) => {
-              if (output.length >= boundedLimit) {
-                return
-              }
-
-              output.push(target)
-
-              if (output.length >= boundedLimit) {
-                return
-              }
-
-              const targetStats = await statPath(target)
-              if (!targetStats.isDirectory()) {
-                return
-              }
-
-              const entries = await readDir(target)
-
-              for (const entry of entries) {
-                if (entry.filename === "." || entry.filename === "..") {
-                  continue
-                }
-
-                const fullPath = joinRemotePath(target, entry.filename)
-
-                if (entry.attrs.isDirectory()) {
-                  await visit(fullPath, output)
-                } else if (output.length < boundedLimit) {
-                  output.push(fullPath)
-                }
-
-                if (output.length >= boundedLimit) {
-                  return
-                }
-              }
-            }
-
-            void (async () => {
-              try {
-                const output: string[] = []
-                await visit(path, output)
-                resolve(output)
-              } catch (visitError) {
-                reject(visitError)
-              }
-            })()
-          })
-        }),
-        operationTimeoutMs,
-      )
-    }
-
-    return withClient<DirEntry[]>(connection, (client) =>
-      new Promise((resolve, reject) => {
-        client.sftp((error, sftp) => {
-          if (error) {
-            reject(error)
-            return
-          }
-
-          sftp.readdir(path, (readError, entries) => {
-            if (readError) {
-              reject(readError)
-              return
-            }
-
-            resolve(entries.slice(0, boundedLimit).map((entry) => ({ name: entry.filename, longname: entry.longname })))
-          })
-        })
-      }),
-      operationTimeoutMs,
-    )
-  }
-
-  const stat = (connection: ConnectConfig, path: string) =>
-    withClient<PathStat>(connection, (client) =>
-      new Promise((resolve, reject) => {
-        client.sftp((error, sftp) => {
-          if (error) {
-            reject(error)
-            return
-          }
-
-          sftp.stat(path, (statError, stats) => {
-            if (statError) {
-              reject(statError)
-              return
-            }
-
-            resolve({
-              size: stats.size,
-              mode: stats.mode,
-              isFile: stats.isFile(),
-              isDirectory: stats.isDirectory(),
-            })
-          })
-        })
-      }),
-      operationTimeoutMs,
-    )
-
-  return { exec, readFile, writeFile, listDir, stat }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { OpenCodePlugin, OpenCodePlugin as OpenShellPlugin } from "./opencode/plugin"
-export { OpenCodePlugin as default } from "./opencode/plugin"
-export * from "./core/contracts"

package/src/opencode/plugin.ts

@@ -1,242 +0,0 @@
-import { tool, type Plugin, type ToolContext } from "@opencode-ai/plugin"
-import { createAuditLogStore } from "../core/audit/log-store"
-import { createGitAuditRepo } from "../core/audit/git-audit-repo"
-import { createOrchestrator } from "../core/orchestrator"
-import { classifyRemoteExec } from "../core/policy"
-import { createRuntimePaths, ensureRuntimeDirs } from "../core/paths"
-import { createServerRegistry } from "../core/registry/server-registry"
-import { errorResult } from "../core/result"
-import { createSshRuntime } from "../core/ssh/ssh-runtime"
-
-const serialize = async <T>(result: Promise<T>) => JSON.stringify(await result)
-type RuntimeDependencies = Parameters<typeof createOrchestrator>[0]
-type OpenCodePluginOptions = {
-  ensureRuntimeDirs?: () => Promise<void>
-  createRuntimeDependencies?: (workspaceRoot?: string) => RuntimeDependencies
-}
-
-type ApprovalRequest = Parameters<ToolContext["ask"]>[0]
-
-const approvalRejected = (toolId: string, server: string, error: unknown) =>
-  JSON.stringify(
-    errorResult({
-      tool: toolId,
-      server,
-      code: "APPROVAL_REJECTED",
-      message: error instanceof Error ? error.message : "approval rejected",
-      execution: { attempted: false, completed: false },
-      audit: { logWritten: false, snapshotStatus: "not-applicable" },
-    }),
-  )
-
-const requestApproval = async (
-  context: ToolContext,
-  toolId: string,
-  server: string,
-  request: ApprovalRequest | null,
-) => {
-  if (!request) {
-    return null
-  }
-
-  try {
-    await context.ask(request)
-    return null
-  } catch (error) {
-    return approvalRejected(toolId, server, error)
-  }
-}
-
-const createEditApproval = (
-  toolId: "remote_write_file" | "remote_patch_file",
-  input: { server: string; path: string; mode?: number; patch?: string; content?: string },
-): ApprovalRequest => ({
-  permission: "edit",
-  patterns: [input.path],
-  always: [],
-  metadata: {
-    tool: toolId,
-    server: input.server,
-    path: input.path,
-    mode: input.mode,
-    contentBytes: input.content ? Buffer.byteLength(input.content) : undefined,
-    patchBytes: input.patch ? Buffer.byteLength(input.patch) : undefined,
-  },
-})
-
-const createRemoteExecApproval = (input: {
-  server: string
-  command: string
-  cwd?: string
-  timeout?: number
-}): ApprovalRequest | null => {
-  const classification = classifyRemoteExec(input.command)
-  if (classification.decision !== "approval-required") {
-    return null
-  }
-
-  return {
-    permission: "bash",
-    patterns: [input.command],
-    always: [],
-    metadata: {
-      tool: "remote_exec",
-      server: input.server,
-      command: input.command,
-      cwd: input.cwd,
-      timeout: input.timeout,
-      reason: classification.reason,
-    },
-  }
-}
-
-const createTools = (orchestrator: ReturnType<typeof createOrchestrator>) => ({
-  list_servers: tool({
-    description: "List configured remote servers.",
-    args: {},
-    execute: async () => serialize(orchestrator.listServers()),
-  }),
-  remote_exec: tool({
-    description: "Execute a shell command on a remote server.",
-    args: {
-      server: tool.schema.string(),
-      command: tool.schema.string(),
-      cwd: tool.schema.string().optional(),
-      timeout: tool.schema.number().int().positive().optional(),
-    },
-    execute: async ({ server, command, cwd, timeout }, context) => {
-      const rejected = await requestApproval(
-        context,
-        "remote_exec",
-        server,
-        createRemoteExecApproval({ server, command, cwd, timeout }),
-      )
-      if (rejected) {
-        return rejected
-      }
-
-      return serialize(orchestrator.remoteExec({ server, command, cwd, timeout }))
-    },
-  }),
-  remote_read_file: tool({
-    description: "Read a remote file.",
-    args: {
-      server: tool.schema.string(),
-      path: tool.schema.string(),
-      offset: tool.schema.number().int().nonnegative().optional(),
-      length: tool.schema.number().int().positive().optional(),
-    },
-    execute: async ({ server, path, offset, length }) =>
-      serialize(orchestrator.remoteReadFile({ server, path, offset, length })),
-  }),
-  remote_write_file: tool({
-    description: "Write content to a remote file.",
-    args: {
-      server: tool.schema.string(),
-      path: tool.schema.string(),
-      content: tool.schema.string(),
-      mode: tool.schema.number().int().positive().optional(),
-    },
-    execute: async ({ server, path, content, mode }, context) => {
-      const rejected = await requestApproval(
-        context,
-        "remote_write_file",
-        server,
-        createEditApproval("remote_write_file", { server, path, content, mode }),
-      )
-      if (rejected) {
-        return rejected
-      }
-
-      return serialize(orchestrator.remoteWriteFile({ server, path, content, mode }))
-    },
-  }),
-  remote_patch_file: tool({
-    description: "Apply a unified diff to a remote file.",
-    args: {
-      server: tool.schema.string(),
-      path: tool.schema.string(),
-      patch: tool.schema.string(),
-    },
-    execute: async ({ server, path, patch }, context) => {
-      const rejected = await requestApproval(
-        context,
-        "remote_patch_file",
-        server,
-        createEditApproval("remote_patch_file", { server, path, patch }),
-      )
-      if (rejected) {
-        return rejected
-      }
-
-      return serialize(orchestrator.remotePatchFile({ server, path, patch }))
-    },
-  }),
-  remote_list_dir: tool({
-    description: "List a remote directory.",
-    args: {
-      server: tool.schema.string(),
-      path: tool.schema.string(),
-      recursive: tool.schema.boolean().optional(),
-      limit: tool.schema.number().int().positive().optional(),
-    },
-    execute: async ({ server, path, recursive, limit }) =>
-      serialize(orchestrator.remoteListDir({ server, path, recursive, limit })),
-  }),
-  remote_stat: tool({
-    description: "Stat a remote path.",
-    args: {
-      server: tool.schema.string(),
-      path: tool.schema.string(),
-    },
-    execute: async ({ server, path }) => serialize(orchestrator.remoteStat({ server, path })),
-  }),
-  remote_find: tool({
-    description: "Search a remote directory for matching files or content.",
-    args: {
-      server: tool.schema.string(),
-      path: tool.schema.string(),
-      pattern: tool.schema.string(),
-      glob: tool.schema.string().optional(),
-      limit: tool.schema.number().int().positive().optional(),
-    },
-    execute: async ({ server, path, pattern, glob, limit }) =>
-      serialize(orchestrator.remoteFind({ server, path, pattern, glob, limit })),
-  }),
-})
-
-const buildRuntimeDependencies = (workspaceRoot: string): RuntimeDependencies => {
-  const paths = createRuntimePaths(workspaceRoot)
-  const registry = createServerRegistry({
-    globalRegistryFile: paths.globalRegistryFile,
-    workspaceRegistryFile: paths.workspaceRegistryFile,
-    workspaceRoot,
-  })
-  const auditLog = createAuditLogStore(paths.auditLogFile)
-  const auditRepo = createGitAuditRepo(paths.auditRepoDir)
-
-  return {
-    registry,
-    ssh: createSshRuntime(),
-    audit: {
-      preflightLog: () => auditLog.preflight(),
-      appendLog: (entry) => auditLog.append(entry),
-      preflightSnapshots: () => auditRepo.preflight(),
-      captureSnapshots: (input) => auditRepo.captureChange(input),
-    },
-  }
-}
-
-export const createOpenCodePlugin = (options: OpenCodePluginOptions = {}): Plugin => async (input) => {
-  await (options.ensureRuntimeDirs ?? ensureRuntimeDirs)()
-
-  const orchestrator = createOrchestrator(
-    (options.createRuntimeDependencies ?? buildRuntimeDependencies)(input.worktree),
-  )
-
-  return {
-    tool: createTools(orchestrator),
-  }
-}
-
-export const OpenCodePlugin: Plugin = createOpenCodePlugin()

package/src/product/install.ts

@@ -1,43 +0,0 @@
-import { mkdir } from "node:fs/promises"
-import { cwd, stdout } from "node:process"
-import { createRuntimePaths } from "../core/paths.js"
-import { installIntoOpenCodeConfig } from "./opencode-config.js"
-import { createWorkspaceTracker } from "./workspace-tracker.js"
-
-type WritableLike = {
-  write(chunk: string): void
-}
-
-type RuntimePaths = ReturnType<typeof createRuntimePaths>
-
-type InstallOptions = {
-  runtimePaths: RuntimePaths
-  stdout: WritableLike
-}
-
-export const installOpenShell = async ({ runtimePaths, stdout }: InstallOptions) => {
-  await mkdir(runtimePaths.configDir, { recursive: true })
-  await mkdir(runtimePaths.dataDir, { recursive: true })
-  await mkdir(runtimePaths.opencodeConfigDir, { recursive: true })
-
-  await installIntoOpenCodeConfig(runtimePaths.opencodeConfigFile)
-  await createWorkspaceTracker(runtimePaths.workspaceTrackerFile).clear()
-
-  stdout.write(
-    [
-      "Installed openshell.",
-      `OpenShell config: ${runtimePaths.configDir}`,
-      `OpenShell data: ${runtimePaths.dataDir}`,
-      `OpenCode config: ${runtimePaths.opencodeConfigFile}`,
-    ].join("\n") + "\n",
-  )
-}
-
-export const runInstallCli = async (_argv: string[] = [], stream: WritableLike = stdout) => {
-  await installOpenShell({
-    runtimePaths: createRuntimePaths(cwd()),
-    stdout: stream,
-  })
-
-  return 0
-}