@yefengr/remote-pi 0.7.4 → 0.7.6

package/dist/daemon/rpc_child.js

@@ -1,27 +1,13 @@
 import { execFileSync, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { defaultAgentName, loadLocalConfig } from "../session/local_config.js";
 export const EXIT_DAEMON_FRESH_SESSION = 42;
-/** Windows extensions `spawn` (without `shell`) can actually launch, in
- *  preference order: native `.exe` first, then the `.cmd`/`.bat` shims (run via
- *  cmd.exe). An extensionless `pi` is a Unix shell script Node CANNOT spawn on
- *  Windows — picking it yields `spawn … ENOENT` and the daemon shows "crashed". */
+export const DEFAULT_READINESS_TIMEOUT_MS = 10_000;
+export const DEFAULT_PROMPT_TIMEOUT_MS = 5_000;
 const WIN_EXECUTABLE_EXTS = [".exe", ".cmd", ".bat", ".com"];
-/**
- * Resolve the `pi` executable for `spawn` (plan/40, decision C). On Windows a
- * bare `pi` is actually `pi.cmd`/`pi.ps1`, and `spawn` won't find it without an
- * extension → resolve the real path via `where` (rather than `shell:true`,
- * which risks shell injection). An explicit path or an already-suffixed name is
- * used as-is. POSIX returns the name unchanged. Best-effort: if `where` fails,
- * fall back to the bare name (spawn will surface ENOENT honestly).
- *
- * `where` lists every match in PATH order, which on pi-node installs puts the
- * extensionless `pi` (a shell script) BEFORE `pi.cmd`. Naively taking the first
- * line spawns the unrunnable script → ENOENT → "crashed". So we prefer a result
- * with a real Windows executable extension and only fall back to the first line.
- */
 export function resolvePiBin(piBin, plat = process.platform) {
     if (plat !== "win32")
         return piBin;
@@ -29,29 +15,13 @@ export function resolvePiBin(piBin, plat = process.platform) {
         return piBin;
     try {
         const out = execFileSync("where", [piBin], { encoding: "utf8" });
-        const lines = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-        const runnable = lines.find((l) => WIN_EXECUTABLE_EXTS.some((ext) => l.toLowerCase().endsWith(ext)));
-        const chosen = runnable ?? lines[0];
-        if (chosen)
-            return chosen;
+        const lines = out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return lines.find((line) => WIN_EXECUTABLE_EXTS.some((ext) => line.toLowerCase().endsWith(ext))) ?? lines[0] ?? piBin;
     }
     catch {
-        /* `where` unavailable or `pi` not found — fall back to the bare name */
+        return piBin;
     }
-    return piBin;
 }
-/**
- * Resolve `pi` to a directly-spawnable target (plan/40). On Windows `pi` is an
- * npm `.cmd` shim, which modern Node refuses to `spawn` without `shell:true`
- * (EINVAL, post CVE-2024-27980). Wrapping it in `cmd.exe` would (a) add a layer
- * that orphans the real `node` on kill and (b) complicate stdio — both fatal for
- * a long-lived RPC daemon the supervisor must stop/restart cleanly. Instead we
- * parse the shim to recover the underlying `node <cli.js>` and spawn that
- * directly: one process, clean signals, clean stdio.
- *
- * Falls back to the bare resolved path when not a parseable shim (e.g. a real
- * `pi.exe`, or POSIX) so `spawn` surfaces any real error honestly.
- */
 export function resolvePiSpawn(piBin, plat = process.platform, nodeExe = process.execPath) {
     const resolved = resolvePiBin(piBin, plat);
     if (plat !== "win32")
@@ -63,12 +33,6 @@ export function resolvePiSpawn(piBin, plat = process.platform, nodeExe = process
     }
     return { command: resolved, prefixArgs: [] };
 }
-/**
- * Extract the JS entry an npm `.cmd` shim launches. npm shims invoke
- * `"%_prog%"  "%dp0%\<relative>\entry.js" %*`; we recover `<dir>\<relative>\entry.js`
- * (dir = the shim's own folder, i.e. `%dp0%`). Returns null when the shim
- * doesn't match the expected shape or the target is missing.
- */
 export function _npmShimTarget(cmdPath) {
     let content;
     try {
@@ -77,313 +41,422 @@ export function _npmShimTarget(cmdPath) {
     catch {
         return null;
     }
-    const m = content.match(/"%dp0%\\([^"]+\.[cm]?js)"/i);
-    if (!m)
+    const match = content.match(/"%dp0%\\([^\"]+\.[cm]?js)"/i);
+    if (!match)
         return null;
-    const target = join(dirname(cmdPath), m[1]);
+    const target = join(dirname(cmdPath), match[1]);
     return existsSync(target) ? target : null;
 }
-/**
- * Maps an RPC stdout line to a busy-state transition: `message_start` → true
- * (a message is streaming), `message_end` → false. Other lines → null (no
- * change). Pure + exported for tests.
- *
- * NOTE (plan/39 detail 1): the Pi RPC stream has NO turn-level event — only
- * per-message start/end (and `response{command:"prompt"}` is emitted at
- * PREFLIGHT, i.e. turn START, not end). So this passive flag reflects
- * "a message is being produced right now"; the authoritative turn-busy signal
- * is `get_state.isStreaming` (see `RpcChild.refreshBusy`).
- */
 export function busyTransition(line) {
-    let obj;
+    let value;
     try {
-        obj = JSON.parse(line);
+        value = JSON.parse(line);
     }
     catch {
         return null;
     }
-    const t = obj?.type;
-    if (t === "message_start")
+    const type = value?.type;
+    if (type === "message_start")
         return true;
-    if (t === "message_end")
+    if (type === "message_end")
         return false;
     return null;
 }
-/** Parses a `get_state` RPC response line, returning its id + isStreaming. */
-function parseGetStateResponse(line) {
-    let obj;
-    try {
-        obj = JSON.parse(line);
-    }
-    catch {
-        return null;
-    }
-    const o = obj;
-    if (o.type !== "response" || o.command !== "get_state")
-        return null;
-    const data = o.data;
-    return {
-        id: typeof o.id === "string" ? o.id : undefined,
-        isStreaming: typeof data?.isStreaming === "boolean" ? data.isStreaming : undefined,
-    };
-}
 /**
- * CLI args for the daemon's `pi --mode rpc` child.
- *
- * `--continue` is the key bit: it resumes the **most recent** session for the
- * cwd (`SessionManager.continueRecent`, non-interactive — unlike `--resume`
- * which opens a picker). Without it every supervisor restart spun up a brand
- * new session file, piling up thousands of JSONLs per folder. With it, a
- * restart REUSES the one session; the app's `/new` (session_new) still rolls
- * it over to a fresh one, which the next restart then continues. First boot
- * (no prior session) just creates the first one.
- *
- * `--name <sessionName>`, when given, pins the session's display name to the
- * daemon's identity (its `agent_name`) so every restart shows up under the
- * same stable name in the picker/app instead of an auto-generated one. The
- * daemon's name is set at registration (`remote-pi create <cwd> --name "…"`).
- * Omitted when no name resolves, so the arg list stays minimal.
- *
- * `--approve` is mandatory for a daemon (pi ≥0.79 project trust): RPC mode is
- * non-interactive, so without an override Pi resolves an untrusted project
- * folder (any folder with `.pi/` or CLAUDE.md/AGENTS.md) to NOT trusted and
- * silently skips its `.pi/settings.json` (model/provider/keys), instructions,
- * resources and project extensions — the daemon then comes up with no model
- * and fails on the first turn. The operator already authorized this folder by
- * registering/launching a daemon in it, so `--approve` (trust-for-this-run) is
- * the correct non-interactive stance. (Does NOT affect the separate "extension
- * loaded twice" conflict, which comes from the extension being BOTH installed
- * in ~/.pi/agent/extensions or cwd/.pi/extensions AND passed via `-e`.)
+ * The installed Pi RPC starts configured extensions itself. In particular this
+ * must not attach Remote Pi with `-e`, which could load it a second time.
  */
-export function rpcSpawnArgs(extensionPath, sessionName, useContinue = true) {
+export function rpcSpawnArgs(_extensionPath, sessionName, useContinue = true) {
     return [
         "--mode", "rpc",
         "--approve",
         ...(useContinue ? ["--continue"] : []),
         ...(sessionName ? ["--name", sessionName] : []),
-        "-e", extensionPath,
     ];
 }
+/**
+ * Parses direct daemon-control events and the current extension's custom
+ * relay-state message shape. Natural-language stderr is intentionally absent.
+ */
+export function parseRuntimeEvent(line) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!raw || typeof raw !== "object")
+        return null;
+    const obj = raw;
+    let type = obj["type"];
+    let payload = obj;
+    if (type === "entry_appended" && obj["entry"] && typeof obj["entry"] === "object") {
+        const entry = obj["entry"];
+        const customType = entry["customType"];
+        const details = entry["details"];
+        if (typeof customType === "string" && details && typeof details === "object") {
+            type = customType.replace(/^remote-pi:/, "").replace(/-/g, "_");
+            payload = details;
+        }
+    }
+    if (type === "runtime_ready") {
+        return {
+            type,
+            event: {
+                control_protocol_version: typeof payload["control_protocol_version"] === "number" ? payload["control_protocol_version"] : undefined,
+                extension_version: typeof payload["extension_version"] === "string" ? payload["extension_version"] : undefined,
+                endpoint_id: typeof payload["endpoint_id"] === "string" ? payload["endpoint_id"] : undefined,
+                runtime_instance_id: typeof payload["runtime_instance_id"] === "string" ? payload["runtime_instance_id"] : undefined,
+                session_id: typeof payload["session_id"] === "string" ? payload["session_id"] : undefined,
+            },
+        };
+    }
+    if (type === "runtime_failed") {
+        if (typeof payload["code"] !== "string" || typeof payload["retryable"] !== "boolean")
+            return null;
+        return { type, event: {
+                stage: typeof payload["stage"] === "string" ? payload["stage"] : undefined,
+                code: payload["code"],
+                message: typeof payload["message"] === "string" ? payload["message"] : undefined,
+                retryable: payload["retryable"],
+            } };
+    }
+    if (type === "relay_state_changed" || type === "relay_state") {
+        const state = payload["state"] ?? payload["status"];
+        if (state === "disconnected" || state === "connecting" || state === "connected" || state === "reconnecting") {
+            return { type: "relay_state_changed", event: { state } };
+        }
+    }
+    if (type === "session_changed") {
+        return { type, event: { session_id: typeof payload["session_id"] === "string" ? payload["session_id"] : undefined } };
+    }
+    return null;
+}
 export class RpcChild extends EventEmitter {
     opts;
     child = null;
     _state = "stopped";
-    _startedAt = null;
+    _process = "absent";
+    _runtime = "pending";
+    _relay = "disconnected";
+    _startedAt;
+    _runtimeInstanceId;
+    _sessionId;
     _restartCount = 0;
-    /** True while a deliberate `stop()` is in flight. The process dies by
-     *  signal (SIGTERM/SIGKILL), which would otherwise look like a crash and
-     *  trip the supervisor's auto-restart — re-spawning a daemon the operator
-     *  just stopped/removed. Gating `isCrash` on this makes a deliberate stop a
-     *  clean exit (no restart). Reset on every `spawn()`. */
     _stopping = false;
-    /** Next spawn should create a fresh session instead of --continue. */
     forceFreshSessionOnNextSpawn = false;
-    /** Accumulates partial stdout lines while waiting for `\n`. */
     stdoutBuf = "";
-    /** Passive busy flag derived from the RPC stream (message_start/end). Hint
-     *  only; `refreshBusy` syncs it authoritatively via get_state.isStreaming. */
     _busy = false;
-    /** In-flight `get_state` requests, keyed by request id. */
-    _statePending = new Map();
+    rpcReady = false;
+    extensionReady = false;
+    extensionReadyEvent = null;
+    readinessTimer = null;
+    readyPromise = Promise.resolve(false);
+    readyResolve = null;
+    statePending = new Map();
+    promptPending = new Map();
     constructor(opts) {
         super();
         this.opts = opts;
     }
     get state() { return this._state; }
-    /** Passive busy hint from the stream. Prefer `refreshBusy()` for an
-     *  authoritative check before acting on it (cron skip_if_busy). */
+    get processState() { return this._process; }
+    get runtimeState() { return this._runtime; }
+    get relayState() { return this._relay; }
     get isBusy() { return this._busy; }
     get pid() { return this.child?.pid; }
     get restartCount() { return this._restartCount; }
-    get uptimeMs() {
-        return this._startedAt !== null ? Date.now() - this._startedAt : undefined;
-    }
-    /**
-     * Spawn the child process. Idempotent for the same instance: a second
-     * call while already running is a no-op.
-     */
+    get startedAt() { return this._startedAt; }
+    get runtimeInstanceId() { return this._runtimeInstanceId; }
+    get sessionId() { return this._sessionId; }
+    get uptimeMs() { return this._startedAt === undefined ? undefined : Date.now() - this._startedAt; }
+    /** Resolves true only after the readiness probe/event, false on timeout/exit. */
+    ready() { return this.readyPromise; }
     spawn() {
         if (this.child)
             return;
-        this._stopping = false; // fresh start — a later signal IS a real crash
+        this._stopping = false;
         this._busy = false;
         this._state = "starting";
-        const piTarget = resolvePiSpawn(this.opts.piBin ?? "pi");
-        // Name the (single) daemon session after the daemon's configured identity,
-        // so it shows up stably instead of an auto-generated name on each restart.
-        // Prefer the supervisor-injected config; fall back to the on-disk file.
-        const cfg = this.opts.config ?? loadLocalConfig(this.opts.cwd);
-        const sessionName = cfg.agent_name ?? defaultAgentName(this.opts.cwd);
+        this._process = "spawning";
+        this._runtime = "pending";
+        this._relay = "connecting";
+        this._sessionId = undefined;
+        this.rpcReady = false;
+        this.extensionReady = false;
+        this.extensionReadyEvent = null;
+        this._runtimeInstanceId = randomUUID();
+        this.readyPromise = new Promise((resolve) => { this.readyResolve = resolve; });
+        const target = resolvePiSpawn(this.opts.piBin ?? "pi");
+        const config = this.opts.config ?? loadLocalConfig(this.opts.cwd);
+        const sessionName = config.agent_name ?? defaultAgentName(this.opts.cwd);
         const useContinue = !this.forceFreshSessionOnNextSpawn;
         this.forceFreshSessionOnNextSpawn = false;
-        // On Windows `prefixArgs` carries pi's cli.js (we spawn node directly); on
-        // POSIX it's empty and `command` is `pi` itself.
-        const args = [...piTarget.prefixArgs, ...rpcSpawnArgs(this.opts.extensionPath, sessionName, useContinue)];
+        const args = [...target.prefixArgs, ...rpcSpawnArgs(this.opts.extensionPath, sessionName, useContinue)];
         const env = {
             ...process.env,
             ...this.opts.env,
-            // Mandatory daemon marker — `_cmdRoot` in index.ts can use this to
-            // bail early if local config is missing (no wizard in RPC mode).
             REMOTE_PI_DAEMON: "1",
-            // Inject the daemon config inline so the child needs no config file.
+            REMOTE_PI_ENDPOINT_ID: this.opts.endpointId ?? "",
+            REMOTE_PI_RUNTIME_INSTANCE_ID: this._runtimeInstanceId,
             ...(this.opts.config ? { REMOTE_PI_DIRECT_CONFIG: JSON.stringify(this.opts.config) } : {}),
         };
-        const child = spawn(piTarget.command, args, {
-            cwd: this.opts.cwd,
-            env,
-            stdio: ["pipe", "pipe", "pipe"],
-            // Windows: suppress any console window the child might allocate. With the
-            // node+cli.js path (resolvePiSpawn) there's no cmd.exe layer, but keep this
-            // as belt-and-suspenders alongside the supervisor's hidden wscript launcher
-            // (service-templates/task-launcher.vbs.template). No-op on POSIX.
-            windowsHide: process.platform === "win32",
-        });
+        const child = spawn(target.command, args, { cwd: this.opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: process.platform === "win32" });
         this.child = child;
         this._startedAt = Date.now();
-        this._state = "running";
-        child.stdout?.on("data", (chunk) => this._onStdout(chunk));
-        child.stderr?.on("data", (chunk) => {
-            // Forward stderr to our own stderr so `journalctl --user -u remote-pi-supervisord`
-            // sees daemon logs (with cwd prefix for disambiguation).
-            process.stderr.write(`[${this.opts.cwd}] ${chunk.toString()}`);
+        // A spawned ChildProcess object is not evidence its executable completed
+        // startup. Preserve `spawning` until Node reports the OS spawn event.
+        child.once("spawn", () => {
+            if (this.child === child && this._process === "spawning")
+                this._process = "running";
         });
-        child.on("exit", (code, signal) => this._onExit(code, signal));
-        child.on("error", (err) => {
-            // spawn() itself failed (e.g. `pi` binary not found).
-            this._state = "crashed";
-            process.stderr.write(`[remote-pi-supervisord] spawn failed for ${this.opts.cwd}: ${String(err)}\n`);
-            this.emit("exit", { code: null, signal: null, isCrash: true });
+        child.stdout?.on("data", (chunk) => this.onStdout(chunk));
+        child.stderr?.on("data", (chunk) => process.stderr.write(`[${this.opts.cwd}] ${chunk.toString()}`));
+        child.on("exit", (code, signal) => this.onExit(code, signal));
+        child.on("error", (error) => {
+            this.failRuntime({ stage: "spawn", code: "spawn_failed", message: String(error), retryable: true });
+            this._process = "exited";
         });
-        this.emit("spawn", { pid: child.pid });
+        this.startReadinessProbe();
+        this.emit("spawn", { pid: child.pid, runtime_instance_id: this._runtimeInstanceId });
     }
-    /**
-     * Sends a Pi RPC `prompt` command to the child's stdin. Fire-and-forget
-     * — we don't wait for the response (response would be the success ack;
-     * the actual agent output streams via the relay/UDS, not back through
-     * stdout).
-     *
-     * Returns false if the child isn't running (caller decides how to report).
-     */
-    sendPrompt(text, requestId) {
-        if (!this.child || !this.child.stdin || this._state !== "running")
-            return false;
-        const cmd = { id: requestId ?? `sv-${Date.now()}`, type: "prompt", message: text };
-        try {
-            this.child.stdin.write(JSON.stringify(cmd) + "\n");
-            return true;
-        }
-        catch {
-            return false;
+    /** Waits for Pi's correlated prompt preflight response, not merely stdin write. */
+    sendPrompt(text, requestId = `sv-${randomUUID()}`, timeoutMs = this.opts.promptTimeoutMs ?? DEFAULT_PROMPT_TIMEOUT_MS) {
+        if (!this.child?.stdin || this._process !== "running" || this._runtime !== "ready") {
+            return Promise.resolve({ accepted: false, code: "runtime_not_ready", error: "daemon RPC runtime is not ready" });
         }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.promptPending.delete(requestId);
+                resolve({ accepted: false, code: "prompt_response_timeout", error: "Pi did not accept the prompt before timeout" });
+            }, timeoutMs);
+            this.promptPending.set(requestId, { resolve, timer });
+            try {
+                this.child.stdin.write(JSON.stringify({ id: requestId, type: "prompt", message: text }) + "\n");
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.promptPending.delete(requestId);
+                resolve({ accepted: false, code: "stdin_write_failed", error: String(error) });
+            }
+        });
     }
-    /**
-     * Asks the child to exit gracefully. Sends SIGTERM; if the child doesn't
-     * exit within `timeoutMs`, escalates to SIGKILL. Resolves when the
-     * `exit` event fires.
-     */
-    async stop(timeoutMs = 5000) {
+    async stop(timeoutMs = 5_000) {
         if (!this.child)
             return;
-        this._stopping = true; // deliberate — the upcoming signal-exit is NOT a crash
+        this._stopping = true;
         const child = this.child;
-        return new Promise((resolve) => {
-            const onExit = () => { resolve(); };
-            this.once("exit", onExit);
+        await new Promise((resolve) => {
+            this.once("exit", resolve);
             try {
                 child.kill("SIGTERM");
             }
-            catch { /* already dead */ }
-            const t = setTimeout(() => {
-                try {
-                    child.kill("SIGKILL");
-                }
-                catch { /* race — already dead */ }
-            }, timeoutMs);
-            this.once("exit", () => clearTimeout(t));
-        });
-    }
-    _onStdout(chunk) {
-        this.stdoutBuf += chunk.toString();
-        let nl;
-        while ((nl = this.stdoutBuf.indexOf("\n")) >= 0) {
-            const line = this.stdoutBuf.slice(0, nl);
-            this.stdoutBuf = this.stdoutBuf.slice(nl + 1);
-            if (!line.trim())
-                continue;
-            this._handleStdoutLine(line);
-        }
-    }
-    _handleStdoutLine(line) {
-        const t = busyTransition(line);
-        if (t !== null)
-            this._busy = t;
-        const gs = parseGetStateResponse(line);
-        if (gs && gs.id) {
-            const pending = this._statePending.get(gs.id);
-            if (pending) {
-                clearTimeout(pending.timer);
-                this._statePending.delete(gs.id);
-                if (typeof gs.isStreaming === "boolean")
-                    this._busy = gs.isStreaming;
-                pending.resolve(this._busy);
+            catch {
+                resolve();
             }
-        }
-        this.emit("stdout", line);
+            const timer = setTimeout(() => { try {
+                child.kill("SIGKILL");
+            }
+            catch { /* process already gone */ } }, timeoutMs);
+            this.once("exit", () => clearTimeout(timer));
+        });
     }
-    /**
-     * Authoritative busy check: queries the child's `get_state` and syncs
-     * `_busy` to `isStreaming`. Resolves the passive flag on timeout (no
-     * response) or when the child isn't running. Used by the cron `skip_if_busy`
-     * gate, where a false "not busy" would pile a prompt onto a live turn.
-     */
-    async refreshBusy(timeoutMs = 1500) {
-        if (this._state !== "running" || !this.child?.stdin)
+    async refreshBusy(timeoutMs = 1_500) {
+        if (this._process !== "running" || !this.child?.stdin)
             return this._busy;
-        const id = `gs-${Date.now()}-${Math.round(Math.random() * 1e6)}`;
+        const id = `gs-${randomUUID()}`;
         return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                this._statePending.delete(id);
-                resolve(this._busy);
-            }, timeoutMs);
-            this._statePending.set(id, { resolve, timer });
+            const timer = setTimeout(() => { this.statePending.delete(id); resolve(this._busy); }, timeoutMs);
+            this.statePending.set(id, { resolve, timer });
             try {
                 this.child.stdin.write(JSON.stringify({ id, type: "get_state" }) + "\n");
             }
             catch {
                 clearTimeout(timer);
-                this._statePending.delete(id);
+                this.statePending.delete(id);
                 resolve(this._busy);
             }
         });
     }
-    /** Test-only: feed a raw stdout line through the same handler. */
-    _ingestStdoutForTest(line) {
-        this._handleStdoutLine(line);
+    /** Test injection point for deterministic RPC event/response coverage. */
+    _ingestStdoutForTest(line) { this.handleStdoutLine(line); }
+    startReadinessProbe() {
+        const timeoutMs = this.opts.readinessTimeoutMs ?? DEFAULT_READINESS_TIMEOUT_MS;
+        this.readinessTimer = setTimeout(() => {
+            if (this.rpcReady && !this.extensionReady) {
+                this.failRuntime({ stage: "extension", code: "extension_not_ready", message: "Pi RPC is ready but the configured Remote Pi extension did not report readiness", retryable: false });
+                return;
+            }
+            this.failRuntime({ stage: "rpc_probe", code: "readiness_timeout", message: "Pi RPC get_state did not respond before timeout", retryable: true });
+        }, timeoutMs);
+        const id = `ready-${randomUUID()}`;
+        try {
+            this.child?.stdin?.write(JSON.stringify({ id, type: "get_state" }) + "\n");
+        }
+        catch (error) {
+            this.failRuntime({ stage: "rpc_probe", code: "readiness_probe_write_failed", message: String(error), retryable: true });
+        }
+    }
+    onStdout(chunk) {
+        this.stdoutBuf += chunk.toString();
+        let newline;
+        while ((newline = this.stdoutBuf.indexOf("\n")) >= 0) {
+            const line = this.stdoutBuf.slice(0, newline);
+            this.stdoutBuf = this.stdoutBuf.slice(newline + 1);
+            if (line.trim())
+                this.handleStdoutLine(line);
+        }
+    }
+    handleStdoutLine(line) {
+        const busy = busyTransition(line);
+        if (busy !== null)
+            this._busy = busy;
+        const response = this.parseResponse(line);
+        if (response)
+            this.handleResponse(response);
+        const event = parseRuntimeEvent(line);
+        if (event)
+            this.handleRuntimeEvent(event);
+        this.emit("stdout", line);
+    }
+    parseResponse(line) {
+        try {
+            const value = JSON.parse(line);
+            return value.type === "response" ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    handleResponse(response) {
+        if (typeof response.id !== "string" || typeof response.command !== "string")
+            return;
+        if (response.command === "get_state") {
+            const pending = this.statePending.get(response.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.statePending.delete(response.id);
+                const streaming = response.data?.isStreaming;
+                if (typeof streaming === "boolean")
+                    this._busy = streaming;
+                pending.resolve(this._busy);
+            }
+            if (response.success === true) {
+                const data = response.data;
+                this.rpcReady = true;
+                if (typeof data?.sessionId === "string")
+                    this._sessionId = data.sessionId;
+                this.maybeMarkReady();
+            }
+            else {
+                this.failRuntime({ stage: "rpc_probe", code: "readiness_probe_rejected", message: typeof response.error === "string" ? response.error : "Pi rejected get_state", retryable: true });
+            }
+            return;
+        }
+        if (response.command === "prompt") {
+            const pending = this.promptPending.get(response.id);
+            if (!pending)
+                return;
+            clearTimeout(pending.timer);
+            this.promptPending.delete(response.id);
+            pending.resolve(response.success === true
+                ? { accepted: true }
+                : { accepted: false, code: "prompt_rejected", error: typeof response.error === "string" ? response.error : "Pi rejected prompt" });
+        }
+    }
+    handleRuntimeEvent(event) {
+        switch (event.type) {
+            case "runtime_ready":
+                this.acceptExtensionReady(event.event);
+                break;
+            case "runtime_failed":
+                this.failRuntime(event.event);
+                break;
+            case "relay_state_changed":
+                this._relay = event.event.state;
+                this.emit("relay_state_changed", event.event);
+                break;
+            case "session_changed":
+                this._sessionId = event.event.session_id;
+                this.emit("session_changed", event.event);
+                break;
+        }
     }
-    _onExit(code, signal) {
-        // Daemon app-action `/new`: child exits with a private code, supervisor
-        // restarts it, and the next spawn omits --continue once to create a fresh
-        // session. Later restarts go back to --continue.
+    acceptExtensionReady(event) {
+        if (this._runtime === "failed" || !this.child)
+            return;
+        if (event.control_protocol_version !== 2) {
+            this.failRuntime({ stage: "extension", code: "control_protocol_mismatch", message: "Remote Pi extension control protocol is incompatible", retryable: false });
+            return;
+        }
+        if (event.endpoint_id !== this.opts.endpointId || event.runtime_instance_id !== this._runtimeInstanceId) {
+            this.failRuntime({ stage: "extension", code: "runtime_identity_mismatch", message: "Remote Pi extension reported a different endpoint runtime identity", retryable: false });
+            return;
+        }
+        this.extensionReady = true;
+        this.extensionReadyEvent = event;
+        if (event.session_id)
+            this._sessionId = event.session_id;
+        this.maybeMarkReady();
+    }
+    maybeMarkReady() {
+        if (!this.rpcReady || !this.extensionReady || this._runtime === "failed" || !this.child)
+            return;
+        this._process = "running";
+        if (this.readinessTimer) {
+            clearTimeout(this.readinessTimer);
+            this.readinessTimer = null;
+        }
+        this._runtime = "ready";
+        this._state = "running";
+        this.readyResolve?.(true);
+        this.readyResolve = null;
+        this.emit("runtime_ready", { ...this.extensionReadyEvent, session_id: this._sessionId, endpoint_id: this.opts.endpointId, runtime_instance_id: this._runtimeInstanceId });
+    }
+    failRuntime(event) {
+        if (this._runtime === "failed")
+            return;
+        if (this.readinessTimer) {
+            clearTimeout(this.readinessTimer);
+            this.readinessTimer = null;
+        }
+        this._runtime = "failed";
+        this._state = event.retryable ? "crashed" : "blocked";
+        this.readyResolve?.(false);
+        this.readyResolve = null;
+        this.emit("runtime_failed", event);
+    }
+    onExit(code, signal) {
         if (code === EXIT_DAEMON_FRESH_SESSION)
             this.forceFreshSessionOnNextSpawn = true;
-        // A deliberate stop() kills by signal — not a crash, so the supervisor
-        // must NOT auto-restart it. Only an UNexpected exit counts as a crash.
-        const isCrash = !this._stopping && (code !== 0 || signal !== null);
+        if (this.readinessTimer) {
+            clearTimeout(this.readinessTimer);
+            this.readinessTimer = null;
+        }
+        const isCrash = !this._stopping;
+        this._process = "exited";
+        if (this._runtime !== "failed")
+            this._runtime = "pending";
         this._state = isCrash ? "crashed" : "stopped";
         this.child = null;
-        this._startedAt = null;
+        this._startedAt = undefined;
         this._busy = false;
-        for (const p of this._statePending.values()) {
-            clearTimeout(p.timer);
-            p.resolve(false);
+        this._relay = "disconnected";
+        this.readyResolve?.(false);
+        this.readyResolve = null;
+        for (const pending of this.statePending.values()) {
+            clearTimeout(pending.timer);
+            pending.resolve(false);
+        }
+        this.statePending.clear();
+        for (const pending of this.promptPending.values()) {
+            clearTimeout(pending.timer);
+            pending.resolve({ accepted: false, code: "child_exited", error: "daemon exited before Pi accepted the prompt" });
         }
-        this._statePending.clear();
+        this.promptPending.clear();
         this.emit("exit", { code, signal, isCrash });
     }
-    /** Bumps the restart counter — called by the supervisor when it
-     *  decides to re-spawn after a crash. Exposed so tests can drive it. */
-    noteRestart() {
-        this._restartCount += 1;
-    }
+    noteRestart() { this._restartCount += 1; }
 }
 //# sourceMappingURL=rpc_child.js.map