@proagentstore/cli 0.1.31 → 0.2.1

package/dist/browser-runner/coding/headless.js

@@ -0,0 +1,237 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export class HeadlessSession {
+    config;
+    sessionName;
+    proc = null;
+    buf = "";
+    transcript = [];
+    run = "idle";
+    /** Claude Code's own session id (from the init event) — used to --resume. */
+    claudeSessionId = null;
+    constructor(config) {
+        this.config = config;
+        this.sessionName = `pags-${config.clientType}-${config.id}`;
+        this.claudeSessionId = readState(config.statePath, config.id);
+    }
+    /** True while the agent process is running. */
+    get alive() {
+        return this.proc !== null && this.proc.exitCode === null && !this.proc.killed;
+    }
+    /** Idle = ready for the next instruction. */
+    get ready() {
+        return this.alive && this.run === "idle";
+    }
+    runState() {
+        return this.alive ? (this.run === "thinking" ? "thinking" : "idle") : "idle";
+    }
+    /** The rendered conversation the brain/console reads (Claude's real output). */
+    snapshot() {
+        return this.transcript.join("\n");
+    }
+    /** Launch (or resume) the agent process. Idempotent if already alive. */
+    start() {
+        if (this.alive)
+            return;
+        const args = [
+            "-p",
+            "--input-format",
+            "stream-json",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--dangerously-skip-permissions",
+        ];
+        // Continue the prior conversation after a runner restart (state in ~/.claude).
+        if (this.claudeSessionId)
+            args.push("--resume", this.claudeSessionId);
+        this.proc = spawn(this.config.bin ?? "claude", args, {
+            cwd: this.config.workDir,
+            env: { ...process.env, ...this.config.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.run = "idle";
+        // MUST handle 'error' — without a listener, a spawn failure (e.g. `claude`
+        // not on PATH) is thrown as an uncaught exception and crashes the runner.
+        this.proc.on("error", (err) => {
+            this.run = "idle";
+            this.push(`[cannot run \`${this.config.bin ?? "claude"}\`: ${err.message} — is Claude Code installed and on your PATH?]`);
+            this.proc = null;
+        });
+        // Swallow EPIPE when writing to a process that just exited (one-shot turn).
+        this.proc.stdin?.on("error", () => { });
+        this.proc.stdout?.on("data", (d) => this.onStdout(d.toString("utf8")));
+        this.proc.stderr?.on("data", (d) => {
+            const text = d.toString("utf8").trim();
+            if (text)
+                this.push(`[claude] ${text}`);
+        });
+        this.proc.on("exit", (code) => {
+            this.run = "idle";
+            if (code && code !== 0)
+                this.push(`[claude exited with code ${code}]`);
+            // A bad --resume can kill the process instantly; drop it so the next
+            // start is a clean session rather than looping on a dead id.
+            if (code && code !== 0 && this.claudeSessionId) {
+                this.claudeSessionId = null;
+                writeState(this.config.statePath, this.config.id, null);
+            }
+        });
+    }
+    /** Send a user turn to Claude (the agent acts on it). */
+    input(text) {
+        if (!this.alive)
+            this.start();
+        this.push(`\n❯ ${text}`); // ❯ — your turn, mirrors the old prompt marker
+        this.run = "thinking";
+        const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } });
+        try {
+            this.proc?.stdin?.write(`${msg}\n`);
+        }
+        catch {
+            /* process may have died; the next snapshot reports not-alive */
+        }
+    }
+    /** No TTY in headless mode; control is via messages. Kept for interface parity. */
+    key(_keys) {
+        /* intentionally a no-op — there are no raw keystrokes without a terminal */
+    }
+    /** Abort the current turn (SIGINT, like Ctrl-C). The process stays usable. */
+    interrupt() {
+        try {
+            this.proc?.kill("SIGINT");
+        }
+        catch {
+            /* ignore */
+        }
+        this.run = "idle";
+    }
+    /** Tear the process down. */
+    stop() {
+        try {
+            this.proc?.kill();
+        }
+        catch {
+            /* ignore */
+        }
+        this.proc = null;
+        this.run = "idle";
+    }
+    // ── internals ────────────────────────────────────────────────────────────
+    onStdout(chunk) {
+        this.buf += chunk;
+        let nl;
+        // biome-ignore lint/suspicious/noAssignInExpressions: standard line-buffer drain
+        while ((nl = this.buf.indexOf("\n")) >= 0) {
+            const line = this.buf.slice(0, nl).trim();
+            this.buf = this.buf.slice(nl + 1);
+            if (line)
+                this.handle(line);
+        }
+    }
+    handle(line) {
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            return; // tolerate non-JSON noise
+        }
+        switch (ev.type) {
+            case "system":
+                if (ev.subtype === "init" && ev.session_id) {
+                    this.claudeSessionId = ev.session_id;
+                    writeState(this.config.statePath, this.config.id, ev.session_id);
+                }
+                break;
+            case "assistant":
+                for (const block of ev.message?.content ?? []) {
+                    if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+                        this.push(block.text.trim());
+                    }
+                    else if (block.type === "tool_use") {
+                        this.push(`⚙ ${String(block.name ?? "tool")} ${shortInput(block.input)}`); // ⚙
+                    }
+                }
+                break;
+            case "user": // tool results come back as a synthetic user message
+                for (const block of ev.message?.content ?? []) {
+                    if (block.type === "tool_result")
+                        this.push(`  ↳ ${toolResult(block.content)}`); // ↳
+                }
+                break;
+            case "result":
+                if (ev.is_error)
+                    this.push(`[error] ${ev.result ?? ev.subtype ?? "failed"}`);
+                this.run = "idle"; // the turn is OVER — a fact, not a guess
+                break;
+            default:
+                break;
+        }
+        // Keep the in-memory transcript bounded.
+        if (this.transcript.length > 4000)
+            this.transcript = this.transcript.slice(-3000);
+    }
+    push(line) {
+        this.transcript.push(line);
+    }
+}
+/** Compact a tool_use input object to a single readable line. */
+function shortInput(input) {
+    if (input == null)
+        return "";
+    try {
+        const s = typeof input === "string" ? input : JSON.stringify(input);
+        return s.length > 160 ? `${s.slice(0, 160)}…` : s;
+    }
+    catch {
+        return "";
+    }
+}
+/** Render a tool_result's content (string, or array of {type:text,text}) to text. */
+function toolResult(content) {
+    let text = "";
+    if (typeof content === "string")
+        text = content;
+    else if (Array.isArray(content)) {
+        text = content
+            .map((b) => (b && typeof b === "object" && "text" in b ? String(b.text) : ""))
+            .join(" ");
+    }
+    text = text.replace(/\s+/g, " ").trim();
+    return text.length > 240 ? `${text.slice(0, 240)}…` : text;
+}
+function loadFile(path) {
+    if (!path || !existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function readState(path, id) {
+    return loadFile(path)[id] ?? null;
+}
+function writeState(path, id, claudeSessionId) {
+    if (!path)
+        return;
+    try {
+        const data = loadFile(path);
+        if (claudeSessionId)
+            data[id] = claudeSessionId;
+        else
+            delete data[id];
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(data));
+    }
+    catch {
+        /* best-effort persistence */
+    }
+}
+/** Default location for the resume-id store, under the repos base dir. */
+export function defaultStatePath(reposBaseDir) {
+    return join(reposBaseDir, "headless-sessions.json");
+}

package/dist/browser-runner/coding/runtime.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { CodingSession } from "./session.js";
-import { ensureRepo, listSessions as listTmuxSessions, sanitizeSessionName } from "./tmux.js";
+import { defaultStatePath, HeadlessSession } from "./headless.js";
+import { ensureRepo, sanitizeSessionName } from "./tmux.js";
 /** Hard cap on a pane returned to the brain/console (matches the worker MAX_PANE_CHARS). */
 const MAX_PANE = 64 * 1024;
 export class CodingRuntime {
@@ -20,7 +20,7 @@ export class CodingRuntime {
     }
     /** Capabilities advertised to PAGS at registration. */
     static capabilities() {
-        return ["coding.sessions", "coding.tmux", "human.takeover"];
+        return ["coding.sessions", "coding.stream", "human.takeover"];
     }
     static taskTypes() {
         return ["coding.session"];
@@ -36,11 +36,13 @@ export class CodingRuntime {
                 ? resolve(input.workDir.replace(/^~(?=$|\/)/, homedir()))
                 : join(this.reposBaseDir, sanitizeSessionName(input.repoId));
             ensureRepo(workDir, { cloneUrl: input.cloneUrl, branch: input.branch, token: input.token });
-            session = new CodingSession({
+            session = new HeadlessSession({
                 id: input.sessionId,
                 workDir,
                 clientType: input.clientType,
                 env: input.env,
+                statePath: defaultStatePath(this.reposBaseDir),
+                bin: input.bin,
             });
             this.sessions.set(input.sessionId, session);
         }
@@ -149,10 +151,9 @@ export class CodingRuntime {
         this.sessions.clear();
         this.takeovers.clear();
     }
-    /** True if any tmux session this runtime owns is still alive. */
-    hasLiveTmux() {
-        const live = new Set(listTmuxSessions());
-        return [...this.sessions.values()].some((s) => live.has(s.sessionName));
+    /** True if any session this runtime owns still has a live agent process. */
+    hasLiveSessions() {
+        return [...this.sessions.values()].some((s) => s.alive);
     }
     require(sessionId) {
         const session = this.sessions.get(sessionId);

package/dist/browser-runner/index.js

@@ -2,6 +2,16 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { startRunnerServer } from "./server.js";
+// Resilience: a stray error in any runtime must NOT take the whole runner down —
+// that drops the tunnel and forces the user to restart `pags up` (and lose their
+// session). Log it and keep serving. Per-component handlers catch most things;
+// this is the last-resort backstop.
+process.on("uncaughtException", (err) => {
+    process.stderr.write(`[runner] uncaught: ${err?.stack || String(err)}\n`);
+});
+process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`[runner] unhandled rejection: ${String(reason)}\n`);
+});
 function arg(name, fallback) {
     const index = process.argv.indexOf(name);
     if (index === -1)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@proagentstore/cli",
-	"version": "0.1.31",
+	"version": "0.2.1",
 	"description": "CLI for creating, publishing, and running ProAgentStore agents",
 	"license": "MIT",
 	"type": "module",

package/dist/browser-runner/coding/session.js

@@ -1,149 +0,0 @@
-import { capturePane, createSession, killSession, paneTarget, sanitizeSessionName, sendKey, sendText, sessionExists, } from "./tmux.js";
-import { handlerFor } from "./handlers.js";
-/**
- * One AI-coding-CLI session living in a tmux pane.
- *
- * This is the coding runtime's analogue of a Playwright `Page`: the unit the
- * remote brain "sees" (via {@link snapshot}) and "acts on" (via {@link send}),
- * and the unit a human attaches to during takeover. The brain/hands split and
- * the streaming-until-idle loop mirror the browser runtime exactly — only the
- * mechanism (tmux send-keys + capture-pane) differs.
- */
-export class CodingSession {
-    config;
-    sessionName;
-    target;
-    handler;
-    constructor(config) {
-        this.config = config;
-        this.sessionName = sanitizeSessionName(`pags-${config.clientType}-${config.id}`);
-        this.target = paneTarget(this.sessionName);
-        this.handler = handlerFor(config.clientType);
-    }
-    /** True if the underlying tmux session is alive. */
-    get alive() {
-        return sessionExists(this.sessionName);
-    }
-    /** Launch the CLI inside a fresh tmux session. Idempotent if already alive. */
-    start() {
-        if (this.alive)
-            return;
-        // Launch a shell first so we can export the BYOK env, then exec the CLI.
-        createSession(this.sessionName, this.config.workDir);
-        if (this.config.env) {
-            for (const [k, v] of Object.entries(this.config.env)) {
-                // Use printf-safe assignment; values never reach a shell as code because
-                // we send them as a single literal then press Enter.
-                sendText(this.target, `export ${k}=${JSON.stringify(v)}`);
-                sendKey(this.target, "Enter");
-            }
-        }
-        if (this.handler.cliCommand && this.handler.cliCommand !== "bash") {
-            sendText(this.target, this.handler.cliCommand);
-            sendKey(this.target, "Enter");
-        }
-    }
-    /** The pane content the brain reasons over (the "snapshot"). */
-    snapshot(lines = 200) {
-        return capturePane(this.target, lines);
-    }
-    /** True when the CLI is idle and ready for the next message. */
-    get ready() {
-        return this.handler.isReady(this.snapshot());
-    }
-    /** Send a raw key (Enter, Escape, C-c) — used by takeover and control flows. */
-    key(name) {
-        sendKey(this.target, name);
-    }
-    /**
-     * Submit a message to the CLI without waiting for the reply (text + Enter).
-     * The brain-driven loop calls this, then polls {@link snapshot}/{@link ready}
-     * until idle — the tmux analogue of the browser runtime's non-blocking act.
-     */
-    input(text) {
-        sendText(this.target, text);
-        sendKey(this.target, "Enter");
-    }
-    /** Interrupt the current run (Ctrl-C), e.g. to stop a runaway CLI. */
-    interrupt() {
-        sendKey(this.target, "C-c");
-    }
-    /** Current run-state inferred from the pane: idle / thinking / responding. */
-    runState() {
-        const pane = this.snapshot();
-        if (this.handler.isProcessing(pane)) {
-            return pane.includes("ctrl+c to interrupt") ? "responding" : "thinking";
-        }
-        return this.handler.isReady(pane) ? "idle" : "thinking";
-    }
-    /**
-     * Send a message to the CLI and resolve with its extracted response once the
-     * pane goes idle. Streams intermediate frames through `onStream`.
-     *
-     * The completion heuristic is the same staged one AgentCoder proved against
-     * real CLIs: wait for "processing" to appear, then for the prompt to return
-     * and output to stabilise, with a hard timeout backstop.
-     */
-    async send(message, onStream) {
-        sendText(this.target, message);
-        sendKey(this.target, "Enter");
-        const cfg = this.handler.completion();
-        const startedAt = Date.now();
-        const hardCap = 5 * 60 * 1000;
-        let sawProcessing = false;
-        let lastContent = "";
-        let lastChange = Date.now();
-        let lastEmit = 0;
-        const emitThrottle = 300;
-        while (Date.now() - startedAt < hardCap) {
-            await delay(cfg.pollInterval);
-            if (!this.alive)
-                break;
-            const pane = this.snapshot(5000);
-            const ready = this.handler.isReady(pane);
-            const processing = this.handler.isProcessing(pane);
-            if (onStream) {
-                const partial = this.handler.extractResponse(pane, message);
-                if (partial && partial !== lastContent) {
-                    lastChange = Date.now();
-                    if (Date.now() - lastEmit >= emitThrottle) {
-                        lastContent = partial;
-                        lastEmit = Date.now();
-                        await onStream(partial, false);
-                    }
-                }
-            }
-            if (processing || !ready) {
-                sawProcessing = true;
-                lastChange = Date.now();
-                continue;
-            }
-            const idle = Date.now() - lastChange;
-            const elapsed = Date.now() - startedAt;
-            if (cfg.minWait !== undefined) {
-                if (ready && elapsed > (sawProcessing ? 0 : cfg.minWait))
-                    break;
-            }
-            else {
-                if (ready && sawProcessing && idle >= cfg.stableThreshold)
-                    break;
-                if (ready && elapsed > 2000)
-                    break;
-                if (elapsed >= cfg.forceCompleteAfter)
-                    break;
-            }
-        }
-        const finalPane = this.snapshot(5000);
-        const response = this.handler.extractResponse(finalPane, message);
-        if (onStream)
-            await onStream(response, true);
-        return response;
-    }
-    /** Tear down the tmux session. */
-    stop() {
-        killSession(this.sessionName);
-    }
-}
-function delay(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}