pipane 0.1.6 → 0.1.8

package/dist/server/server/pi-rpc-protocol.js

@@ -0,0 +1,407 @@
+import { StringDecoder } from "node:string_decoder";
+const SUPPORTED_COMMAND_TYPES = [
+    "prompt",
+    "steer",
+    "abort",
+    "new_session",
+    "get_state",
+    "set_model",
+    "get_available_models",
+    "set_thinking_level",
+    "compact",
+    "get_session_stats",
+    "switch_session",
+    "fork",
+    "set_session_name",
+    "get_commands",
+];
+class ValidationFailure extends Error {
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+    }
+}
+function fail(path, message) {
+    throw new ValidationFailure(path, message);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value, path) {
+    if (!isRecord(value))
+        fail(path, "expected an object");
+    return value;
+}
+function string(value, path, allowEmpty = true) {
+    if (typeof value !== "string" || (!allowEmpty && value.length === 0)) {
+        fail(path, allowEmpty ? "expected a string" : "expected a non-empty string");
+    }
+    return value;
+}
+function optionalString(value, path) {
+    if (value !== undefined)
+        string(value, path);
+}
+function boolean(value, path) {
+    if (typeof value !== "boolean")
+        fail(path, "expected a boolean");
+    return value;
+}
+function integer(value, path) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        fail(path, "expected a non-negative safe integer");
+    return value;
+}
+function finiteNumber(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        fail(path, "expected a finite number");
+    return value;
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        fail(path, "expected an array");
+    return value;
+}
+function stringArray(value, path) {
+    array(value, path).forEach((item, index) => string(item, `${path}[${index}]`));
+}
+function thinkingLevel(value, path) {
+    if (!["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(String(value))) {
+        fail(path, "expected a supported thinking level");
+    }
+}
+function model(value, path) {
+    const source = record(value, path);
+    string(source.provider, `${path}.provider`, false);
+    string(source.id, `${path}.id`, false);
+}
+function agentMessage(value, path) {
+    const message = record(value, path);
+    string(message.role, `${path}.role`, false);
+}
+function validateState(value, path) {
+    const state = record(value, path);
+    if (state.model !== undefined && state.model !== null)
+        model(state.model, `${path}.model`);
+    thinkingLevel(state.thinkingLevel, `${path}.thinkingLevel`);
+    boolean(state.isStreaming, `${path}.isStreaming`);
+    boolean(state.isCompacting, `${path}.isCompacting`);
+    if (state.steeringMode !== "all" && state.steeringMode !== "one-at-a-time") {
+        fail(`${path}.steeringMode`, "expected all or one-at-a-time");
+    }
+    if (state.followUpMode !== "all" && state.followUpMode !== "one-at-a-time") {
+        fail(`${path}.followUpMode`, "expected all or one-at-a-time");
+    }
+    optionalString(state.sessionFile, `${path}.sessionFile`);
+    string(state.sessionId, `${path}.sessionId`);
+    optionalString(state.sessionName, `${path}.sessionName`);
+    boolean(state.autoCompactionEnabled, `${path}.autoCompactionEnabled`);
+    integer(state.messageCount, `${path}.messageCount`);
+    integer(state.pendingMessageCount, `${path}.pendingMessageCount`);
+}
+function validateSlashCommands(value, path) {
+    array(value, path).forEach((item, index) => {
+        const command = record(item, `${path}[${index}]`);
+        string(command.name, `${path}[${index}].name`, false);
+        optionalString(command.description, `${path}[${index}].description`);
+        if (!["extension", "prompt", "skill"].includes(String(command.source))) {
+            fail(`${path}[${index}].source`, "expected extension, prompt, or skill");
+        }
+        if (command.sourceInfo !== undefined)
+            record(command.sourceInfo, `${path}[${index}].sourceInfo`);
+    });
+}
+function validateSessionStats(value, path) {
+    const stats = record(value, path);
+    optionalString(stats.sessionFile, `${path}.sessionFile`);
+    string(stats.sessionId, `${path}.sessionId`, false);
+    for (const field of ["userMessages", "assistantMessages", "toolCalls", "toolResults", "totalMessages"]) {
+        integer(stats[field], `${path}.${field}`);
+    }
+    const tokens = record(stats.tokens, `${path}.tokens`);
+    for (const field of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
+        integer(tokens[field], `${path}.tokens.${field}`);
+    }
+    if (finiteNumber(stats.cost, `${path}.cost`) < 0)
+        fail(`${path}.cost`, "expected a non-negative number");
+    if (stats.contextUsage !== undefined) {
+        const context = record(stats.contextUsage, `${path}.contextUsage`);
+        if (context.tokens !== null)
+            integer(context.tokens, `${path}.contextUsage.tokens`);
+        integer(context.contextWindow, `${path}.contextUsage.contextWindow`);
+        if (context.percent !== null && finiteNumber(context.percent, `${path}.contextUsage.percent`) < 0) {
+            fail(`${path}.contextUsage.percent`, "expected a non-negative number or null");
+        }
+    }
+}
+const SUPPORTED_COMMAND_SET = new Set(SUPPORTED_COMMAND_TYPES);
+function commandType(value, path) {
+    const type = string(value, path, false);
+    if (!SUPPORTED_COMMAND_SET.has(type))
+        fail(path, `unexpected command '${type}'`);
+    return type;
+}
+function validateResponse(value) {
+    string(value.id, "$rpc.id", false);
+    const command = commandType(value.command, "$rpc.command");
+    const success = boolean(value.success, "$rpc.success");
+    if (!success) {
+        string(value.error, "$rpc.error", false);
+        return value;
+    }
+    switch (command) {
+        case "prompt":
+        case "steer":
+        case "abort":
+        case "set_thinking_level":
+        case "set_session_name":
+            break;
+        case "new_session":
+        case "switch_session": {
+            const data = record(value.data, "$rpc.data");
+            boolean(data.cancelled, "$rpc.data.cancelled");
+            break;
+        }
+        case "get_state":
+            validateState(value.data, "$rpc.data");
+            break;
+        case "set_model":
+            model(value.data, "$rpc.data");
+            break;
+        case "get_available_models": {
+            const data = record(value.data, "$rpc.data");
+            array(data.models, "$rpc.data.models").forEach((item, index) => model(item, `$rpc.data.models[${index}]`));
+            break;
+        }
+        case "compact":
+            record(value.data, "$rpc.data");
+            break;
+        case "get_session_stats":
+            validateSessionStats(value.data, "$rpc.data");
+            break;
+        case "fork": {
+            const data = record(value.data, "$rpc.data");
+            string(data.text, "$rpc.data.text");
+            boolean(data.cancelled, "$rpc.data.cancelled");
+            break;
+        }
+        case "get_commands": {
+            const data = record(value.data, "$rpc.data");
+            validateSlashCommands(data.commands, "$rpc.data.commands");
+            break;
+        }
+    }
+    return value;
+}
+function validateExtensionUiRequest(value) {
+    string(value.id, "$rpc.id", false);
+    const method = string(value.method, "$rpc.method", false);
+    switch (method) {
+        case "select":
+            string(value.title, "$rpc.title");
+            stringArray(value.options, "$rpc.options");
+            if (value.timeout !== undefined)
+                integer(value.timeout, "$rpc.timeout");
+            break;
+        case "confirm":
+            string(value.title, "$rpc.title");
+            string(value.message, "$rpc.message");
+            if (value.timeout !== undefined)
+                integer(value.timeout, "$rpc.timeout");
+            break;
+        case "input":
+            string(value.title, "$rpc.title");
+            optionalString(value.placeholder, "$rpc.placeholder");
+            if (value.timeout !== undefined)
+                integer(value.timeout, "$rpc.timeout");
+            break;
+        case "editor":
+            string(value.title, "$rpc.title");
+            optionalString(value.prefill, "$rpc.prefill");
+            break;
+        case "notify":
+            string(value.message, "$rpc.message");
+            if (value.notifyType !== undefined && !["info", "warning", "error"].includes(String(value.notifyType))) {
+                fail("$rpc.notifyType", "expected info, warning, or error");
+            }
+            break;
+        case "setStatus":
+            string(value.statusKey, "$rpc.statusKey", false);
+            optionalString(value.statusText, "$rpc.statusText");
+            break;
+        case "setWidget":
+            string(value.widgetKey, "$rpc.widgetKey", false);
+            if (value.widgetLines !== undefined)
+                stringArray(value.widgetLines, "$rpc.widgetLines");
+            if (value.widgetPlacement !== undefined && value.widgetPlacement !== "aboveEditor" && value.widgetPlacement !== "belowEditor") {
+                fail("$rpc.widgetPlacement", "expected aboveEditor or belowEditor");
+            }
+            break;
+        case "setTitle":
+            string(value.title, "$rpc.title");
+            break;
+        case "set_editor_text":
+            string(value.text, "$rpc.text");
+            break;
+        default:
+            fail("$rpc.method", `unknown extension UI method '${method}'`);
+    }
+    return value;
+}
+function validateEvent(value, type) {
+    switch (type) {
+        case "agent_start":
+        case "agent_settled":
+        case "turn_start":
+            break;
+        case "agent_end":
+            array(value.messages, "$rpc.messages").forEach((item, index) => agentMessage(item, `$rpc.messages[${index}]`));
+            boolean(value.willRetry, "$rpc.willRetry");
+            break;
+        case "turn_end":
+            agentMessage(value.message, "$rpc.message");
+            array(value.toolResults, "$rpc.toolResults").forEach((item, index) => agentMessage(item, `$rpc.toolResults[${index}]`));
+            break;
+        case "message_start":
+        case "message_end":
+            agentMessage(value.message, "$rpc.message");
+            break;
+        case "message_update":
+            agentMessage(value.message, "$rpc.message");
+            record(value.assistantMessageEvent, "$rpc.assistantMessageEvent");
+            break;
+        case "tool_execution_start":
+            string(value.toolCallId, "$rpc.toolCallId", false);
+            string(value.toolName, "$rpc.toolName", false);
+            record(value.args, "$rpc.args");
+            break;
+        case "tool_execution_update":
+            string(value.toolCallId, "$rpc.toolCallId", false);
+            string(value.toolName, "$rpc.toolName", false);
+            record(value.args, "$rpc.args");
+            record(value.partialResult, "$rpc.partialResult");
+            break;
+        case "tool_execution_end":
+            string(value.toolCallId, "$rpc.toolCallId", false);
+            string(value.toolName, "$rpc.toolName", false);
+            record(value.result, "$rpc.result");
+            boolean(value.isError, "$rpc.isError");
+            break;
+        case "queue_update":
+            stringArray(value.steering, "$rpc.steering");
+            stringArray(value.followUp, "$rpc.followUp");
+            break;
+        case "compaction_start":
+            if (!["manual", "threshold", "overflow"].includes(String(value.reason)))
+                fail("$rpc.reason", "expected a compaction reason");
+            break;
+        case "compaction_end":
+            if (!["manual", "threshold", "overflow"].includes(String(value.reason)))
+                fail("$rpc.reason", "expected a compaction reason");
+            if (value.result !== undefined && value.result !== null)
+                record(value.result, "$rpc.result");
+            boolean(value.aborted, "$rpc.aborted");
+            boolean(value.willRetry, "$rpc.willRetry");
+            optionalString(value.errorMessage, "$rpc.errorMessage");
+            break;
+        case "auto_retry_start":
+            integer(value.attempt, "$rpc.attempt");
+            integer(value.maxAttempts, "$rpc.maxAttempts");
+            integer(value.delayMs, "$rpc.delayMs");
+            string(value.errorMessage, "$rpc.errorMessage");
+            break;
+        case "auto_retry_end":
+            boolean(value.success, "$rpc.success");
+            integer(value.attempt, "$rpc.attempt");
+            optionalString(value.finalError, "$rpc.finalError");
+            break;
+        case "entry_appended":
+            record(value.entry, "$rpc.entry");
+            break;
+        case "session_info_changed":
+            optionalString(value.name, "$rpc.name");
+            break;
+        case "thinking_level_changed":
+            thinkingLevel(value.level, "$rpc.level");
+            break;
+        case "extension_error":
+            string(value.extensionPath, "$rpc.extensionPath");
+            string(value.event, "$rpc.event");
+            string(value.error, "$rpc.error");
+            break;
+        default:
+            fail("$rpc.type", `unknown event '${type}'`);
+    }
+    return value;
+}
+/** Validate one complete line emitted by Pi RPC before it reaches state mutation. */
+export function decodePiRpcLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                line,
+            },
+        };
+    }
+    try {
+        const value = record(parsed, "$rpc");
+        const type = string(value.type, "$rpc.type", false);
+        if (type === "response")
+            return { ok: true, value: validateResponse(value) };
+        if (type === "extension_ui_request")
+            return { ok: true, value: validateExtensionUiRequest(value) };
+        return { ok: true, value: validateEvent(value, type) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                message: error instanceof Error ? error.message : String(error),
+                line,
+            },
+        };
+    }
+}
+/**
+ * Pi RPC is strict JSONL: only LF delimits records. Node readline also splits on
+ * U+2028/U+2029, so use this decoder for protocol-compliant framing.
+ */
+export function attachStrictJsonlReader(stream, onLine) {
+    const decoder = new StringDecoder("utf8");
+    let buffer = "";
+    const consume = (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+        while (true) {
+            const newline = buffer.indexOf("\n");
+            if (newline === -1)
+                break;
+            let line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            if (line.length > 0)
+                onLine(line);
+        }
+    };
+    const end = () => {
+        buffer += decoder.end();
+        if (buffer.length > 0)
+            onLine(buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer);
+        buffer = "";
+    };
+    stream.on("data", consume);
+    stream.on("end", end);
+    return () => {
+        stream.removeListener("data", consume);
+        stream.removeListener("end", end);
+    };
+}
+/** Build a correlated command line after static command typing has succeeded. */
+export function encodePiRpcCommand(command, id) {
+    return `${JSON.stringify({ ...command, id })}\n`;
+}

