@abitat_reece/host-daemon 0.1.0

package/dist/remote-control/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../src/remote-control/manager.ts"],"names":[],"mappings":"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"}

package/dist/runtime/adapter.d.ts

@@ -0,0 +1,27 @@
+import type { RunEventType, Runtime } from "@abitat_reece/shared";
+export interface RuntimeEvent {
+    type: Extract<RunEventType, "error" | "status" | "stdout" | "stderr" | "summary">;
+    content: string;
+}
+export interface RuntimeRunInput {
+    worktreePath: string;
+    prompt: string;
+    model?: string;
+    instructions: string;
+    conversationId?: string;
+    allowedTools?: string[];
+    resumeSessionId?: string;
+    skipGitRepoCheck?: boolean;
+}
+export interface RuntimeAvailability {
+    installed: boolean;
+    version?: string;
+    path?: string;
+    reason?: string;
+}
+export interface RuntimeAdapter {
+    name: Runtime;
+    isAvailable(): Promise<RuntimeAvailability>;
+    run(input: RuntimeRunInput, emit: (event: RuntimeEvent) => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/runtime/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/runtime/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAElE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC,CAAC;IAClF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC5C,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1F"}

package/dist/runtime/adapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.js.map

package/dist/runtime/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/runtime/adapter.ts"],"names":[],"mappings":""}

package/dist/runtime/cli.d.ts

@@ -0,0 +1,41 @@
+import type { RuntimeAdapter, RuntimeAvailability } from "./adapter.js";
+export declare const terminalShellPidMarker = "__ABITAT_SHELL_PID__";
+type CliRuntimeName = "codex" | "claude";
+type CliOutput = {
+    type: "stdout" | "stderr" | "summary";
+    content: string;
+};
+interface CliRunOptions {
+    cwd: string;
+    stdin: string;
+}
+export interface TerminalLaunchInput {
+    scriptPath: string;
+    logPath: string;
+    exitMarker: string;
+}
+interface TerminalCliRuntimeRunnerInput {
+    check?: (command: string) => Promise<RuntimeAvailability>;
+    launch?: (input: TerminalLaunchInput) => Promise<void>;
+    isProcessAlive?: (pid: number) => Promise<boolean>;
+    startupTimeoutMs?: number;
+}
+export interface CliRuntimeRunner {
+    interactive: boolean;
+    check(command: string): Promise<RuntimeAvailability>;
+    run(command: string, args: string[], options: CliRunOptions, emit: (event: CliOutput) => Promise<void>): Promise<number>;
+}
+interface CliRuntimeAdapterInput {
+    name: CliRuntimeName;
+    command: string;
+    runner?: CliRuntimeRunner;
+}
+export declare function createCodexRuntimeAdapter(): RuntimeAdapter;
+export declare function createClaudeRuntimeAdapter(): RuntimeAdapter;
+export declare function createCliRuntimeAdapter(input: CliRuntimeAdapterInput): RuntimeAdapter;
+export declare const defaultCliRuntimeRunner: CliRuntimeRunner;
+export declare function createTerminalCliRuntimeRunner(input?: TerminalCliRuntimeRunnerInput): CliRuntimeRunner;
+type ExecFileAsync = (file: string, args: string[]) => Promise<unknown>;
+export declare function launchITerm2Script(input: TerminalLaunchInput, execFileAsyncImpl?: ExecFileAsync): Promise<void>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/runtime/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/runtime/cli.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAmB,MAAM,cAAc,CAAC;AAczF,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAE7D,KAAK,cAAc,GAAG,OAAO,GAAG,QAAQ,CAAC;AACzC,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,6BAA6B;IACrC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC1D,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrD,GAAG,CACD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GACxC,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB;AAED,UAAU,sBAAsB;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED,wBAAgB,yBAAyB,mBAMxC;AAED,wBAAgB,0BAA0B,mBAMzC;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,sBAAsB,GAAG,cAAc,CAyCrF;AAED,eAAO,MAAM,uBAAuB,EAAE,gBAiDrC,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,KAAK,GAAE,6BAAkC,GACxC,gBAAgB,CA4DlB;AAwBD,KAAK,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAExE,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,iBAAiB,GAAE,aAA6B,iBAoBjD"}

package/dist/runtime/cli.js

@@ -0,0 +1,540 @@
+import { execFile, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { chmod, mkdtemp, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const ESCAPE_CHARACTER = String.fromCharCode(27);
+const BELL_CHARACTER = String.fromCharCode(7);
+const CONTROL_CHARACTER_PATTERN = new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(8)}${String.fromCharCode(11)}${String.fromCharCode(12)}${String.fromCharCode(14)}-${String.fromCharCode(31)}${String.fromCharCode(127)}]`, "g");
+const ANSI_CSI_PATTERN = new RegExp(`${ESCAPE_CHARACTER}\\[[0-?]*[ -/]*[@-~]`, "g");
+const ANSI_OSC_PATTERN = new RegExp(`${ESCAPE_CHARACTER}\\][^${BELL_CHARACTER}]*(?:${BELL_CHARACTER}|${ESCAPE_CHARACTER}\\\\)`, "g");
+export const terminalShellPidMarker = "__ABITAT_SHELL_PID__";
+export function createCodexRuntimeAdapter() {
+    return createCliRuntimeAdapter({
+        name: "codex",
+        command: "codex",
+        runner: defaultRunnerForAgentCli()
+    });
+}
+export function createClaudeRuntimeAdapter() {
+    return createCliRuntimeAdapter({
+        name: "claude",
+        command: "claude",
+        runner: defaultRunnerForAgentCli()
+    });
+}
+export function createCliRuntimeAdapter(input) {
+    const runner = input.runner ?? defaultCliRuntimeRunner;
+    return {
+        name: input.name,
+        isAvailable() {
+            return runner.check(input.command);
+        },
+        async run(runInput, emit) {
+            const availability = await runner.check(input.command);
+            let lastOutput = "";
+            if (!availability.installed) {
+                throw new Error(availability.reason ?? `${input.name} CLI is unavailable`);
+            }
+            await emit({ type: "status", content: `${input.name} runtime starting` });
+            const exitCode = await runner.run(input.command, runtimeArgs(input.name, runInput, runner.interactive), {
+                cwd: runInput.worktreePath,
+                stdin: runtimePrompt(runInput)
+            }, async (event) => {
+                if (event.content.trim().length > 0) {
+                    lastOutput = event.content.trim();
+                }
+                await emit(event);
+            });
+            if (exitCode !== 0) {
+                const details = lastOutput ? `: ${lastOutput}` : "";
+                throw new Error(`${input.name} exited with code ${exitCode}${details}`);
+            }
+            await emit({ type: "status", content: `${input.name} runtime completed` });
+        }
+    };
+}
+export const defaultCliRuntimeRunner = {
+    interactive: false,
+    async check(command) {
+        try {
+            const { stdout: path } = await execFileAsync("which", [command]);
+            const version = await readVersion(command);
+            return {
+                installed: true,
+                path: path.trim(),
+                ...(version ? { version } : {})
+            };
+        }
+        catch {
+            return {
+                installed: false,
+                reason: `${command} CLI is unavailable on the host.`
+            };
+        }
+    },
+    run(command, args, options, emit) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd: options.cwd,
+                stdio: ["pipe", "pipe", "pipe"]
+            });
+            const flushStdout = createLineEmitter("stdout", emit);
+            const flushStderr = createLineEmitter("stderr", emit);
+            const queue = createAsyncQueue();
+            child.stdout.on("data", (chunk) => {
+                queue.add(() => flushStdout.write(chunk.toString("utf8")));
+            });
+            child.stderr.on("data", (chunk) => {
+                queue.add(() => flushStderr.write(chunk.toString("utf8")));
+            });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                queue
+                    .add(async () => {
+                    await flushStdout.close();
+                    await flushStderr.close();
+                })
+                    .then(() => resolve(code ?? 1))
+                    .catch(reject);
+            });
+            child.stdin.end(options.stdin);
+        });
+    }
+};
+export function createTerminalCliRuntimeRunner(input = {}) {
+    const check = input.check ?? defaultCliRuntimeRunner.check;
+    const launch = input.launch ?? launchITerm2Script;
+    const isProcessAlive = input.isProcessAlive ?? defaultIsProcessAlive;
+    const startupTimeoutMs = input.startupTimeoutMs ?? 15_000;
+    return {
+        interactive: true,
+        check,
+        async run(command, args, options, emit) {
+            const availability = await check(command);
+            const startedAt = Date.now();
+            if (!availability.installed) {
+                return 127;
+            }
+            const runDir = await mkdtemp(join(tmpdir(), "abitat-terminal-runtime-"));
+            const logPath = join(runDir, "runtime.log");
+            const promptPath = join(runDir, "prompt.txt");
+            const scriptPath = join(runDir, `${command}.command`);
+            const exitMarker = `__ABITAT_EXIT_${randomUUID()}__`;
+            const commandPath = availability.path ?? command;
+            await writeFile(promptPath, options.stdin, "utf8");
+            await writeFile(logPath, "", "utf8");
+            await writeFile(scriptPath, terminalScript({
+                args,
+                commandName: command,
+                commandPath,
+                cwd: options.cwd,
+                exitMarker,
+                logPath,
+                promptPath
+            }), "utf8");
+            await chmod(scriptPath, 0o700);
+            const watch = watchTerminalLog(logPath, exitMarker, emit, {
+                isProcessAlive,
+                startupTimeoutMs
+            });
+            await launch({ scriptPath, logPath, exitMarker });
+            const { exitCode, sawSessionId } = await watch;
+            const sessionId = command === "codex" && isInteractiveCodexArgs(args)
+                ? await findLatestCodexSessionId(options.cwd, startedAt)
+                : null;
+            if (sessionId && !sawSessionId) {
+                await emit({ type: "stdout", content: `session id: ${sessionId}` });
+            }
+            return exitCode;
+        }
+    };
+}
+function defaultRunnerForAgentCli() {
+    if (process.env.ABITAT_CLI_RUNTIME_MODE === "inline" || process.platform !== "darwin") {
+        console.log("runtime runner: inline (hidden)");
+        return defaultCliRuntimeRunner;
+    }
+    console.log("runtime runner: terminal (visible window)");
+    return createTerminalCliRuntimeRunner();
+}
+function createAsyncQueue() {
+    let current = Promise.resolve();
+    return {
+        add(task) {
+            const next = current.then(task, task);
+            current = next.catch(() => undefined);
+            return next;
+        }
+    };
+}
+export async function launchITerm2Script(input, execFileAsyncImpl = execFileAsync) {
+    const command = shellQuote(input.scriptPath);
+    const script = [
+        'tell application "iTerm2"',
+        "activate",
+        "if (count of windows) = 0 then",
+        "set newWindow to create window with default profile",
+        "set targetSession to current session of newWindow",
+        "else",
+        "tell current window",
+        "set newTab to create tab with default profile",
+        "set targetSession to current session of newTab",
+        "end tell",
+        "end if",
+        `tell targetSession to write text ${appleScriptString(command)}`,
+        "end tell"
+    ].join("\n");
+    await execFileAsyncImpl("osascript", ["-e", script]);
+}
+function terminalScript(input) {
+    const usesPrompt = usesPromptFile(input.commandName, input.args);
+    const command = terminalCommand(input.commandName, input.commandPath, input.args, input.promptPath);
+    const holdOpen = process.env.ABITAT_TERMINAL_HOLD_OPEN !== "0";
+    const capturesOutput = capturesTerminalOutput(input.commandName, input.args);
+    const lines = [
+        "#!/bin/bash",
+        "set +e",
+        `cd ${shellQuote(input.cwd)}`,
+        `echo "${terminalShellPidMarker}:$$" >> ${shellQuote(input.logPath)}`,
+        terminalLogLine("Abitat Workspace terminal runtime", input.logPath, capturesOutput),
+        terminalLogLine(`cwd: ${input.cwd}`, input.logPath, capturesOutput),
+        terminalLogLine(`command: ${command}`, input.logPath, capturesOutput),
+        capturesOutput ? `echo ""` : "clear",
+        ...(usesPrompt
+            ? [`echo "--- Task ---"`, `cat ${shellQuote(input.promptPath)}`, `echo ""`]
+            : []),
+        ...(capturesOutput ? [`echo "--- Starting Codex CLI ---"`, `echo ""`] : []),
+        capturesOutput
+            ? // Use `script` to give noninteractive CLI runs a real pseudo-terminal
+                // while capturing output for the daemon to stream to the web UI.
+                `script -q -a ${shellQuote(input.logPath)} /bin/bash -lc ${shellQuote(command)}`
+            : command,
+        "status=$?",
+        `echo "${input.exitMarker}:$status" >> ${shellQuote(input.logPath)}`,
+        'echo ""',
+        'echo "--- Agent finished (exit $status) ---"',
+        ...(holdOpen ? ['read -p "Press enter to close this window..."'] : []),
+        "exit $status",
+        ""
+    ];
+    return lines.join("\n");
+}
+function terminalLogLine(line, logPath, echoToTerminal) {
+    const escaped = escapeDoubleQuoted(line);
+    const log = shellQuote(logPath);
+    return echoToTerminal ? `echo "${escaped}" | tee -a ${log}` : `echo "${escaped}" >> ${log}`;
+}
+function terminalCommand(commandName, commandPath, args, promptPath) {
+    if (commandName === "codex" && args[0] === "exec") {
+        const promptArgs = args.at(-1) === "-" ? args.slice(0, -1) : args;
+        return [
+            shellQuote(commandPath),
+            ...promptArgs.map(shellQuote),
+            `"$(cat ${shellQuote(promptPath)})"`
+        ].join(" ");
+    }
+    if (commandName === "codex") {
+        return [commandPath, ...args].map(shellQuote).join(" ");
+    }
+    return `${[commandPath, ...args].map(shellQuote).join(" ")} < ${shellQuote(promptPath)}`;
+}
+function usesPromptFile(commandName, args) {
+    return commandName !== "codex" || args[0] === "exec";
+}
+function capturesTerminalOutput(commandName, args) {
+    return commandName !== "codex" || args[0] === "exec";
+}
+async function watchTerminalLog(logPath, exitMarker, emit, options) {
+    let offset = 0;
+    let buffered = "";
+    let shellPid = null;
+    let sawSessionId = false;
+    const startedAt = Date.now();
+    const emittedLines = [];
+    while (true) {
+        const text = await readFile(logPath, "utf8").catch(() => "");
+        const chunk = text.slice(offset);
+        offset = text.length;
+        if (chunk) {
+            buffered += chunk;
+            const lines = buffered.split(/\r?\n/);
+            buffered = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.startsWith(`${terminalShellPidMarker}:`)) {
+                    shellPid = Number(line.slice(terminalShellPidMarker.length + 1)) || null;
+                    continue;
+                }
+                if (line.startsWith(`${exitMarker}:`)) {
+                    const summary = summarizeTerminalLines(emittedLines);
+                    if (summary) {
+                        await emit({ type: "summary", content: summary });
+                    }
+                    return {
+                        exitCode: Number(line.slice(exitMarker.length + 1)) || 0,
+                        sawSessionId
+                    };
+                }
+                if (line.length > 0) {
+                    emittedLines.push(line);
+                    await emit({ type: "stdout", content: line });
+                    const sessionId = parseTerminalSessionId(line);
+                    if (sessionId) {
+                        sawSessionId = true;
+                        if (!/^session id:/i.test(cleanTerminalLine(line))) {
+                            await emit({ type: "stdout", content: `session id: ${sessionId}` });
+                        }
+                    }
+                }
+            }
+        }
+        if (shellPid !== null && !(await options.isProcessAlive(shellPid))) {
+            const summary = summarizeTerminalLines(emittedLines);
+            if (summary) {
+                await emit({ type: "summary", content: summary });
+            }
+            return {
+                exitCode: 130,
+                sawSessionId
+            };
+        }
+        if (shellPid === null && Date.now() - startedAt > options.startupTimeoutMs) {
+            const summary = summarizeTerminalLines(emittedLines);
+            if (summary) {
+                await emit({ type: "summary", content: summary });
+            }
+            return {
+                exitCode: 124,
+                sawSessionId
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+}
+async function readVersion(command) {
+    try {
+        const { stdout } = await execFileAsync(command, ["--version"]);
+        return stdout.trim().split("\n")[0] || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isInteractiveCodexArgs(args) {
+    return args[0] !== "exec";
+}
+async function findLatestCodexSessionId(cwd, startedAt) {
+    const sessionsRoot = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "sessions");
+    const files = await listFiles(sessionsRoot).catch(() => []);
+    let latest = null;
+    for (const file of files) {
+        if (!file.endsWith(".jsonl")) {
+            continue;
+        }
+        const details = await stat(file).catch(() => null);
+        if (!details || details.mtimeMs < startedAt - 60_000) {
+            continue;
+        }
+        const firstLine = (await readFile(file, "utf8").catch(() => "")).split(/\r?\n/)[0];
+        const session = parseCodexSessionMeta(firstLine, cwd);
+        if (session && (!latest || details.mtimeMs > latest.mtimeMs)) {
+            latest = {
+                id: session,
+                mtimeMs: details.mtimeMs
+            };
+        }
+    }
+    return latest?.id ?? null;
+}
+async function listFiles(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+            return listFiles(path);
+        }
+        return entry.isFile() ? [path] : [];
+    }));
+    return files.flat();
+}
+function parseCodexSessionMeta(line, cwd) {
+    try {
+        const parsed = JSON.parse(line);
+        if (parsed.type !== "session_meta") {
+            return null;
+        }
+        if (parsed.payload?.cwd !== cwd || typeof parsed.payload.id !== "string") {
+            return null;
+        }
+        return parsed.payload.id;
+    }
+    catch {
+        return null;
+    }
+}
+function summarizeTerminalLines(lines) {
+    const recent = lines.map(cleanTerminalLine).map(cleanSummaryLine).filter(isSummaryLine).slice(-6);
+    if (recent.length === 0) {
+        return "Codex terminal session ended.";
+    }
+    return [
+        "Codex terminal session ended.",
+        "",
+        "Recent activity:",
+        ...recent.map((line) => `- ${line}`)
+    ].join("\n");
+}
+function cleanTerminalLine(line) {
+    return line
+        .replace(ANSI_CSI_PATTERN, "")
+        .replace(ANSI_OSC_PATTERN, "")
+        .replace(CONTROL_CHARACTER_PATTERN, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function parseTerminalSessionId(line) {
+    const cleaned = cleanTerminalLine(line);
+    const direct = /^session id:\s*(\S+)/i.exec(cleaned);
+    if (direct) {
+        return direct[1];
+    }
+    const resume = /\bcodex\s+resume\s+(\S+)/i.exec(cleaned);
+    return resume?.[1]?.replace(/[.,;:]+$/u, "");
+}
+function cleanSummaryLine(line) {
+    let cleaned = line
+        .replace(/^[\u2022\-\s]+/u, "")
+        .replace(/^[\u2713\u2714]\s*/u, "")
+        .trim();
+    for (const marker of [" › ", " Token usage:"]) {
+        const markerIndex = cleaned.indexOf(marker);
+        if (markerIndex > 0) {
+            cleaned = cleaned.slice(0, markerIndex).trim();
+        }
+    }
+    return cleaned;
+}
+function isSummaryLine(line) {
+    if (!line) {
+        return false;
+    }
+    if (/^session id:/i.test(line)) {
+        return false;
+    }
+    if (/to continue this session/i.test(line)) {
+        return false;
+    }
+    if (["Abitat Workspace terminal runtime", "--- Starting Codex CLI ---", "--- Task ---"].some((prefix) => line.startsWith(prefix)) ||
+        line.startsWith("cwd:") ||
+        line.startsWith("command:")) {
+        return false;
+    }
+    if (/^[\u256d\u2570\u2502\u2500\s]+$/u.test(line) || /^\d+\s+[+-]?/u.test(line)) {
+        return false;
+    }
+    return /^(?:added|changed|completed|created|deleted|edited|fixed|generated|implemented|modified|updated|wrote)\b/iu.test(line);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function appleScriptString(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function escapeDoubleQuoted(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$");
+}
+async function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !(typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            error.code === "ESRCH");
+    }
+}
+function runtimeArgs(name, input, interactive) {
+    if (name === "codex") {
+        const localFolderArgs = input.skipGitRepoCheck ? ["--skip-git-repo-check"] : [];
+        const vpnStableArgs = ["--disable", "plugins", "--disable", "general_analytics"];
+        if (interactive) {
+            const interactiveArgs = [...vpnStableArgs, ...codexModelArgs(input.model), "--full-auto"];
+            if (input.resumeSessionId) {
+                return [...interactiveArgs, "resume", input.resumeSessionId];
+            }
+            return interactiveArgs;
+        }
+        if (input.resumeSessionId) {
+            return [
+                "exec",
+                "resume",
+                ...localFolderArgs,
+                ...vpnStableArgs,
+                ...codexModelArgs(input.model),
+                "--full-auto",
+                input.resumeSessionId,
+                "-"
+            ];
+        }
+        return [
+            "exec",
+            ...localFolderArgs,
+            ...vpnStableArgs,
+            ...codexModelArgs(input.model),
+            "--full-auto"
+        ];
+    }
+    if (interactive) {
+        return [];
+    }
+    return [...plainModelArgs(input.model), "--print"];
+}
+function codexModelArgs(model) {
+    const trimmed = model?.trim();
+    return trimmed ? ["--model", resolveCodexModel(trimmed)] : [];
+}
+function plainModelArgs(model) {
+    const trimmed = model?.trim();
+    return trimmed ? ["--model", trimmed] : [];
+}
+function resolveCodexModel(model) {
+    return /^\d+(?:\.\d+)+$/.test(model) ? `gpt-${model}` : model;
+}
+function runtimePrompt(input) {
+    return [
+        "# Instructions",
+        input.instructions,
+        "",
+        "# Task",
+        input.prompt,
+        "",
+        "# Allowed Tools",
+        (input.allowedTools ?? []).join(", ")
+    ].join("\n");
+}
+function createLineEmitter(type, emit) {
+    let buffered = "";
+    return {
+        async write(text) {
+            buffered += text;
+            const lines = buffered.split(/\r?\n/);
+            buffered = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.length > 0) {
+                    await emit({ type, content: line });
+                }
+            }
+        },
+        async close() {
+            if (buffered.length > 0) {
+                await emit({ type, content: buffered });
+                buffered = "";
+            }
+        }
+    };
+}
+//# sourceMappingURL=cli.js.map