zidane 7.2.5 → 8.0.4

package/dist/{isolation-Kfoof0MM.d.ts → isolation-D9L650W5.d.ts}

@@ -1,5 +1,4 @@
 import { Buffer } from "node:buffer";
-
 //#region src/contexts/types.d.ts
 /**
  * Lifetime guarantee of background tasks started through
@@ -144,8 +143,11 @@ interface SpawnConfig {
   mounts?: ContextMount[];
   /** Resource limits */
   limits?: {
-    /** Memory limit in MB */memory?: number; /** CPU limit (e.g. '1.0' = 1 core) */
-    cpu?: string; /** Timeout in seconds for the entire context lifetime */
+    /** Memory limit in MB */
+    memory?: number;
+    /** CPU limit (e.g. '1.0' = 1 core) */
+    cpu?: string;
+    /** Timeout in seconds for the entire context lifetime */
     timeout?: number;
   };
   /** Sandbox provider config (only for 'sandbox' context) */
@@ -339,7 +341,8 @@ interface ExecutionContext {
      * Must already exist OR be creatable by the context — the
      * implementation handles `mkdir -p` defensively.
      */
-    outputDir: string; /** Push-style exit callback. Optional — see the method doc. */
+    outputDir: string;
+    /** Push-style exit callback. Optional — see the method doc. */
     onExit?: (info: TaskExitInfo) => void;
     /**
      * Cap on bytes written to the output file. Beyond the cap the
@@ -355,8 +358,15 @@ interface ExecutionContext {
      * consumer decides (typically by telling the model the task may
      * be stuck at an interactive prompt). Unset = no watchdog.
      */
-    stallTimeoutMs?: number; /** One-shot stall callback — see `stallTimeoutMs`. */
+    stallTimeoutMs?: number;
+    /** One-shot stall callback — see `stallTimeoutMs`. */
     onStall?: (info: TaskStallInfo) => void;
+    /**
+     * Run the task in a terminal — see {@link BackgroundTerminalOptions}.
+     * Contexts without terminal support ignore it and use pipes; check
+     * {@link TaskHandle.terminal} to know which one happened.
+     */
+    terminal?: BackgroundTerminalOptions;
   }) => Promise<TaskHandle>;
   /**
    * Open a LIVE bidirectional byte stream to a long-lived process in the
@@ -405,9 +415,29 @@ interface ExecutionContext {
    */
   execStream?: (handle: ExecutionHandle, command: string, options?: {
     cwd?: string;
-    env?: Record<string, string>; /** Aborts startup and kills the child once running. */
+    env?: Record<string, string>;
+    /** Aborts startup and kills the child once running. */
     signal?: AbortSignal;
   }) => Promise<StreamHandle>;
+  /**
+   * Open an interactive terminal (a PTY running the user's login shell) in
+   * the context: on the host, in the container, in the sandbox. For people,
+   * not protocols: the opposite of {@link execStream}, which defeats every
+   * terminal semantic this one keeps (echo, line editing, job control,
+   * window size).
+   *
+   * Optional: a context without a PTY primitive (or a runtime without one:
+   * the local contexts need Bun) leaves it undefined, and callers offer no
+   * terminal rather than falling back to a host shell.
+   */
+  openTerminal?: (handle: ExecutionHandle, options: TerminalOptions) => Promise<TerminalProcess>;
+  /**
+   * Re-attach to a terminal opened earlier, by its {@link TerminalProcess.id},
+   * after the host lost the connection (daemon restart, paused sandbox).
+   * Resolves `null` when it is gone. Only contexts whose terminals outlive
+   * the host (remote sandboxes) implement it.
+   */
+  reconnectTerminal?: (handle: ExecutionHandle, id: string, options: TerminalOptions) => Promise<TerminalProcess | null>;
   /**
    * SIGTERM the whole process group of a running background task.
    * Idempotent — second call returns `null` (or the cached exit info).
@@ -453,17 +483,24 @@ interface ExecutionContext {
    * subagent's destroy() — matching shell semantics, where a `&`-ed
    * command outlives the parent process.
    *
+   * With `fromHandle === toHandle` ownership stays put and only the
+   * callbacks are rebound: a host that keeps one handle across agent
+   * rebuilds (`chat/execution-cache.ts`) hands the running tasks to the
+   * freshly built agent this way.
+   *
    * Side effects:
    *   - The task's `handleId` is rewritten, so subsequent
    *     `listBackground(toHandle)` / `killBackground(toHandle, …)` /
    *     `destroy(toHandle)` see it (and `fromHandle`-scoped operations
    *     don't).
-   *   - When `newOnExit` is provided, the original `onExit` is
-   *     REPLACED with it. Critical: the task's natural exit callback
-   *     was captured against the spawning agent's hook bus, which is
-   *     about to be destroyed; without rewiring, the parent never
-   *     learns when the task terminates. Pass a closure that fires
-   *     the parent agent's `background:exit` hook.
+   *   - When `newOnExit` / `newOnStall` are provided, the task's OWNER
+   *     callbacks are REPLACED with them. Critical: they were captured
+   *     against the spawning agent's hook bus, which is about to be
+   *     destroyed; without rewiring, the new owner never learns when the
+   *     task terminates or stalls. Pass closures that fire the new owner's
+   *     `background:exit` / `background:stall` hooks. In-flight
+   *     `killBackground` / `waitBackground` resolvers are not owner
+   *     callbacks and keep firing.
    *
    * Returns the entries that were actually reassigned (running tasks
    * only; terminated ones stay where they are). Implementations that
@@ -471,7 +508,7 @@ interface ExecutionContext {
    * (spawn.ts) falls back to the current behavior of killing child
    * tasks at subagent shutdown.
    */
