office-core 0.1.0

package/.runtime-dist/scripts/lib/local-runner.js

@@ -0,0 +1,287 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+export async function runLocalRunner(input) {
+    if (input.runner === "codex") {
+        return runCodex(input);
+    }
+    return runClaude(input);
+}
+export function resolveRunnerCommand(kind, override) {
+    if (override?.trim()) {
+        return override.trim();
+    }
+    if (process.platform !== "win32") {
+        return kind;
+    }
+    const executableName = `${kind}.exe`;
+    const byExactExe = queryWhere(executableName);
+    if (byExactExe.length > 0) {
+        return byExactExe[0];
+    }
+    const byCommandName = queryWhere(kind);
+    const preferred = byCommandName.find((candidate) => candidate.toLowerCase().endsWith(".exe"));
+    if (preferred) {
+        return preferred;
+    }
+    const fallbacks = buildWindowsFallbacks(kind);
+    const direct = fallbacks.find((candidate) => existsSync(candidate));
+    if (direct) {
+        return direct;
+    }
+    return executableName;
+}
+export function probeRunnerAvailability(kind, override) {
+    const command = resolveRunnerCommand(kind, override);
+    if (process.platform === "win32") {
+        return { available: existsSync(command) || queryWhere(command).length > 0, command };
+    }
+    return { available: true, command };
+}
+async function runCodex(input) {
+    const outputDir = await mkdtemp(path.join(os.tmpdir(), "office-codex-"));
+    const command = resolveRunnerCommand("codex", process.env.CODEX_CMD);
+    const args = [
+        "exec",
+        "--json",
+        "--skip-git-repo-check",
+        "--dangerously-bypass-approvals-and-sandbox",
+        "-C",
+        input.workdir,
+        "-",
+    ];
+    const effort = normalizeEffort(input.effort);
+    if (effort) {
+        args.splice(args.length - 1, 0, "-c", `model_reasoning_effort="${effort}"`);
+    }
+    try {
+        return await runJsonProcess(command, args, input.workdir, input.prompt, "codex", input);
+    }
+    finally {
+        await rm(outputDir, { recursive: true, force: true });
+    }
+}
+async function runClaude(input) {
+    const command = resolveRunnerCommand("claude", process.env.CLAUDE_CMD);
+    const args = [
+        "-p",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages",
+        "--dangerously-skip-permissions",
+        "--add-dir",
+        input.workdir,
+    ];
+    const effort = normalizeEffort(input.effort);
+    if (effort) {
+        args.push("--effort", effort);
+    }
+    return runJsonProcess(command, args, input.workdir, input.prompt, "claude", input);
+}
+function queryWhere(command) {
+    const result = spawnSync("where.exe", [command], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        return [];
+    }
+    return String(result.stdout ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function buildWindowsFallbacks(kind) {
+    const localAppData = process.env.LOCALAPPDATA ?? "";
+    const appData = process.env.APPDATA ?? "";
+    const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+    if (kind === "codex") {
+        return [
+            path.join(localAppData, "OpenAI", "Codex", "bin", "codex.exe"),
+            path.join(localAppData, "Programs", "OpenAI", "Codex", "bin", "codex.exe"),
+            path.join(appData, "npm", "codex.cmd"),
+            path.join(programFiles, "WindowsApps", "OpenAI.Codex_26.325.3894.0_x64__2p2nqsd0c76g0", "app", "resources", "codex.exe"),
+        ];
+    }
+    return [
+        path.join(process.env.USERPROFILE ?? "", ".local", "bin", "claude.exe"),
+        path.join(appData, "npm", "claude.cmd"),
+    ];
+}
+async function runJsonProcess(command, args, cwd, stdinText, parserKind, input) {
+    const timeout_ms = input.timeout_ms ?? 15 * 60 * 1000;
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        let stdoutBuffer = "";
+        let resultText = "";
+        let sawPartial = false;
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Runner timed out after ${timeout_ms}ms`));
+        }, timeout_ms);
+        child.stdin.write(stdinText);
+        child.stdin.end();
+        child.stdout.on("data", (chunk) => {
+            const text = String(chunk);
+            stdout += text;
+            stdoutBuffer += text;
+            let newlineIndex = stdoutBuffer.indexOf("\n");
+            while (newlineIndex >= 0) {
+                const line = stdoutBuffer.slice(0, newlineIndex).trim();
+                stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+                if (line) {
+                    const parsed = parseRunnerJsonLine(parserKind, line, input);
+                    if (parsed.status) {
+                        input.onStatus?.(parsed.status);
+                    }
+                    if (parsed.partial) {
+                        sawPartial = true;
+                        resultText += parsed.partial;
+                        input.onPartial?.(parsed.partial);
+                    }
+                    if (parsed.finalText) {
+                        resultText = parsed.finalText;
+                    }
+                }
+                newlineIndex = stdoutBuffer.indexOf("\n");
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(summarizeRunnerFailure(code, stdout, stderr)));
+                return;
+            }
+            const trailing = stdoutBuffer.trim();
+            if (trailing) {
+                const parsed = parseRunnerJsonLine(parserKind, trailing, input);
+                if (parsed.status) {
+                    input.onStatus?.(parsed.status);
+                }
+                if (parsed.partial) {
+                    sawPartial = true;
+                    resultText += parsed.partial;
+                    input.onPartial?.(parsed.partial);
+                }
+                if (parsed.finalText) {
+                    resultText = parsed.finalText;
+                }
+            }
+            if (!resultText.trim() && !sawPartial) {
+                resultText = extractFallbackText(parserKind, stdout, stderr);
+            }
+            resolve(resultText.trim());
+        });
+    });
+}
+function normalizeEffort(value) {
+    if (value === "low" || value === "medium" || value === "high" || value === "max") {
+        return value;
+    }
+    return undefined;
+}
+function parseRunnerJsonLine(kind, line, input) {
+    try {
+        const payload = JSON.parse(line);
+        if (kind === "claude") {
+            return parseClaudeJsonLine(payload);
+        }
+        return parseCodexJsonLine(payload, input);
+    }
+    catch {
+        return {};
+    }
+}
+function parseClaudeJsonLine(payload) {
+    if (payload?.type === "stream_event") {
+        const event = payload.event;
+        if (event?.type === "content_block_delta" && event.delta?.type === "text_delta") {
+            return { partial: String(event.delta.text ?? "") };
+        }
+        if (event?.type === "message_start") {
+            return { status: "thinking" };
+        }
+    }
+    if (payload?.type === "assistant") {
+        const finalText = Array.isArray(payload.message?.content)
+            ? payload.message.content
+                .filter((entry) => entry?.type === "text")
+                .map((entry) => String(entry.text ?? ""))
+                .join("")
+            : "";
+        return finalText ? { finalText } : {};
+    }
+    if (payload?.type === "result" && typeof payload.result === "string") {
+        return { finalText: payload.result };
+    }
+    return {};
+}
+function parseCodexJsonLine(payload, input) {
+    if (payload?.type === "thread.started") {
+        return { status: "starting" };
+    }
+    if (payload?.type === "turn.started") {
+        return { status: "thinking" };
+    }
+    if (payload?.type === "item.completed" && payload.item?.type === "agent_message") {
+        const finalText = String(payload.item.text ?? "").trim();
+        return finalText ? { finalText } : {};
+    }
+    if (payload?.type === "turn.completed") {
+        return { status: "complete" };
+    }
+    if (payload?.type === "item.started" && payload.item?.type) {
+        return { status: String(payload.item.type) };
+    }
+    return {};
+}
+function extractFallbackText(kind, stdout, stderr) {
+    if (kind === "claude") {
+        const resultMatch = stdout.match(/"result":"([^"]*)"/);
+        if (resultMatch?.[1]) {
+            return resultMatch[1];
+        }
+    }
+    return (stdout || stderr).trim();
+}
+function summarizeRunnerFailure(code, stdout, stderr) {
+    const combined = `${stdout}\n${stderr}`.trim();
+    const lines = combined.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const usageLine = lines.find((line) => /usage limit|out of extra usage|try again at/i.test(line));
+    if (usageLine) {
+        return `Runner unavailable: ${usageLine}`;
+    }
+    const errorMessageLine = lines.find((line) => /"message":|^error[:\s]/i.test(line));
+    if (errorMessageLine) {
+        const cleaned = errorMessageLine
+            .replace(/^error[:\s]*/i, "")
+            .replace(/^.*"message":"?/, "")
+            .replace(/"}?[,]?$/, "")
+            .trim();
+        if (cleaned) {
+            return `Runner failed: ${cleaned}`;
+        }
+    }
+    return `Runner exited with code ${code}${combined ? `: ${truncateOneLine(combined)}` : ""}`;
+}
+function truncateOneLine(value, max = 220) {
+    const single = value.replace(/\s+/g, " ").trim();
+    return single.length <= max ? single : `${single.slice(0, max - 1)}…`;
+}