package/dist/server/server/process-pool.js

@@ -6,8 +6,8 @@
  * reserved atomically before control returns to asynchronous application code.
  */
 import { spawn } from "node:child_process";
-import * as readline from "node:readline";
 import { existsSync } from "node:fs";
+import { attachStrictJsonlReader, decodePiRpcLine, encodePiRpcCommand, } from "./pi-rpc-protocol.js";
 /** Exclusive ownership of one pooled process. */
 export class RpcProcessLease {
     process;
@@ -114,35 +114,37 @@ export class ProcessPool {
                     recentStderr.splice(0, recentStderr.length - 60);
             }
         });
-        const rl = readline.createInterface({ input: child.stdout, terminal: false });
         const proc = {
             id: procId,
             cwd,
             process: child,
-            rl,
+            stopReadingStdout: () => { },
             pendingRequests: new Map(),
             requestId: 0,
             lastResponseTime: Date.now(),
             recentStderr,
         };
-        rl.on("line", (line) => {
-            let data;
-            try {
-                data = JSON.parse(line);
-            }
-            catch {
+        proc.stopReadingStdout = attachStrictJsonlReader(child.stdout, (line) => {
+            const decoded = decodePiRpcLine(line);
+            if (!decoded.ok) {
+                console.warn(`[pool] pi#${proc.id} ignored invalid RPC output: ${decoded.error.message}`);
                 return;
             }
-            if (data.type === "response") {
-                if (data.id && proc.pendingRequests.has(data.id)) {
-                    const pending = proc.pendingRequests.get(data.id);
-                    proc.pendingRequests.delete(data.id);
-                    proc.lastResponseTime = Date.now();
-                    pending.resolve(data);
+            const message = decoded.value;
+            if (message.type === "response") {
+                const pending = message.id ? proc.pendingRequests.get(message.id) : undefined;
+                if (!pending || !message.id)
+                    return;
+                proc.pendingRequests.delete(message.id);
+                proc.lastResponseTime = Date.now();
+                if (message.command !== pending.command) {
+                    pending.reject(new Error(`Mismatched RPC response for ${pending.command}: received ${message.command}`));
+                    return;
                 }
+                pending.resolve(message);
                 return;
             }
-            this.emitEvent(proc, data);
+            this.emitEvent(proc, message);
         });
         child.on("error", (err) => {
             console.error(`[pool] pi#${proc.id} spawn error: ${err.message}`);
@@ -178,6 +180,7 @@ export class ProcessPool {
             lease.markReleased();
         this.leases.delete(proc);
         this.decommissioning.delete(proc);
+        proc.stopReadingStdout();
         for (const pending of proc.pendingRequests.values())
             pending.reject(error);
         proc.pendingRequests.clear();
@@ -301,7 +304,6 @@ export class ProcessPool {
         }
         const timeout = timeoutMs ?? this.rpcTimeout;
         const id = `req_${++proc.requestId}`;
-        const fullCommand = { ...command, id };
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 proc.pendingRequests.delete(id);
@@ -311,22 +313,23 @@ export class ProcessPool {
                 reject(new Error(`Timeout waiting for RPC response to ${command.type}`));
             }, timeout);
             proc.pendingRequests.set(id, {
-                resolve: (data) => {
+                command: command.type,
+                resolve: (response) => {
                     clearTimeout(timer);
-                    resolve(data);
+                    resolve(response);
                 },
-                reject: (err) => {
+                reject: (error) => {
                     clearTimeout(timer);
-                    reject(err);
+                    reject(error);
                 },
             });
-            proc.process.stdin.write(JSON.stringify(fullCommand) + "\n");
+            proc.process.stdin.write(encodePiRpcCommand(command, id));
         });
     }
     async sendRpcChecked(proc, command) {
         const response = await this.sendRpc(proc, command);
-        if (!response?.success) {
-            throw new Error(response?.error || `RPC command failed: ${command.type}`);
+        if (!response.success) {
+            throw new Error(response.error || `RPC command failed: ${command.type}`);
         }
         return response;
     }