-  reassignBackgroundTasks?: (fromHandle: ExecutionHandle, toHandle: ExecutionHandle, newOnExit?: (info: TaskExitInfo) => void) => Promise<readonly TaskEntry[]>;
+  reassignBackgroundTasks?: (fromHandle: ExecutionHandle, toHandle: ExecutionHandle, newOnExit?: (info: TaskExitInfo) => void, newOnStall?: (info: TaskStallInfo) => void) => Promise<readonly TaskEntry[]>;
   /** Read a file from the context's filesystem */
   readFile: (handle: ExecutionHandle, path: string) => Promise<string>;
   /**
@@ -561,6 +598,52 @@ interface ExecutionContext {
  * The status is a coarse-grained signal; the exit code carries the
  * fine-grained detail (e.g. `143 = SIGTERM` for `'killed'`).
  */
+interface TerminalOptions {
+  /** Working directory; defaults to the handle's cwd. */
+  cwd?: string;
+  cols: number;
+  rows: number;
+  /** Extra environment on top of what the context's commands get. */
+  env?: Record<string, string>;
+  /** Variables to drop from the inherited environment (local contexts). */
+  unsetEnv?: readonly string[];
+  /** Raw terminal output. Called synchronously; never slowed by the consumer. */
+  onData: (data: Uint8Array) => void;
+}
+interface TerminalProcess {
+  /** Opaque id for {@link ExecutionContext.reconnectTerminal}. */
+  id: string;
+  /** Whether {@link ExecutionContext.reconnectTerminal} can find it again later. */
+  reconnectable: boolean;
+  /** Host pid of the shell, when it runs on this machine (for labels). */
+  localPid?: number;
+  write: (data: string | Uint8Array) => void;
+  resize: (cols: number, rows: number) => void;
+  /** End the shell and everything it started. Idempotent. */
+  kill: () => Promise<void>;
+  /** Let go without ending it (a remote PTY keeps running for a reconnect). */
+  detach: () => Promise<void>;
+  /** Resolves once with the exit code; `-1` when the connection was lost instead. */
+  exited: Promise<number>;
+}
+/**
+ * Terminal mode for {@link ExecutionContext.execBackground}: run the task in
+ * a PTY instead of pipes, so it behaves as it would for a person (colors,
+ * progress, tools that insist on a TTY) and can be watched and typed into.
+ * The log file still receives the output, with terminal control sequences
+ * removed, and the registry (kill, wait, list, reassign) is unchanged.
+ */
+interface BackgroundTerminalOptions {
+  cols: number;
+  rows: number;
+  /** Raw output as it arrives (the log gets the stripped text). */
+  onData: (data: Uint8Array) => void;
+  /** Receives the functions to type into and resize the task's terminal. */
+  onReady?: (io: {
+    write: (data: string | Uint8Array) => void;
+    resize: (cols: number, rows: number) => void;
+  }) => void;
+}
 type BackgroundTaskStatus = 'running' | 'exited' | 'killed';
 /**
  * Returned synchronously by `execBackground` — the handle the model and
@@ -582,6 +665,8 @@ interface TaskHandle {
   pid: number;
   /** Absolute path to the log file the context is streaming output into. */
   outputPath: string;
