@junwu168/openshell 0.1.0

package/dist/core/ssh/ssh-runtime.js

@@ -0,0 +1,240 @@
+import { constants as osConstants } from "node:os";
+import { Shescape } from "shescape";
+import { Client } from "ssh2";
+const shell = new Shescape({ shell: "zsh" });
+const DEFAULT_OPERATION_TIMEOUT_MS = 30_000;
+const normalizeShellPath = (path) => (path.startsWith("-") ? `./${path}` : path);
+const quoteShellPath = (path) => shell.quote(normalizeShellPath(path));
+const clampLimit = (limit) => Math.max(0, Math.trunc(limit));
+const joinRemotePath = (parent, name) => (parent.endsWith("/") ? `${parent}${name}` : `${parent}/${name}`);
+const signalToExitCode = (signal) => {
+    if (!signal) {
+        return 0;
+    }
+    const normalized = signal.startsWith("SIG") ? signal : `SIG${signal}`;
+    const signalNumber = osConstants.signals[normalized];
+    return signalNumber === undefined ? 1 : 128 + signalNumber;
+};
+const withClient = (connection, action, timeoutMs = null) => new Promise((resolve, reject) => {
+    const client = new Client();
+    let settled = false;
+    let timer = null;
+    const finish = (handler, close = () => 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 = {}) => {
+    const operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+    const exec = (connection, command, options = {}) => withClient(connection, (client) => new Promise((resolve, reject) => {
+        const effective = options.cwd ? `cd -- ${quoteShellPath(options.cwd)} && ${command}` : command;
+        let settled = false;
+        let streamRef = null;
+        const finish = (handler) => {
+            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) => {
+                stdout += chunk.toString();
+            });
+            stream.stderr.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            stream.on("exit", (code, signal) => {
+                exitCode = code ?? signalToExitCode(signal);
+            });
+            stream.on("close", () => {
+                finish(() => resolve({ stdout, stderr, exitCode }));
+            });
+            stream.on("error", (streamError) => {
+                finish(() => reject(streamError));
+            });
+        });
+    }), null);
+    const readFile = (connection, path) => withClient(connection, (client) => new Promise((resolve, reject) => {
+        client.sftp((error, sftp) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            const chunks = [];
+            const stream = sftp.createReadStream(path);
+            stream.on("data", (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            stream.on("error", reject);
+            stream.on("close", () => {
+                resolve(Buffer.concat(chunks).toString("utf8"));
+            });
+        });
+    }), operationTimeoutMs);
+    const writeFile = (connection, path, content, mode) => withClient(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, path, recursive = false, limit = 200) => {
+        const boundedLimit = clampLimit(limit);
+        if (boundedLimit === 0) {
+            return [];
+        }
+        if (recursive) {
+            return withClient(connection, (client) => new Promise((resolve, reject) => {
+                client.sftp((error, sftp) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    const statPath = (target) => new Promise((resolvePath, rejectPath) => {
+                        sftp.stat(target, (statError, stats) => {
+                            if (statError) {
+                                rejectPath(statError);
+                                return;
+                            }
+                            resolvePath(stats);
+                        });
+                    });
+                    const readDir = (target) => new Promise((resolvePath, rejectPath) => {
+                        sftp.readdir(target, (readError, entries) => {
+                            if (readError) {
+                                rejectPath(readError);
+                                return;
+                            }
+                            resolvePath(entries);
+                        });
+                    });
+                    const visit = async (target, output) => {
+                        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 = [];
+                            await visit(path, output);
+                            resolve(output);
+                        }
+                        catch (visitError) {
+                            reject(visitError);
+                        }
+                    })();
+                });
+            }), operationTimeoutMs);
+        }
+        return withClient(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, path) => withClient(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/dist/index.d.ts

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

package/dist/index.js

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

package/dist/opencode/plugin.d.ts

@@ -0,0 +1,10 @@
+import { type Plugin } from "@opencode-ai/plugin";
+import { createOrchestrator } from "../core/orchestrator";
+type RuntimeDependencies = Parameters<typeof createOrchestrator>[0];
+type OpenCodePluginOptions = {
+    ensureRuntimeDirs?: () => Promise<void>;
+    createRuntimeDependencies?: (workspaceRoot?: string) => RuntimeDependencies;
+};
+export declare const createOpenCodePlugin: (options?: OpenCodePluginOptions) => Plugin;
+export declare const OpenCodePlugin: Plugin;
+export {};

package/dist/opencode/plugin.js

@@ -0,0 +1,183 @@
+import { tool } 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 (result) => JSON.stringify(await result);
+const approvalRejected = (toolId, server, error) => 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, toolId, server, request) => {
+    if (!request) {
+        return null;
+    }
+    try {
+        await context.ask(request);
+        return null;
+    }
+    catch (error) {
+        return approvalRejected(toolId, server, error);
+    }
+};
+const createEditApproval = (toolId, input) => ({
+    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) => {
+    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) => ({
+    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) => {
+    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 = {}) => async (input) => {
+    await (options.ensureRuntimeDirs ?? ensureRuntimeDirs)();
+    const orchestrator = createOrchestrator((options.createRuntimeDependencies ?? buildRuntimeDependencies)(input.worktree));
+    return {
+        tool: createTools(orchestrator),
+    };
+};
+export const OpenCodePlugin = createOpenCodePlugin();

package/dist/product/install.d.ts

@@ -0,0 +1,12 @@
+import { createRuntimePaths } from "../core/paths.js";
+type WritableLike = {
+    write(chunk: string): void;
+};
+type RuntimePaths = ReturnType<typeof createRuntimePaths>;
+type InstallOptions = {
+    runtimePaths: RuntimePaths;
+    stdout: WritableLike;
+};
+export declare const installOpenShell: ({ runtimePaths, stdout }: InstallOptions) => Promise<void>;
+export declare const runInstallCli: (_argv?: string[], stream?: WritableLike) => Promise<number>;
+export {};

package/dist/product/install.js

@@ -0,0 +1,25 @@
+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";
+export const installOpenShell = async ({ runtimePaths, stdout }) => {
+    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 = [], stream = stdout) => {
+    await installOpenShell({
+        runtimePaths: createRuntimePaths(cwd()),
+        stdout: stream,
+    });
+    return 0;
+};

package/dist/product/opencode-config.d.ts

@@ -0,0 +1,15 @@
+export declare const defaultBashPermissions: {
+    readonly "*": "ask";
+    readonly "cat *": "allow";
+    readonly "grep *": "allow";
+    readonly "find *": "allow";
+    readonly "ls *": "allow";
+    readonly pwd: "allow";
+    readonly "uname *": "allow";
+    readonly "df *": "allow";
+    readonly "free *": "allow";
+    readonly "ps *": "allow";
+    readonly "systemctl status *": "allow";
+};
+export declare const installIntoOpenCodeConfig: (opencodeConfigFile: string) => Promise<void>;
+export declare const uninstallFromOpenCodeConfig: (opencodeConfigFile: string) => Promise<void>;

package/dist/product/opencode-config.js

@@ -0,0 +1,93 @@
+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",
+};
+const readConfig = async (opencodeConfigFile) => {
+    try {
+        return JSON.parse(await readFile(opencodeConfigFile, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+};
+const writeConfig = async (opencodeConfigFile, config) => {
+    await mkdir(dirname(opencodeConfigFile), { recursive: true });
+    await writeFile(opencodeConfigFile, JSON.stringify(config, null, 2) + "\n");
+};
+export const installIntoOpenCodeConfig = async (opencodeConfigFile) => {
+    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) => {
+    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 }
+        : 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 = { ...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/dist/product/uninstall.d.ts

@@ -0,0 +1,12 @@
+import { createRuntimePaths } from "../core/paths.js";
+type WritableLike = {
+    write(chunk: string): void;
+};
+type RuntimePaths = ReturnType<typeof createRuntimePaths>;
+type UninstallOptions = {
+    runtimePaths: RuntimePaths;
+    stdout: WritableLike;
+};
+export declare const uninstallOpenShell: ({ runtimePaths, stdout }: UninstallOptions) => Promise<void>;
+export declare const runUninstallCli: (_argv?: string[], stream?: WritableLike) => Promise<number>;
+export {};

package/dist/product/uninstall.js

@@ -0,0 +1,27 @@
+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";
+export const uninstallOpenShell = async ({ runtimePaths, stdout }) => {
+    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 = [], stream = stdout) => {
+    await uninstallOpenShell({
+        runtimePaths: createRuntimePaths(cwd()),
+        stdout: stream,
+    });
+    return 0;
+};

package/dist/product/workspace-tracker.d.ts

@@ -0,0 +1,11 @@
+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>;
+};
+export declare const createWorkspaceTracker: (trackerFile: string) => WorkspaceTracker;