nolo-cli 0.1.23 → 0.1.29

package/server/handlers/execShellHandler.ts

@@ -0,0 +1,661 @@
+import { spawn as bunSpawn } from "bun";
+import { spawn as nodeSpawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+
+const JSON_HEADERS = {
+    "Content-Type": "application/json; charset=utf-8",
+};
+const SHELL_SESSION_IDLE_TTL_MS = 10 * 60_000;
+const SHELL_SESSION_EXITED_RETENTION_MS = 60_000;
+
+const PYTHON_PTY_BRIDGE = [
+    "import os, pty, select, sys",
+    "argv = sys.argv[1:]",
+    "pid, fd = pty.fork()",
+    "if pid == 0:",
+    "    os.execvp(argv[0], argv)",
+    "while True:",
+    "    readers, _, _ = select.select([fd, sys.stdin.buffer], [], [])",
+    "    if fd in readers:",
+    "        try:",
+    "            data = os.read(fd, 1024)",
+    "        except OSError:",
+    "            break",
+    "        if not data:",
+    "            break",
+    "        sys.stdout.buffer.write(data)",
+    "        sys.stdout.buffer.flush()",
+    "    if sys.stdin.buffer in readers:",
+    "        data = os.read(sys.stdin.fileno(), 1024)",
+    "        if not data:",
+    "            break",
+    "        os.write(fd, data)",
+].join("\n");
+
+type SupportedShell = "auto" | "bash" | "powershell";
+type ResolvedShell = "bash" | "powershell";
+
+type ExecShellRequestBody = {
+    command?: string;
+    cwd?: string;
+    interactive?: boolean;
+    pty?: boolean;
+    shell?: SupportedShell;
+    sessionId?: string;
+    input?: string;
+    close?: boolean;
+};
+
+type ShellRuntime = {
+    requestedShell: SupportedShell;
+    resolvedShell: ResolvedShell;
+    executable: string;
+    supportsPty: boolean;
+};
+
+type ExecShellSession = {
+    id: string;
+    command: string;
+    cwd: string;
+    pty: boolean;
+    requestedShell: SupportedShell;
+    resolvedShell: ResolvedShell;
+    stdout: string;
+    stderr: string;
+    pendingStdout: string;
+    pendingStderr: string;
+    running: boolean;
+    exitCode: number | null;
+    startedAt: number;
+    lastActiveAt: number;
+    endedAt: number | null;
+    proc: SpawnedShellProcess;
+};
+
+type SpawnStdioMode = "pipe" | "ignore";
+
+type SpawnedShellProcess = {
+    stdout: ReadableStream<Uint8Array> | null;
+    stderr: ReadableStream<Uint8Array> | null;
+    stdin: any;
+    exited: Promise<number>;
+    kill: () => void;
+};
+
+const shellSessions = new Map<string, ExecShellSession>();
+const POWERSHELL_CANDIDATES = ["pwsh", "powershell.exe", "powershell"];
+let bunSpawnImpl = bunSpawn;
+let nodeSpawnImpl = nodeSpawn;
+
+export function __setExecShellSpawnForTest(overrides: {
+    bunSpawn?: typeof bunSpawn;
+    nodeSpawn?: typeof nodeSpawn;
+}) {
+    if (overrides.bunSpawn) bunSpawnImpl = overrides.bunSpawn;
+    if (overrides.nodeSpawn) nodeSpawnImpl = overrides.nodeSpawn;
+}
+
+export function __resetExecShellSpawnForTest() {
+    bunSpawnImpl = bunSpawn;
+    nodeSpawnImpl = nodeSpawn;
+}
+
+function findExecutable(candidates: string[]): string | null {
+    for (const candidate of candidates) {
+        if (Bun.which(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+
+function wrapPowerShellCommand(command: string): string {
+    return [
+        "[Console]::InputEncoding=[System.Text.Encoding]::UTF8",
+        "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+        "$OutputEncoding=[System.Text.Encoding]::UTF8",
+        "$PSStyle.OutputRendering='PlainText'",
+        command,
+    ].join("; ");
+}
+
+export function resolveShellRuntime(
+    requestedShell: SupportedShell = "auto",
+    platform: NodeJS.Platform = process.platform
+): ShellRuntime {
+    if (requestedShell === "powershell") {
+        const executable = findExecutable(POWERSHELL_CANDIDATES);
+        if (!executable) {
+            throw new Error("当前环境不可用 PowerShell / pwsh。");
+        }
+        return {
+            requestedShell,
+            resolvedShell: "powershell",
+            executable,
+            supportsPty: false,
+        };
+    }
+
+    if (requestedShell === "bash") {
+        if (!Bun.which("bash")) {
+            throw new Error("当前环境不可用 bash。请安装 bash/WSL，或改用 execShell + shell='powershell'。");
+        }
+        return {
+            requestedShell,
+            resolvedShell: "bash",
+            executable: "bash",
+            supportsPty: true,
+        };
+    }
+
+    if (platform === "win32") {
+        const executable = findExecutable(POWERSHELL_CANDIDATES);
+        if (executable) {
+            return {
+                requestedShell,
+                resolvedShell: "powershell",
+                executable,
+                supportsPty: false,
+            };
+        }
+    }
+
+    if (!Bun.which("bash")) {
+        throw new Error("当前环境不可用 bash，且未找到可回退的 PowerShell。");
+    }
+    return {
+        requestedShell,
+        resolvedShell: "bash",
+        executable: "bash",
+        supportsPty: true,
+    };
+}
+
+export function shouldUseHiddenWindowsSpawn(
+    runtime: ShellRuntime
+): boolean {
+    return runtime.resolvedShell === "powershell";
+}
+
+export function containsDisallowedSearchCommand(rawCommand: string): boolean {
+    const normalized = rawCommand.replace(/\s+/g, " ").trim();
+    if (!normalized) return false;
+    if (/^(?:rtk\s+)?(?:rg|grep)(?:\.exe)?\s+(?:-V|--version)\s*$/i.test(normalized)) {
+        return false;
+    }
+
+    return /(^|[|;&(]\s*|&&\s*|\|\|\s*|\$\(\s*)(?:rtk\s+)?(?:rg|grep)\b/i.test(
+        normalized
+    );
+}
+
+function resolveCwdUnderProjectRoot(cwd?: string): string {
+    const projectRoot = process.cwd();
+    const requested = cwd && cwd.trim().length > 0 ? cwd : ".";
+    const absPath = resolve(projectRoot, requested);
+    const normalizedRoot = projectRoot.endsWith(sep)
+        ? projectRoot
+        : projectRoot + sep;
+
+    if (!absPath.startsWith(normalizedRoot) && absPath !== projectRoot) {
+        throw new Error("cwd 必须位于项目根目录内，禁止路径穿越。");
+    }
+
+    return absPath;
+}
+
+function buildNonInteractiveSpawnArgs(runtime: ShellRuntime, command: string): string[] {
+    if (runtime.resolvedShell === "powershell") {
+        return [
+            runtime.executable,
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            wrapPowerShellCommand(command),
+        ];
+    }
+    return [runtime.executable, "-lc", command];
+}
+
+function buildInteractiveSpawnArgs(runtime: ShellRuntime, command: string, wantsPty?: boolean): {
+    args: string[];
+    pty: boolean;
+} {
+    if (runtime.resolvedShell === "powershell") {
+        return {
+            args: [
+                runtime.executable,
+                "-NoLogo",
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                wrapPowerShellCommand(command),
+            ],
+            pty: false,
+        };
+    }
+
+    if (wantsPty) {
+        const pythonExecutable = Bun.which("python3") ? "python3" : Bun.which("python") ? "python" : null;
+        if (pythonExecutable) {
+            return {
+                args: [pythonExecutable, "-u", "-c", PYTHON_PTY_BRIDGE, runtime.executable, "-lc", `env TERM=dumb ${command}`],
+                pty: true,
+            };
+        }
+    }
+
+    return {
+        args: [runtime.executable, "-lc", command],
+        pty: false,
+    };
+}
+
+function buildExecResponse(session: ExecShellSession) {
+    return {
+        ok: true,
+        interactive: true,
+        pty: session.pty,
+        shell: session.resolvedShell,
+        requestedShell: session.requestedShell,
+        sessionId: session.id,
+        command: session.command,
+        cwd: session.cwd,
+        running: session.running,
+        exitCode: session.exitCode,
+        stdout: session.pendingStdout,
+        stderr: session.pendingStderr,
+        startedAt: session.startedAt,
+        lastActiveAt: session.lastActiveAt,
+        endedAt: session.endedAt,
+    };
+}
+
+function spawnShellProcess(args: string[], opts: {
+    cwd: string;
+    stdin: SpawnStdioMode;
+    stdout: "pipe";
+    stderr: "pipe";
+    runtime: ShellRuntime;
+}): SpawnedShellProcess {
+    if (shouldUseHiddenWindowsSpawn(opts.runtime)) {
+        const proc = nodeSpawnImpl(args[0]!, args.slice(1), {
+            cwd: opts.cwd,
+            windowsHide: true,
+            stdio: [opts.stdin, opts.stdout, opts.stderr],
+        });
+        return {
+            stdout: proc.stdout ? Readable.toWeb(proc.stdout) as ReadableStream<Uint8Array> : null,
+            stderr: proc.stderr ? Readable.toWeb(proc.stderr) as ReadableStream<Uint8Array> : null,
+            stdin: proc.stdin ?? null,
+            exited: new Promise<number>((resolve, reject) => {
+                proc.once("error", reject);
+                proc.once("close", (code) => {
+                    resolve(typeof code === "number" ? code : 1);
+                });
+            }),
+            kill: () => {
+                proc.kill();
+            },
+        };
+    }
+
+    const proc = bunSpawnImpl(args, {
+        cwd: opts.cwd,
+        stdin: opts.stdin,
+        stdout: opts.stdout,
+        stderr: opts.stderr,
+    });
+    return {
+        stdout: proc.stdout ?? null,
+        stderr: proc.stderr ?? null,
+        stdin: proc.stdin ?? null,
+        exited: proc.exited,
+        kill: () => {
+            proc.kill();
+        },
+    };
+}
+
+function readSessionOutput(session: ExecShellSession) {
+    session.lastActiveAt = Date.now();
+    const payload = buildExecResponse(session);
+    session.pendingStdout = "";
+    session.pendingStderr = "";
+    if (!session.running) {
+        shellSessions.delete(session.id);
+    }
+    return payload;
+}
+
+function pruneExpiredshellSessions(now = Date.now()) {
+    for (const [sessionId, session] of shellSessions.entries()) {
+        const idleFor = now - session.lastActiveAt;
+        const endedFor = session.endedAt ? now - session.endedAt : 0;
+
+        if (session.running && idleFor > SHELL_SESSION_IDLE_TTL_MS) {
+            try {
+                session.proc.kill();
+            } catch {
+                // ignore kill failures during cleanup
+            }
+            session.running = false;
+            session.endedAt = now;
+            session.pendingStderr += "[ExecShell] session expired due to inactivity.\n";
+            shellSessions.delete(sessionId);
+            continue;
+        }
+
+        if (!session.running && session.endedAt && endedFor > SHELL_SESSION_EXITED_RETENTION_MS) {
+            shellSessions.delete(sessionId);
+        }
+    }
+}
+
+function startInteractiveSessionWithOptions(
+    command: string,
+    cwd: string,
+    requestedShell: SupportedShell,
+    pty?: boolean
+) {
+    const runtime = resolveShellRuntime(requestedShell);
+    const shellSpawn = buildInteractiveSpawnArgs(runtime, command, pty);
+    const proc = spawnShellProcess(shellSpawn.args, {
+        cwd,
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        runtime,
+    });
+
+    const session: ExecShellSession = {
+        id: randomUUID(),
+        command,
+        cwd,
+        pty: shellSpawn.pty,
+        requestedShell,
+        resolvedShell: runtime.resolvedShell,
+        stdout: "",
+        stderr: "",
+        pendingStdout: "",
+        pendingStderr: "",
+        running: true,
+        exitCode: null,
+        startedAt: Date.now(),
+        lastActiveAt: Date.now(),
+        endedAt: null,
+        proc,
+    };
+
+    const appendStdout = (chunk: string) => {
+        session.stdout += chunk;
+        session.pendingStdout += chunk;
+    };
+    const appendStderr = (chunk: string) => {
+        session.stderr += chunk;
+        session.pendingStderr += chunk;
+    };
+
+    (async () => {
+        if (proc.stdout) {
+            const reader = proc.stdout.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    appendStdout(Buffer.from(value).toString());
+                }
+            } finally {
+                reader.releaseLock();
+            }
+        }
+    })().catch((error) => {
+        appendStderr(`[ExecShell stdout reader error] ${error instanceof Error ? error.message : String(error)}\n`);
+    });
+
+    (async () => {
+        if (proc.stderr) {
+            const reader = proc.stderr.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    appendStderr(Buffer.from(value).toString());
+                }
+            } finally {
+                reader.releaseLock();
+            }
+        }
+    })().catch((error) => {
+        appendStderr(`[ExecShell stderr reader error] ${error instanceof Error ? error.message : String(error)}\n`);
+    });
+
+    void proc.exited.then((exitCode) => {
+        session.running = false;
+        session.exitCode = exitCode;
+        session.endedAt = Date.now();
+    });
+
+    shellSessions.set(session.id, session);
+    return session;
+}
+
+export async function handleExecShell(req: Request): Promise<Response> {
+    try {
+        pruneExpiredshellSessions();
+        if (req.method !== "POST") {
+            return new Response(
+                JSON.stringify({ error: "Method not allowed" }),
+                { status: 405, headers: { ...JSON_HEADERS, Allow: "POST, OPTIONS" } }
+            );
+        }
+
+        let body: unknown;
+        try {
+            body = await req.json();
+        } catch {
+            return new Response(
+                JSON.stringify({ error: "请求体必须是合法的 JSON。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        const { command, cwd, interactive, pty, shell, sessionId, input, close }: Partial<ExecShellRequestBody> =
+            typeof body === "object" && body !== null ? (body as any) : {};
+        const requestedShell = shell ?? "auto";
+
+        if (requestedShell !== "auto" && requestedShell !== "bash" && requestedShell !== "powershell") {
+            return new Response(
+                JSON.stringify({ error: "执行失败：shell 仅支持 auto / bash / powershell。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        if (sessionId !== undefined && typeof sessionId !== "string") {
+            return new Response(
+                JSON.stringify({ error: "执行失败：sessionId 必须是字符串。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        if (input !== undefined && typeof input !== "string") {
+            return new Response(
+                JSON.stringify({ error: "执行失败：input 必须是字符串。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        if (sessionId) {
+            const session = shellSessions.get(sessionId);
+            if (!session) {
+                return new Response(
+                    JSON.stringify({ error: "执行失败：session 不存在或已结束。" }),
+                    { status: 404, headers: JSON_HEADERS }
+                );
+            }
+
+            if (input) {
+                if (!session.running || !session.proc.stdin) {
+                    return new Response(
+                        JSON.stringify({ error: "执行失败：session 已结束，无法继续写入 stdin。" }),
+                        { status: 400, headers: JSON_HEADERS }
+                    );
+                }
+                const encoded = new TextEncoder().encode(input);
+                const stdinTarget = session.proc.stdin as any;
+                if (typeof stdinTarget.getWriter === "function") {
+                    const writer = stdinTarget.getWriter();
+                    try {
+                        await writer.write(encoded);
+                    } finally {
+                        writer.releaseLock();
+                    }
+                } else if (typeof stdinTarget.write === "function") {
+                    await stdinTarget.write(encoded);
+                } else {
+                    return new Response(
+                        JSON.stringify({ error: "执行失败：当前 session stdin 不支持写入。" }),
+                        { status: 500, headers: JSON_HEADERS }
+                    );
+                }
+            }
+
+            if (close) {
+                if (session.running) {
+                    session.proc.kill();
+                    session.running = false;
+                    session.endedAt = Date.now();
+                }
+                const payload = readSessionOutput(session);
+                return new Response(JSON.stringify(payload), {
+                    status: 200,
+                    headers: JSON_HEADERS,
+                });
+            }
+
+            return new Response(JSON.stringify(readSessionOutput(session)), {
+                status: 200,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        if (!command || typeof command !== "string") {
+            return new Response(
+                JSON.stringify({
+                    error: "执行失败：必须提供有效的 command 字符串。",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        if (containsDisallowedSearchCommand(command)) {
+            return new Response(
+                JSON.stringify({
+                    error: "执行失败：shell 执行工具不允许执行 rg/grep 做内容搜索，请改用 codeSearch 工具。如果只是检查 rg 是否安装，请改用 where rg（Windows）或 command -v rg / which rg（Unix），不要继续重试 rg/grep。",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        if (cwd !== undefined && typeof cwd !== "string") {
+            return new Response(
+                JSON.stringify({ error: "执行失败：cwd 必须是字符串。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        let spawnCwd: string;
+        try {
+            spawnCwd = resolveCwdUnderProjectRoot(cwd);
+        } catch (e: any) {
+            return new Response(
+                JSON.stringify({ error: e?.message || "执行失败：cwd 无效。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        const RTK_COMMANDS = ["git", "ls", "cat", "find", "npm", "bun", "cargo", "pytest", "go", "tree", "diff", "docker"];
+        const firstWord = command.trim().split(/\s+/)[0];
+        const finalCommand = (Bun.which("rtk") && RTK_COMMANDS.includes(firstWord))
+            ? `rtk ${command}`
+            : command;
+
+        if (interactive) {
+            let session: ExecShellSession;
+            try {
+                session = startInteractiveSessionWithOptions(finalCommand, spawnCwd, requestedShell, pty);
+            } catch (error: any) {
+                return new Response(
+                    JSON.stringify({ error: error?.message || "执行失败：无法启动交互式 shell。" }),
+                    { status: 400, headers: JSON_HEADERS }
+                );
+            }
+            return new Response(
+                JSON.stringify(readSessionOutput(session)),
+                {
+                    status: 200,
+                    headers: JSON_HEADERS,
+                }
+            );
+        }
+
+        let runtime: ShellRuntime;
+        try {
+            runtime = resolveShellRuntime(requestedShell);
+        } catch (error: any) {
+            return new Response(
+                JSON.stringify({ error: error?.message || "执行失败：无法解析 shell 运行时。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        const proc = spawnShellProcess(buildNonInteractiveSpawnArgs(runtime, finalCommand), {
+            cwd: spawnCwd,
+            stdin: "ignore",
+            stdout: "pipe",
+            stderr: "pipe",
+            runtime,
+        });
+
+        const [stdout, stderr] = await Promise.all([
+            proc.stdout ? new Response(proc.stdout).text() : Promise.resolve(""),
+            proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
+        ]);
+
+        const exitCode = await proc.exited;
+
+        return new Response(
+            JSON.stringify({
+                ok: true,
+                command,
+                cwd: spawnCwd,
+                shell: runtime.resolvedShell,
+                requestedShell,
+                exitCode,
+                stdout,
+                stderr,
+            }),
+            {
+                status: 200,
+                headers: JSON_HEADERS,
+            }
+        );
+    } catch (error: any) {
+        console.error("[exec-shell] Error:", error);
+        return new Response(
+            JSON.stringify({
+                error: `执行 shell 命令失败：${error?.message || String(error)}`,
+            }),
+            {
+                status: 500,
+                headers: JSON_HEADERS,
+            }
+        );
+    }
+}