+  /** True when the task runs in a terminal (`execBackground`'s `terminal` option was honored). */
+  terminal?: boolean;
 }
 /**
  * A live bidirectional stream to a process in the context. Returned by
@@ -765,5 +850,5 @@ declare function resolveWritableRootsAsync(cwd: string, options?: Omit<ResolveWr
   gitCommonDir?: (cwd: string) => Promise<string | null>;
 }): Promise<string[]>;
 //#endregion
-export { TaskHandle as C, TaskExitInfo as S, resolveDetachedTasksCapability as T, ListFilesEntry as _, resolveWritableRoots as a, StreamHandle as b, ContextCapabilities as c, ContextType as d, DetachedTasksCapability as f, ListFileMetadata as g, ExecutionHandle as h, parseAllowWriteSetting as i, ContextHardening as l, ExecutionContext as m, IsolationPolicy as n, resolveWritableRootsAsync as o, ExecResult as p, isolationAvailability as r, BackgroundTaskStatus as s, IsolationBackend as t, ContextMount as u, ListFilesOptions as v, TaskStallInfo as w, TaskEntry as x, SpawnConfig as y };
-//# sourceMappingURL=isolation-Kfoof0MM.d.ts.map
+export { TaskExitInfo as C, TerminalProcess as D, TerminalOptions as E, resolveDetachedTasksCapability as O, TaskEntry as S, TaskStallInfo as T, ListFileMetadata as _, resolveWritableRoots as a, SpawnConfig as b, BackgroundTerminalOptions as c, ContextMount as d, ContextType as f, ExecutionHandle as g, ExecutionContext as h, parseAllowWriteSetting as i, ContextCapabilities as l, ExecResult as m, IsolationPolicy as n, resolveWritableRootsAsync as o, DetachedTasksCapability as p, isolationAvailability as r, BackgroundTaskStatus as s, IsolationBackend as t, ContextHardening as u, ListFilesEntry as v, TaskHandle as w, StreamHandle as x, ListFilesOptions as y };
+//# sourceMappingURL=isolation-D9L650W5.d.ts.map

package/dist/isolation-D9L650W5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isolation-D9L650W5.d.ts","names":[],"sources":["../src/contexts/types.ts","../src/contexts/isolation.ts"],"mappings":";;;;;;;;;;;;;;;;;KA+BY;UAEK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;EAWA;;;;;;;;EAQA;;;;;;;EAOA,gBAAgB;;;;;;iBAOF,+BAA+B,SAAS,mBAAmB;;UAU1D;EACf;EACA,MAAM;;EAEN;;UAOe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;;KAGU,0BAA0B;UAErB;;EAEf;EACA;EACA;;;;;;EAMA;;EAEA,SAAS;;UAOM;;EAEf;;;;;;;;;;;;EAYA;;EAEA,MAAM;;;;;;;;;;;EAWN;;;;;;;;;;;;;;;;EAgBA,YAAY;;EAEZ;;EAEA;;EAEA,SAAS;;EAET;;IAEE;;IAEA;;IAEA;;;EAGF;IACE;IACA;;;;;;IAMA;KACC;;;;;;;;;;EAWH;;;;;;;;;EAUA,QAAQ;IAAQ;IAAmB;IAAe;;;;;;;;;;;EAWlD;;;;;;;;EASA;;;;;;;;EASA,SAAS;;;;;;;;;;EAWT,YAAY;;;;;;;UAQG;;;;;;EAMf;;;;;EAKA;;;;;EAKA;;;;;EAKA;;UAGe;;EAEf;;EAEA;;EAEA;;;;;;;EAOA;;KAOU;UAEK;;WAEN,MAAM;;WAGN,cAAc;;EAGvB,QAAQ,SAAS,gBAAgB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;EA0BzC,OAAO,QAAQ,iBAAiB,iBAAiB;IAAY;IAAc,MAAM;IAAwB;IAAkB,SAAS;QAAkB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B9J,kBACE,QAAQ,iBACR,iBACA;IACE;IACA,MAAM;;;;;;;;IAQN;;IAEA,UAAU,MAAM;;;;;;;IAOhB;;;;;;;;IAQA;;IAEA,WAAW,MAAM;;;;;;IAMjB,WAAW;QAEV,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+Cb,cACE,QAAQ,iBACR,iBACA;IACE;IACA,MAAM;;IAEN,SAAS;QAER,QAAQ;;;;;;;;;;;;EAab,gBAAgB,QAAQ,iBAAiB,SAAS,oBAAoB,QAAQ;;;;;;;EAQ9E,qBAAqB,QAAQ,iBAAiB,YAAY,SAAS,oBAAoB,QAAQ;;;;;;;;;;;EAY/F,kBACE,QAAQ,iBACR,mBACG,QAAQ;;;;;;EAOb,kBACE,QAAQ,oBACL,iBAAiB;;;;;;;;;;;;;;;;;;EAmBtB,kBACE,QAAQ,iBACR,gBACA;IAAY;IAAoB,SAAS;QACtC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCb,2BACE,YAAY,iBACZ,UAAU,iBACV,aAAa,MAAM,uBACnB,cAAc,MAAM,2BACjB,iBAAiB;;EAGtB,WAAW,QAAQ,iBAAiB,iBAAiB;;;;;;;;;;;EAYrD,kBAAkB,QAAQ,iBAAiB,iBAAiB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCpE,YAAY,QAAQ,iBAAiB,iBAAiB;;;;;;;;EAStD,YAAY,QAAQ,iBAAiB,cAAc,kBAAkB,QAAQ,WAAW,mBAAmB;;;;;;;;;;;EAY3G,YAAY,QAAQ,iBAAiB,cAAc,UAAU,qBAAqB,QAAQ;;;;;;;;;;EAW1F,iBAAiB,QAAQ,iBAAiB,0BAA0B;;EAGpE,UAAU,QAAQ,oBAAoB;;;;;;;;;;;;UAiBvB;;EAEf;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA,SAAS,MAAM;;UAGA;;EAEf;;EAEA;;EAEA;EACA,QAAQ,eAAe;EACvB,SAAS,cAAc;;EAEvB,YAAY;;EAEZ,cAAc;;EAEd,QAAQ;;;;;;;;;UAUO;EACf;EACA;;EAEA,SAAS,MAAM;;EAEf,WAAW;IAAM,QAAQ,eAAe;IAAqB,SAAS,cAAc;;;KAG1E;;;;;;;;;UAUK;;;;;;;EAOf;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;UAce;;EAEf;;;;;;;;;;;;;;;;;;;;;;EAsBA,QAAQ,cAAc;;;;;;;;EAQtB,SAAS,cAAc;;EAEvB,QAAQ,MAAM,eAAe;;EAE7B,YAAY;;;;;EAKZ,QAAQ;;;;;;;;;;;;UAaO;EACf;EACA,QAAQ,QAAQ;EAChB;EACA,SAAS,OAAO;EAChB;;EAEA;;EAEA;;;;;;;UAQe;EACf;EACA;EACA;EACA;EACA;;;;;;EAMA;EACA;EACA,QAAQ;EACR;EACA,SAAS,OAAO;;EAEhB;;;;;;;;UASe;EACf;EACA;EACA;;EAEA;;EAEA;;;;UCp0Be;;;;;;;EAOf;;;;;;;EAOA;;;;;EAKA;;KAGU;KA2CA;EAA0B;EAAU,SAAS;EAAkB;;EAAyB;EAAW;;;;;;;;iBA6B/F,sBACd,WAAU,OAAO,UACjB,MAAK,OAAO,aACX;;;;;;iBAiCa,uBAAuB,aAAa,aAAa;UAuDhD;;EAEf;EACA,MAAM,OAAO;EACb,WAAW,OAAO;;;;;;EAMlB,gBAAgB;;;;;;;iBA8EF,qBAAqB,aAAa,UAAS;;iBAMrC,0BACpB,aACA,UAAS,KAAK;EAAiD,gBAAgB,gBAAgB;IAC9F"}

package/dist/json-rpc--HXQti1E.js

@@ -0,0 +1,350 @@
+import { Buffer } from "node:buffer";
+//#region src/acp/json-rpc.ts
+function createJsonRpcEndpoint(options) {
+	const endpoint = createEndpointCore(options);
+	return {
+		...endpoint,
+		receive(text) {
+			let message;
+			try {
+				message = JSON.parse(text);
+			} catch (err) {
+				endpoint.writeMessage(errorResponse(null, -32700, err instanceof Error ? err.message : String(err)));
+				return;
+			}
+			endpoint.handleParsed(message);
+		}
+	};
+}
+function createJsonRpcConnection(options) {
+	const frames = createFrameBuffer();
+	const endpoint = createEndpointCore({
+		...options,
+		send: options.send ?? ((json) => {
+			if (options.framing === "content-length") {
+				const bytes = Buffer.byteLength(json);
+				options.output.write(`Content-Length: ${bytes}\r\n\r\n${json}`);
+				return;
+			}
+			options.output.write(`${json}\n`);
+		})
+	});
+	const { writeMessage, handleParsed } = endpoint;
+	let deferred;
+	let closing = false;
+	let stopped = false;
+	const finish = () => {
+		if (stopped) return;
+		stopped = true;
+		clearImmediate(deferred);
+		endpoint.close();
+	};
+	const drain = () => {
+		deferred = void 0;
+		for (;;) {
+			if (stopped) return;
+			let parsed;
+			try {
+				parsed = frames.next();
+			} catch (err) {
+				frames.dropThroughNewline();
+				writeMessage(errorResponse(null, -32700, err instanceof Error ? err.message : String(err)));
+				continue;
+			}
+			if (!parsed) {
+				if (closing) finish();
+				return;
+			}
+			handleParsed(parsed.message);
+			if (isResponse(parsed.message)) {
+				deferred = setImmediate(drain);
+				return;
+			}
+		}
+	};
+	const onData = (chunk) => {
+		if (!frames.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk)) return;
+		if (deferred) return;
+		drain();
+	};
+	const onError = (err) => {
+		options.onError?.(err);
+	};
+	return {
+		start() {
+			options.input.on("data", onData);
+			options.input.on("error", onError);
+		},
+		close() {
+			if (closing) return;
+			closing = true;
+			options.input.off("data", onData);
+			options.input.off("error", onError);
+			endpoint.seal();
+			if (!deferred) finish();
+		},
+		sendNotification: endpoint.sendNotification,
+		sendRequest: endpoint.sendRequest
+	};
+}
+/** The framing-free half both shapes share: ids, pending requests, dispatch of parsed messages. */
+function createEndpointCore(options) {
+	let nextId = 1;
+	/** No more sending, no new requests (`seal`, `close`). */
+	let closed = false;
+	const pending = /* @__PURE__ */ new Map();
+	const reportError = (err) => {
+		options.onError?.(err instanceof Error ? err : new Error(String(err)));
+	};
+	/**
+	* A reply is written from a dispatch nobody awaits: an unencodable result
+	* is answered with an internal error, and a transport that throws on send
+	* (a socket torn down under the reply) is reported through `onError`. Our
+	* own requests and notifications throw to their caller, as before.
+	*/
+	const writeMessage = (message) => {
+		if (closed) return;
+		const reply = "result" in message || "error" in message;
+		let json;
+		try {
+			json = JSON.stringify({
+				...message,
+				jsonrpc: "2.0"
+			});
+		} catch (err) {
+			if (!("result" in message)) throw err;
+			writeMessage(errorResponse(message.id, -32603, err instanceof Error ? err.message : String(err)));
+			return;
+		}
+		try {
+			options.send(json, message);
+		} catch (err) {
+			if (!reply) throw err;
+			reportError(err);
+		}
+	};
+	const handleParsed = async (message) => {
+		if (!isObject(message)) {
+			writeMessage(errorResponse(null, -32600, "Invalid JSON-RPC message."));
+			return;
+		}
+		const msg = message;
+		if ("id" in msg && ("result" in msg || "error" in msg)) {
+			const request = pending.get(msg.id);
+			if (!request) return;
+			pending.delete(msg.id);
+			if ("error" in msg && msg.error) request.reject(new JsonRpcRemoteError(msg.error.message, msg.error.code, msg.error.data));
+			else request.resolve(msg.result);
+			return;
+		}
+		if (typeof msg.method !== "string") {
+			writeMessage(errorResponse(("id" in msg ? msg.id : null) ?? null, -32600, "Missing JSON-RPC method."));
+			return;
+		}
+		if ("id" in msg) {
+			try {
+				const response = await options.onRequest(msg);
+				if (response) writeMessage(response);
+			} catch (err) {
+				writeMessage(errorResponse(msg.id, -32603, err instanceof Error ? err.message : String(err)));
+			}
+			return;
+		}
+		try {
+			await options.onNotification?.(msg);
+		} catch (err) {
+			reportError(err);
+		}
+	};
+	return {
+		writeMessage,
+		/** Dispatch one parsed message; what it can't answer goes to `onError`, never an unhandled rejection. */
+		handleParsed: (message) => {
+			handleParsed(message).catch(reportError);
+		},
+		/** Stop sending and refuse new requests; pending ones stay until `close` (a reply already received may settle them). */
+		seal() {
+			closed = true;
+		},
+		close() {
+			closed = true;
+			for (const request of pending.values()) request.reject(new JsonRpcConnectionClosedError());
+			pending.clear();
+		},
+		sendNotification(method, params) {
+			writeMessage({
+				jsonrpc: "2.0",
+				method,
+				...params !== void 0 ? { params } : {}
+			});
+		},
+		sendRequest(method, params) {
+			if (closed) return Promise.reject(new JsonRpcConnectionClosedError({ sent: false }));
+			const id = nextId++;
+			writeMessage({
+				jsonrpc: "2.0",
+				id,
+				method,
+				...params !== void 0 ? { params } : {}
+			});
+			return new Promise((resolve, reject) => {
+				pending.set(id, {
+					resolve,
+					reject
+				});
+			});
+		}
+	};
+}
+/**
+* The transport closed while requests were in flight. Distinct from
+* {@link JsonRpcRemoteError} because it is not a reply — nothing on the other
+* side said anything — and callers must be able to tell "the daemon rejected
+* this" from "the daemon went away" without parsing a message string. Every
+* pending request is rejected with one of these on `close()`, and so is every
+* request made after it.
+*
+* `sent`: whether the request may have reached the other side. `false` only
+* when it was refused before being written (the connection was already
+* closed), so a caller can retry a non-idempotent call elsewhere safely.
+*/
+var JsonRpcConnectionClosedError = class extends Error {
+	sent;
+	constructor(options = {}) {
+		super("JSON-RPC connection closed.");
+		this.name = "JsonRpcConnectionClosedError";
+		this.sent = options.sent ?? true;
+	}
+};
+var JsonRpcRemoteError = class extends Error {
+	code;
+	data;
+	constructor(message, code, data) {
+		super(message);
+		this.code = code;
+		this.data = data;
+		this.name = "JsonRpcRemoteError";
+	}
+};
+function successResponse(id, result = {}) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+}
+function errorResponse(id, code, message, data) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code,
+			message,
+			...data !== void 0 ? { data } : {}
+		}
+	};
+}
+const HEADER_DELIMITER = "\r\n\r\n";
+const NEWLINE = 10;
+/**
+* Receive buffer for both framings. Incoming chunks are only listed; they are
+* concatenated when a frame can actually have completed: a newline arrived
+* (every NDJSON line and every header block ends in one) or, while a
+* Content-Length body is incomplete, once enough bytes are buffered. The
+* header-delimiter search resumes where the previous one stopped instead of
+* rescanning from byte 0. Parsing itself is {@link readNextMessage}, unchanged.
+*/
+function createFrameBuffer() {
+	let buffer = Buffer.alloc(0);
+	let chunks = [];
+	let chunkBytes = 0;
+	let delimiterFreeBefore = 0;
+	let needBytes = 0;
+	let newlineSeen = false;
+	const consume = (bytes) => {
+		buffer = buffer.subarray(bytes);
+		delimiterFreeBefore = Math.max(0, delimiterFreeBefore - bytes);
+	};
+	const findHeaderEnd = (input) => {
+		const at = input.indexOf(HEADER_DELIMITER, delimiterFreeBefore);
+		if (at < 0) delimiterFreeBefore = Math.max(0, input.length - 3);
+		return at;
+	};
+	return {
+		/** Buffer a chunk; true when a frame may now be complete and `next()` should run. */
+		push(chunk) {
+			if (chunk.length === 0) return false;
+			chunks.push(chunk);
+			chunkBytes += chunk.length;
+			if (!newlineSeen && chunk.includes(NEWLINE)) newlineSeen = true;
+			if (needBytes > 0) return buffer.length + chunkBytes >= needBytes;
+			return newlineSeen;
+		},
+		/** Next complete message, or null when more bytes are needed. Throws on a malformed frame. */
+		next() {
+			if (chunks.length > 0) {
+				buffer = Buffer.concat([buffer, ...chunks]);
+				chunks = [];
+				chunkBytes = 0;
+			}
+			const parsed = readNextMessage(buffer, findHeaderEnd);
+			if (parsed === null || "needBytes" in parsed) {
+				needBytes = parsed?.needBytes ?? 0;
+				newlineSeen = false;
+				return null;
+			}
+			needBytes = 0;
+			consume(parsed.consumed);
+			return { message: parsed.message };
+		},
+		/** Parse-error resync: drop through the first newline (everything when there is none). */
+		dropThroughNewline() {
+			const newline = buffer.indexOf(NEWLINE);
+			consume(newline >= 0 ? newline + 1 : buffer.length);
+		}
+	};
+}
+function readNextMessage(input, findHeaderEnd) {
+	if (input.length === 0) return null;
+	const headerEnd = findHeaderEnd(input);
+	if (headerEnd >= 0) {
+		const header = input.subarray(0, headerEnd).toString("utf8");
+		const match = /^Content-Length:\s*(\d+)/im.exec(header);
+		if (!match) return readLineMessage(input);
+		const length = Number(match[1]);
+		const bodyStart = headerEnd + 4;
+		const bodyEnd = bodyStart + length;
+		if (input.length < bodyEnd) return { needBytes: bodyEnd };
+		const body = input.subarray(bodyStart, bodyEnd).toString("utf8");
+		return {
+			message: JSON.parse(body),
+			consumed: bodyEnd
+		};
+	}
+	if (/^Content-Length:/i.test(input.subarray(0, Math.min(input.length, 32)).toString("utf8"))) return null;
+	return readLineMessage(input);
+}
+function readLineMessage(input) {
+	let offset = 0;
+	for (;;) {
+		const lineEnd = input.indexOf(NEWLINE, offset);
+		if (lineEnd < 0) return null;
+		const line = input.subarray(offset, lineEnd).toString("utf8").trim();
+		offset = lineEnd + 1;
+		if (line.length === 0) continue;
+		return {
+			message: JSON.parse(line),
+			consumed: offset
+		};
+	}
+}
+function isResponse(message) {
+	return isObject(message) && "id" in message && ("result" in message || "error" in message);
+}
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+export { errorResponse as a, createJsonRpcEndpoint as i, JsonRpcRemoteError as n, successResponse as o, createJsonRpcConnection as r, JsonRpcConnectionClosedError as t };
+
+//# sourceMappingURL=json-rpc--HXQti1E.js.map

package/dist/json-rpc--HXQti1E.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-rpc--HXQti1E.js","names":[],"sources":["../src/acp/json-rpc.ts"],"sourcesContent":["import type { Readable, Writable } from 'node:stream'\nimport type { AcpPeer, JsonRpcFailure, JsonRpcId, JsonRpcMessage, JsonRpcRequest, JsonRpcResponse } from './types'\nimport { Buffer } from 'node:buffer'\nimport { AcpErrorCode } from './types'\n\nexport interface JsonRpcConnectionOptions {\n  input: Readable\n  output: Writable\n  onRequest: (message: JsonRpcRequest) => Promise<JsonRpcResponse | null | undefined> | JsonRpcResponse | null | undefined\n  onNotification?: (message: JsonRpcMessage & { method: string, id?: undefined }) => void | Promise<void>\n  framing?: 'content-length' | 'newline'\n  onError?: (error: Error) => void\n  /**\n   * Write each serialized message yourself instead of to `output` (framing\n   * included): a transport that budgets replies and the rest apart\n   * (`src/ipc/transports/send-budget.ts`). `message` is what was serialized.\n   */\n  send?: (json: string, message: JsonRpcMessage) => void\n}\n\nexport interface JsonRpcConnection extends AcpPeer {\n  start: () => void\n  close: () => void\n}\n\n/**\n * JSON-RPC over a message transport (one message per frame, e.g. a WebSocket):\n * the request / response / notification logic of {@link createJsonRpcConnection}\n * without the byte-stream framing.\n */\nexport interface JsonRpcEndpointOptions {\n  /**\n   * Write one serialized message (a single JSON text). `message` is what was\n   * serialized, for a transport that treats replies and the rest apart.\n   */\n  send: (json: string, message: JsonRpcMessage) => void\n  onRequest: JsonRpcConnectionOptions['onRequest']\n  onNotification?: JsonRpcConnectionOptions['onNotification']\n  onError?: (error: Error) => void\n}\n\nexport interface JsonRpcEndpoint extends AcpPeer {\n  /** Handle one received frame's text; a frame that is not JSON is answered with a parse error. */\n  receive: (text: string) => void\n  /** Stop sending and reject every pending request with {@link JsonRpcConnectionClosedError}. */\n  close: () => void\n}\n\ninterface PendingRequest {\n  resolve: (value: unknown) => void\n  reject: (error: Error) => void\n}\n\nexport function createJsonRpcEndpoint(options: JsonRpcEndpointOptions): JsonRpcEndpoint {\n  const endpoint = createEndpointCore(options)\n  return {\n    ...endpoint,\n    receive(text) {\n      let message: unknown\n      try {\n        message = JSON.parse(text)\n      }\n      catch (err) {\n        endpoint.writeMessage(errorResponse(null, AcpErrorCode.ParseError, err instanceof Error ? err.message : String(err)))\n        return\n      }\n      endpoint.handleParsed(message)\n    },\n  }\n}\n\nexport function createJsonRpcConnection(options: JsonRpcConnectionOptions): JsonRpcConnection {\n  const frames = createFrameBuffer()\n  const endpoint = createEndpointCore({\n    ...options,\n    send: options.send ?? ((json) => {\n      // ACP stdio framing is newline-delimited JSON (NDJSON) and is the default.\n      // `JSON.stringify` escapes any embedded newline, so a serialized message is\n      // always a single line. LSP-style `Content-Length` framing is opt-in for\n      // non-ACP transports only.\n      if (options.framing === 'content-length') {\n        const bytes = Buffer.byteLength(json)\n        options.output.write(`Content-Length: ${bytes}\\r\\n\\r\\n${json}`)\n        return\n      }\n      options.output.write(`${json}\\n`)\n    }),\n  })\n  const { writeMessage, handleParsed } = endpoint\n\n  /*\n   * Frames are dispatched in wire order, but a response is only OBSERVED once\n   * the promise it settles has run its continuations (microtasks), while a\n   * request or notification reaches its handler synchronously. When a busy\n   * reader gets \"response, then notification\" in one chunk, dispatching both\n   * in one pass lets the notification overtake the answer it followed (e.g. an\n   * `ipc.signal` the host emitted after answering). So after a response the\n   * rest of the buffer waits one macrotask: the caller's continuation runs\n   * first, exactly as if the frames had arrived in separate reads.\n   *\n   * `close()` stops reading, but frames already received in full are still\n   * delivered, the same way (a reply, a notification and EOF can arrive in\n   * one chunk, and the owner closes on EOF before the held notification's\n   * turn). Then the endpoint closes: what is still pending is rejected.\n   */\n  let deferred: ReturnType<typeof setImmediate> | undefined\n  let closing = false\n  let stopped = false\n\n  const finish = (): void => {\n    if (stopped)\n      return\n    stopped = true\n    clearImmediate(deferred)\n    endpoint.close()\n  }\n\n  const drain = (): void => {\n    deferred = undefined\n    for (;;) {\n      if (stopped)\n        return\n      let parsed: { message: unknown } | null\n      try {\n        parsed = frames.next()\n      }\n      catch (err) {\n        // Resync to the next newline: drop ONLY the malformed line instead\n        // of zeroing the whole receive buffer, so one bad line can't discard\n        // well-formed messages already buffered behind it. A parse error\n        // implies a complete (newline-terminated) line was seen, so this\n        // always consumes at least one byte — the loop can't spin.\n        frames.dropThroughNewline()\n        writeMessage(errorResponse(null, AcpErrorCode.ParseError, err instanceof Error ? err.message : String(err)))\n        continue\n      }\n      if (!parsed) {\n        if (closing)\n          finish()\n        return\n      }\n      handleParsed(parsed.message)\n      if (isResponse(parsed.message)) {\n        deferred = setImmediate(drain)\n        return\n      }\n    }\n  }\n\n  const onData = (chunk: Buffer | string): void => {\n    // Skips the parse entirely while no frame can have completed, so a large\n    // message split into many chunks is concatenated once, not per chunk.\n    if (!frames.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk))\n      return\n    // Frames are held behind a response: the scheduled drain reads this chunk after them.\n    if (deferred)\n      return\n    drain()\n  }\n\n  const onError = (err: Error): void => {\n    options.onError?.(err)\n  }\n\n  return {\n    start() {\n      options.input.on('data', onData)\n      options.input.on('error', onError)\n    },\n    close() {\n      if (closing)\n        return\n      closing = true\n      options.input.off('data', onData)\n      options.input.off('error', onError)\n      // Nothing more goes out; replies to frames still held can still settle their requests.\n      endpoint.seal()\n      // Frames held behind a response: the scheduled drain delivers them, then finishes.\n      if (!deferred)\n        finish()\n    },\n    sendNotification: endpoint.sendNotification,\n    sendRequest: endpoint.sendRequest,\n  }\n}\n\n/** The framing-free half both shapes share: ids, pending requests, dispatch of parsed messages. */\nfunction createEndpointCore(options: JsonRpcEndpointOptions) {\n  let nextId = 1\n  /** No more sending, no new requests (`seal`, `close`). */\n  let closed = false\n  const pending = new Map<JsonRpcId, PendingRequest>()\n\n  const reportError = (err: unknown): void => {\n    options.onError?.(err instanceof Error ? err : new Error(String(err)))\n  }\n\n  /**\n   * A reply is written from a dispatch nobody awaits: an unencodable result\n   * is answered with an internal error, and a transport that throws on send\n   * (a socket torn down under the reply) is reported through `onError`. Our\n   * own requests and notifications throw to their caller, as before.\n   */\n  const writeMessage = (message: JsonRpcMessage): void => {\n    if (closed)\n      return\n    const reply = 'result' in message || 'error' in message\n    let json: string\n    try {\n      json = JSON.stringify({ ...message, jsonrpc: '2.0' })\n    }\n    catch (err) {\n      if (!('result' in message))\n        throw err\n      writeMessage(errorResponse(message.id, AcpErrorCode.InternalError, err instanceof Error ? err.message : String(err)))\n      return\n    }\n    try {\n      options.send(json, message)\n    }\n    catch (err) {\n      if (!reply)\n        throw err\n      reportError(err)\n    }\n  }\n\n  const handleParsed = async (message: unknown): Promise<void> => {\n    if (!isObject(message)) {\n      writeMessage(errorResponse(null, AcpErrorCode.InvalidRequest, 'Invalid JSON-RPC message.'))\n      return\n    }\n\n    const msg = message as unknown as JsonRpcMessage\n    if ('id' in msg && ('result' in msg || 'error' in msg)) {\n      const request = pending.get(msg.id)\n      if (!request)\n        return\n      pending.delete(msg.id)\n      if ('error' in msg && msg.error) {\n        request.reject(new JsonRpcRemoteError(msg.error.message, msg.error.code, msg.error.data))\n      }\n      else {\n        request.resolve((msg as { result?: unknown }).result)\n      }\n      return\n    }\n\n    if (typeof (msg as { method?: unknown }).method !== 'string') {\n      writeMessage(errorResponse(('id' in msg ? msg.id : null) ?? null, AcpErrorCode.InvalidRequest, 'Missing JSON-RPC method.'))\n      return\n    }\n\n    if ('id' in msg) {\n      try {\n        const response = await options.onRequest(msg as JsonRpcRequest)\n        if (response)\n          writeMessage(response)\n      }\n      catch (err) {\n        writeMessage(errorResponse(msg.id, AcpErrorCode.InternalError, err instanceof Error ? err.message : String(err)))\n      }\n      return\n    }\n\n    try {\n      await options.onNotification?.(msg as JsonRpcMessage & { method: string, id?: undefined })\n    }\n    catch (err) {\n      reportError(err)\n    }\n  }\n\n  return {\n    writeMessage,\n    /** Dispatch one parsed message; what it can't answer goes to `onError`, never an unhandled rejection. */\n    handleParsed: (message: unknown): void => {\n      handleParsed(message).catch(reportError)\n    },\n    /** Stop sending and refuse new requests; pending ones stay until `close` (a reply already received may settle them). */\n    seal() {\n      closed = true\n    },\n    close() {\n      closed = true\n      for (const request of pending.values())\n        request.reject(new JsonRpcConnectionClosedError())\n      pending.clear()\n    },\n    sendNotification(method: string, params?: unknown) {\n      writeMessage({ jsonrpc: '2.0', method, ...(params !== undefined ? { params } : {}) })\n    },\n    sendRequest(method: string, params?: unknown) {\n      if (closed)\n        return Promise.reject(new JsonRpcConnectionClosedError({ sent: false }))\n      const id = nextId++\n      writeMessage({ jsonrpc: '2.0', id, method, ...(params !== undefined ? { params } : {}) })\n      return new Promise((resolve, reject) => {\n        pending.set(id, { resolve, reject })\n      })\n    },\n  }\n}\n\n/**\n * The transport closed while requests were in flight. Distinct from\n * {@link JsonRpcRemoteError} because it is not a reply — nothing on the other\n * side said anything — and callers must be able to tell \"the daemon rejected\n * this\" from \"the daemon went away\" without parsing a message string. Every\n * pending request is rejected with one of these on `close()`, and so is every\n * request made after it.\n *\n * `sent`: whether the request may have reached the other side. `false` only\n * when it was refused before being written (the connection was already\n * closed), so a caller can retry a non-idempotent call elsewhere safely.\n */\nexport class JsonRpcConnectionClosedError extends Error {\n  readonly sent: boolean\n  constructor(options: { sent?: boolean } = {}) {\n    super('JSON-RPC connection closed.')\n    this.name = 'JsonRpcConnectionClosedError'\n    this.sent = options.sent ?? true\n  }\n}\n\nexport class JsonRpcRemoteError extends Error {\n  constructor(message: string, readonly code: number, readonly data?: unknown) {\n    super(message)\n    this.name = 'JsonRpcRemoteError'\n  }\n}\n\nexport function successResponse(id: JsonRpcId, result: unknown = {}): JsonRpcResponse {\n  return { jsonrpc: '2.0', id, result }\n}\n\nexport function errorResponse(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcFailure {\n  return {\n    jsonrpc: '2.0',\n    id,\n    error: {\n      code,\n      message,\n      ...(data !== undefined ? { data } : {}),\n    },\n  }\n}\n\nconst HEADER_DELIMITER = '\\r\\n\\r\\n'\nconst NEWLINE = 0x0A\n\n/**\n * Receive buffer for both framings. Incoming chunks are only listed; they are\n * concatenated when a frame can actually have completed: a newline arrived\n * (every NDJSON line and every header block ends in one) or, while a\n * Content-Length body is incomplete, once enough bytes are buffered. The\n * header-delimiter search resumes where the previous one stopped instead of\n * rescanning from byte 0. Parsing itself is {@link readNextMessage}, unchanged.\n */\nexport function createFrameBuffer() {\n  let buffer: Buffer<ArrayBufferLike> = Buffer.alloc(0)\n  let chunks: Buffer[] = []\n  let chunkBytes = 0\n  // No header delimiter starts before this offset of `buffer`.\n  let delimiterFreeBefore = 0\n  // Byte count `buffer` must reach for the pending Content-Length frame; 0 = none pending.\n  let needBytes = 0\n  let newlineSeen = false\n\n  const consume = (bytes: number): void => {\n    buffer = buffer.subarray(bytes)\n    delimiterFreeBefore = Math.max(0, delimiterFreeBefore - bytes)\n  }\n\n  const findHeaderEnd = (input: Buffer<ArrayBufferLike>): number => {\n    const at = input.indexOf(HEADER_DELIMITER, delimiterFreeBefore)\n    if (at < 0)\n      delimiterFreeBefore = Math.max(0, input.length - (HEADER_DELIMITER.length - 1))\n    return at\n  }\n\n  return {\n    /** Buffer a chunk; true when a frame may now be complete and `next()` should run. */\n    push(chunk: Buffer): boolean {\n      if (chunk.length === 0)\n        return false\n      chunks.push(chunk)\n      chunkBytes += chunk.length\n      if (!newlineSeen && chunk.includes(NEWLINE))\n        newlineSeen = true\n      if (needBytes > 0)\n        return buffer.length + chunkBytes >= needBytes\n      return newlineSeen\n    },\n    /** Next complete message, or null when more bytes are needed. Throws on a malformed frame. */\n    next(): { message: unknown } | null {\n      if (chunks.length > 0) {\n        buffer = Buffer.concat([buffer, ...chunks])\n        chunks = []\n        chunkBytes = 0\n      }\n      const parsed = readNextMessage(buffer, findHeaderEnd)\n      if (parsed === null || 'needBytes' in parsed) {\n        needBytes = parsed?.needBytes ?? 0\n        newlineSeen = false\n        return null\n      }\n      needBytes = 0\n      consume(parsed.consumed)\n      return { message: parsed.message }\n    },\n    /** Parse-error resync: drop through the first newline (everything when there is none). */\n    dropThroughNewline(): void {\n      const newline = buffer.indexOf(NEWLINE)\n      consume(newline >= 0 ? newline + 1 : buffer.length)\n    },\n  }\n}\n\ntype ReadResult = { message: unknown, consumed: number } | { needBytes: number } | null\n\nfunction readNextMessage(input: Buffer<ArrayBufferLike>, findHeaderEnd: (input: Buffer<ArrayBufferLike>) => number): ReadResult {\n  if (input.length === 0)\n    return null\n\n  const headerEnd = findHeaderEnd(input)\n  if (headerEnd >= 0) {\n    const header = input.subarray(0, headerEnd).toString('utf8')\n    const match = /^Content-Length:\\s*(\\d+)/im.exec(header)\n    if (!match)\n      return readLineMessage(input)\n    const length = Number(match[1])\n    const bodyStart = headerEnd + 4\n    const bodyEnd = bodyStart + length\n    if (input.length < bodyEnd)\n      return { needBytes: bodyEnd }\n    const body = input.subarray(bodyStart, bodyEnd).toString('utf8')\n    return { message: JSON.parse(body), consumed: bodyEnd }\n  }\n\n  if (/^Content-Length:/i.test(input.subarray(0, Math.min(input.length, 32)).toString('utf8')))\n    return null\n\n  return readLineMessage(input)\n}\n\nfunction readLineMessage(input: Buffer<ArrayBufferLike>): ReadResult {\n  let offset = 0\n  // Skip blank lines: NDJSON streams may contain stray newlines (e.g. a keep-\n  // alive or a trailing separator). Emitting an error for those would be wrong.\n  for (;;) {\n    const lineEnd = input.indexOf(NEWLINE, offset)\n    if (lineEnd < 0)\n      return null\n    const line = input.subarray(offset, lineEnd).toString('utf8').trim()\n    offset = lineEnd + 1\n    if (line.length === 0)\n      continue\n    return { message: JSON.parse(line), consumed: offset }\n  }\n}\n\nfunction isResponse(message: unknown): boolean {\n  return isObject(message) && 'id' in message && ('result' in message || 'error' in message)\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value)\n}\n"],"mappings":"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"}