@agentprojectcontext/apx 1.66.0 → 1.67.0

package/src/host/daemon/api/artifact-preview.js

@@ -0,0 +1,82 @@
+// Artifact preview + sharing routes.
+//   POST   /projects/:pid/artifacts/:name/preview   body: { watch? }
+//   GET    /projects/:pid/previews
+//   GET    /previews
+//   DELETE /previews/:id
+//   POST   /previews/:id/tunnel                      body: { provider? }
+//   DELETE /previews/:id/tunnel
+//
+// Preview servers and tunnels live in process-wide singletons (see
+// #core/artifacts/preview.js and tunnel.js) so they survive across requests
+// for the daemon's lifetime.
+import { previews } from "#core/artifacts/preview.js";
+import { tunnels, detectProviders } from "#core/artifacts/tunnel.js";
+
+export function register(app, { project }) {
+  // Start (or reuse) an ephemeral preview server for an artifact.
+  app.post("/projects/:pid/artifacts/:name/preview", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const name = decodeURIComponent(req.params.name);
+    const watch = req.body?.watch !== false;
+    try {
+      const view = await previews.start({
+        storagePath: p.storagePath,
+        name,
+        projectId: p.id,
+        watch,
+      });
+      res.status(201).json(view);
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+
+  // List preview servers scoped to a project.
+  app.get("/projects/:pid/previews", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    res.json(previews.list(p.id));
+  });
+
+  // List every live preview (all projects).
+  app.get("/previews", (_req, res) => {
+    res.json(previews.list());
+  });
+
+  // Which tunnel providers this host can use, best first.
+  app.get("/previews/tunnel-providers", (_req, res) => {
+    res.json({ providers: detectProviders() });
+  });
+
+  // Stop a preview server (also closes its tunnel).
+  app.delete("/previews/:id", async (req, res) => {
+    const rec = previews.get(req.params.id);
+    if (rec?.tunnel) tunnels.close(rec.tunnel.id);
+    const ok = await previews.stop(req.params.id);
+    res.status(ok ? 204 : 404).end();
+  });
+
+  // Open a public tunnel to a preview's local port.
+  app.post("/previews/:id/tunnel", async (req, res) => {
+    const rec = previews.get(req.params.id);
+    if (!rec) return res.status(404).json({ error: "preview not found" });
+    if (rec.tunnel) return res.json(rec.tunnel); // already shared
+    try {
+      const tunnel = await tunnels.open(rec.port, { provider: req.body?.provider });
+      previews.attachTunnel(rec.id, tunnel);
+      res.status(201).json(tunnel);
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
+  // Close a preview's tunnel but keep the local server running.
+  app.delete("/previews/:id/tunnel", (req, res) => {
+    const rec = previews.get(req.params.id);
+    if (!rec || !rec.tunnel) return res.status(404).end();
+    tunnels.close(rec.tunnel.id);
+    previews.attachTunnel(rec.id, null);
+    res.status(204).end();
+  });
+}

package/src/host/daemon/api/web.js

@@ -24,7 +24,7 @@ const API_PREFIXES = [
   "/health", "/admin", "/projects", "/telegram", "/engines", "/runtimes",
   "/messages", "/sessions", "/tools", "/mcp", "/voice", "/tts", "/desktop", "/overlay",
   "/transcribe", "/run", "/files", "/memory", "/env", "/pair", "/deck",
-  "/super-agent", "/identity",
+  "/super-agent", "/identity", "/skills",
 ];
 
 export function isApiPath(p) {

package/src/host/daemon/api.js

@@ -33,6 +33,7 @@ import { register as registerConnections } from "./api/connections.js";
 import { register as registerRuntimes } from "./api/runtimes.js";
 import { register as registerRoutines } from "./api/routines.js";
 import { register as registerArtifacts } from "./api/artifacts.js";
+import { register as registerArtifactPreview } from "./api/artifact-preview.js";
 import { register as registerTasks } from "./api/tasks.js";
 import { register as registerOrganization } from "./api/organization.js";
 import { register as registerProjectFiles } from "./api/files-project.js";
@@ -124,6 +125,7 @@ export function buildApi({
   registerRuntimes(app, ctx);
   registerRoutines(app, ctx);
   registerArtifacts(app, ctx);
+  registerArtifactPreview(app, ctx);
   registerTasks(app, ctx);
   registerOrganization(app, ctx);
   registerProjectFiles(app, ctx);

package/src/host/daemon/index.js

@@ -15,6 +15,12 @@ import {
   APX_HOME,
   TOKEN_PATH,
 } from "#core/config/index.js";
+import {
+  collectSecretValues,
+  collectMcpSecretValues,
+  registerSecretValues,
+} from "#core/config/secret-values.js";
+import { readGlobalMcps, readRuntimeMcps } from "#core/mcp/sources.js";
 import { ProjectManager } from "./db.js";
 import { McpRegistry } from "#core/mcp/runner.js";
 import { PluginManager } from "./plugins/index.js";
@@ -156,17 +162,26 @@ async function main() {
   const host = effectiveHost(cfg);
   const port = effectivePort(cfg);
 
+  // Value-based secret masking: register every known secret VALUE (engine
+  // keys, telegram tokens, MCP env/header tokens) so core/logging.js can
+  // scrub them from any log text they leak into. Refreshed on config PATCH
+  // in api/admin-config.js.
+  registerSecretValues(collectSecretValues(cfg));
+  registerSecretValues(collectMcpSecretValues(readGlobalMcps()));
+
   const projects = new ProjectManager(cfg);
   const registries = new RegistryCache();
 
   // Default project (id=0) is always available — no local .apc/ required.
-  projects.registerDefault();
+  const defaultProject = projects.registerDefault();
+  registerSecretValues(collectMcpSecretValues(readRuntimeMcps(defaultProject.storagePath)));
 
   // Load registered projects from config.
   for (const entry of cfg.projects) {
     try {
       const p = projects.register(entry.path);
       registries.ensure(p);
+      registerSecretValues(collectMcpSecretValues(readRuntimeMcps(p.storagePath)));
       log(`loaded project #${p.id} ${p.path}`);
     } catch (e) {
       log(`skipping project ${entry.path}: ${e.message}`);

package/src/interfaces/acp/index.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+// APX ACP agent — serves the APX super-agent over the Agent Client Protocol
+// (https://agentclientprotocol.com, JSON-RPC 2.0 over newline-delimited JSON
+// on stdio), so ACP clients (Zed, JetBrains, marimo, …) can drive it.
+// Canonical launch: `apx acp` (bin alias `apx-acp` mirrors `apx-mcp`).
+//
+// Like the mcp-server surface, this is a thin adapter over the daemon HTTP
+// API: each `session/prompt` becomes a POST to the NDJSON stream endpoint
+// `/projects/:pid/super-agent/chat/stream` and the stream events are mapped
+// onto ACP `session/update` notifications:
+//
+//   assistant_text         → agent_message_chunk
+//   tool_start             → tool_call        (status: in_progress)
+//   tool_result            → tool_call_update (status: completed|failed)
+//   confirmation_required  → session/request_permission round-trip, answered
+//                            via POST /super-agent/confirm/:correlationId
+//   final                  → session/prompt response { stopReason }
+//
+// IMPORTANT: stdout carries the protocol. Never log to stdout here — errors
+// go to stderr and the unified file log only.
+
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { CHANNELS } from "#core/constants/channels.js";
+import { loggerFor } from "#core/logging.js";
+import { APX_HOME } from "#core/config/index.js";
+import { JsonRpcConnection, JsonRpcError, JSONRPC_ERROR_CODES } from "./jsonrpc.js";
+import {
+  createDaemonClient,
+  createSession,
+  extractPromptText,
+  resolveProjectForCwd,
+  summarizeToolResult,
+  toolKindFor,
+} from "./session.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Single major version integer per the ACP initialization spec.
+export const ACP_PROTOCOL_VERSION = 1;
+
+const log = loggerFor("acp");
+
+function packageVersion() {
+  try {
+    return JSON.parse(
+      fs.readFileSync(path.join(__dirname, "..", "..", "..", "package.json"), "utf8")
+    ).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+export class AcpAgentServer {
+  /**
+   * @param {{ input: import("node:stream").Readable,
+   *           output: import("node:stream").Writable,
+   *           daemon: { baseUrl: string, token?: string | (() => string) },
+   *           ensureDaemon?: (() => Promise<void>) | null,
+   *           version?: string }} opts
+   * `daemon` and the streams are injectable so tests can run fully offline
+   * against an in-process daemon API and PassThrough pipes.
+   */
+  constructor({ input, output, daemon, ensureDaemon = null, version = packageVersion() }) {
+    this.version = version;
+    this.sessions = new Map();
+    this.clientCapabilities = {};
+    this.client = createDaemonClient({
+      baseUrl: daemon.baseUrl,
+      token: daemon.token || "",
+      ensureReady: ensureDaemon,
+    });
+    this.connection = new JsonRpcConnection({
+      input,
+      output,
+      onError: (e) => this.#logError("connection error", e),
+    });
+  }
+
+  start() {
+    this.connection
+      .method("initialize", (params) => this.#initialize(params))
+      // No auth methods are advertised, so authenticate is a no-op accept —
+      // daemon access control is the local bearer token, not an ACP concern.
+      .method("authenticate", () => ({}))
+      .method("session/new", (params) => this.#newSession(params))
+      .method("session/prompt", (params) => this.#prompt(params))
+      .method("session/cancel", (params) => this.#cancel(params));
+    return this;
+  }
+
+  whenClosed() {
+    return this.connection.whenClosed();
+  }
+
+  #logError(msg, err) {
+    const detail = err?.message || String(err || "");
+    try {
+      log.error(`${msg}: ${detail}`);
+    } catch {
+      /* file log is best-effort */
+    }
+    process.stderr.write(`apx acp: ${msg}: ${detail}\n`);
+  }
+
+  #initialize(params) {
+    const requested = Number(params?.protocolVersion);
+    this.clientCapabilities = params?.clientCapabilities || {};
+    return {
+      // Same version when we support what the client asked for, otherwise the
+      // latest we do support — the client decides whether to disconnect.
+      protocolVersion:
+        requested === ACP_PROTOCOL_VERSION ? requested : ACP_PROTOCOL_VERSION,
+      agentCapabilities: {
+        loadSession: false,
+        promptCapabilities: { image: false, audio: false, embeddedContext: false },
+        mcpCapabilities: { http: false, sse: false },
+      },
+      agentInfo: { name: "apx", title: "APX Super-Agent", version: this.version },
+      authMethods: [],
+    };
+  }
+
+  async #newSession(params) {
+    const cwd = params?.cwd;
+    if (!cwd || typeof cwd !== "string" || !path.isAbsolute(cwd)) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_PARAMS,
+        "cwd must be an absolute path"
+      );
+    }
+    let project;
+    try {
+      project = await resolveProjectForCwd(this.client, cwd);
+    } catch (e) {
+      throw new JsonRpcError(JSONRPC_ERROR_CODES.INTERNAL_ERROR, e.message);
+    }
+    const sessionId = `sess_${randomUUID().replace(/-/g, "")}`;
+    this.sessions.set(sessionId, createSession({ id: sessionId, project, cwd }));
+    return { sessionId };
+  }
+
+  #session(params) {
+    const session = this.sessions.get(params?.sessionId);
+    if (!session) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_PARAMS,
+        `unknown sessionId: ${params?.sessionId}`
+      );
+    }
+    return session;
+  }
+
+  async #prompt(params) {
+    const session = this.#session(params);
+    if (session.activeTurn) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_REQUEST,
+        "a prompt turn is already in progress for this session"
+      );
+    }
+    const promptText = extractPromptText(params.prompt);
+    if (!promptText) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_PARAMS,
+        "prompt must include at least one text content block"
+      );
+    }
+
+    const turn = {
+      abort: new AbortController(),
+      cancelled: false,
+      lastToolCallId: null,
+      messageSeq: 0,
+      sentTexts: new Set(),
+    };
+    session.activeTurn = turn;
+    try {
+      const final = await this.client.streamPost(
+        `/projects/${session.project.id}/super-agent/chat/stream`,
+        {
+          prompt: promptText,
+          // ACP clients are coding surfaces (IDEs) — the `code` channel gives
+          // them the coding system prompt + git/code tools, same as apx code.
+          channel: CHANNELS.CODE,
+          previousMessages: session.history,
+        },
+        (event) => this.#onDaemonEvent(session, turn, event),
+        { signal: turn.abort.signal }
+      );
+      if (turn.cancelled) return { stopReason: "cancelled" };
+      if (!final) {
+        throw new JsonRpcError(
+          JSONRPC_ERROR_CODES.INTERNAL_ERROR,
+          "daemon stream ended without a final result"
+        );
+      }
+      // In-process history feeds previousMessages on the next turn, so the
+      // conversation keeps context without daemon-side session storage.
+      session.history.push({ role: "user", content: promptText });
+      if (final.text) session.history.push({ role: "assistant", content: final.text });
+      return { stopReason: "end_turn" };
+    } catch (e) {
+      // Aborts surface as generic stream errors — per spec, cancellation MUST
+      // resolve the prompt with the "cancelled" stop reason, never an error.
+      if (turn.cancelled) return { stopReason: "cancelled" };
+      if (e instanceof JsonRpcError) throw e;
+      throw new JsonRpcError(JSONRPC_ERROR_CODES.INTERNAL_ERROR, e.message);
+    } finally {
+      session.activeTurn = null;
+    }
+  }
+
+  // session/cancel is a notification — no response, just abort the in-flight
+  // daemon stream; #prompt observes `cancelled` and resolves the turn.
+  #cancel(params) {
+    const session = this.sessions.get(params?.sessionId);
+    const turn = session?.activeTurn;
+    if (!turn) return;
+    turn.cancelled = true;
+    turn.abort.abort();
+  }
+
+  #notifyUpdate(session, update) {
+    this.connection.notify("session/update", { sessionId: session.id, update });
+  }
+
+  #sendMessageChunk(session, turn, text) {
+    const value = String(text || "");
+    if (!value || turn.sentTexts.has(value)) return;
+    turn.sentTexts.add(value);
+    turn.messageSeq += 1;
+    this.#notifyUpdate(session, {
+      sessionUpdate: "agent_message_chunk",
+      messageId: `msg_${session.seq}_${turn.messageSeq}`,
+      content: { type: "text", text: value },
+    });
+  }
+
+  async #onDaemonEvent(session, turn, event) {
+    switch (event?.type) {
+      case "assistant_text":
+        return this.#sendMessageChunk(session, turn, event.text);
+      // The loop only emits assistant_text for mid-turn progress; the closing
+      // reply usually travels solely inside the final result, so surface it
+      // as a chunk here (deduped against anything already streamed).
+      case "final":
+        return this.#sendMessageChunk(session, turn, event.result?.text);
+      case "tool_start": {
+        const trace = event.trace || {};
+        const toolCallId = String(trace.id || `call_${randomUUID().slice(0, 8)}`);
+        turn.lastToolCallId = toolCallId;
+        this.#notifyUpdate(session, {
+          sessionUpdate: "tool_call",
+          toolCallId,
+          title: String(trace.tool || "tool"),
+          kind: toolKindFor(trace.tool),
+          status: "in_progress",
+          ...(trace.args && typeof trace.args === "object" ? { rawInput: trace.args } : {}),
+        });
+        return;
+      }
+      case "tool_result": {
+        const trace = event.trace || {};
+        const failed =
+          trace.result && typeof trace.result === "object" && trace.result.error != null;
+        this.#notifyUpdate(session, {
+          sessionUpdate: "tool_call_update",
+          toolCallId: String(trace.id || turn.lastToolCallId || "call_unknown"),
+          status: failed ? "failed" : "completed",
+          content: [
+            {
+              type: "content",
+              content: { type: "text", text: summarizeToolResult(trace.result) },
+            },
+          ],
+          ...(trace.result && typeof trace.result === "object"
+            ? { rawOutput: trace.result }
+            : {}),
+        });
+        return;
+      }
+      case "confirmation_required":
+        return this.#requestPermission(session, turn, event);
+      default:
+        // model_start, model_routed, skill_inspector, … are APX-internal
+        // progress events with no ACP counterpart.
+        return;
+    }
+  }
+
+  async #requestPermission(session, turn, event) {
+    let confirmed = false;
+    try {
+      const res = await this.connection.request("session/request_permission", {
+        sessionId: session.id,
+        toolCall: {
+          toolCallId: turn.lastToolCallId || String(event.correlationId),
+          title: String(event.description || event.tool || "tool call"),
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" },
+        ],
+      });
+      const outcome = res?.outcome;
+      confirmed = outcome?.outcome === "selected" && outcome.optionId === "allow";
+    } catch (e) {
+      // Client gone or errored — never self-approve.
+      this.#logError("permission request failed", e);
+      confirmed = false;
+    }
+    try {
+      await this.client.post(
+        `/super-agent/confirm/${encodeURIComponent(event.correlationId)}`,
+        { confirmed }
+      );
+    } catch (e) {
+      // The pending-store entry times out on its own; log and move on.
+      this.#logError("confirm resolution failed", e);
+    }
+  }
+}
+
+/** Run the ACP agent on the current process stdio against the local daemon. */
+export async function startStdioAcpServer() {
+  // Lazy import: the CLI http helper auto-starts the daemon; tests never
+  // reach this path (they inject their own base URL).
+  const { ensureDaemon } = await import("#interfaces/cli/http.js");
+  const host = process.env.APX_HOST || "127.0.0.1";
+  const port = parseInt(process.env.APX_PORT || "7430", 10);
+  const tokenPath = path.join(APX_HOME, "daemon.token");
+  const server = new AcpAgentServer({
+    input: process.stdin,
+    output: process.stdout,
+    daemon: {
+      baseUrl: `http://${host}:${port}`,
+      // Re-read per request so a daemon restart with a rotated token mid-
+      // session keeps working.
+      token: () => {
+        try {
+          return fs.readFileSync(tokenPath, "utf8").trim();
+        } catch {
+          return "";
+        }
+      },
+    },
+    ensureDaemon: () => ensureDaemon({ silent: true }),
+  });
+  server.start();
+  await server.whenClosed();
+}
+
+const isMain =
+  process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (isMain) {
+  startStdioAcpServer().catch((e) => {
+    process.stderr.write(`apx acp: fatal: ${e?.message || e}\n`);
+    process.exit(1);
+  });
+}

package/src/interfaces/acp/jsonrpc.js

@@ -0,0 +1,180 @@
+// Newline-delimited JSON-RPC 2.0 connection — the ACP stdio framing.
+//
+// Per the ACP transport spec (agentclientprotocol.com, transports.mdx):
+// messages are individual JSON-RPC requests/notifications/responses, UTF-8,
+// delimited by "\n", never containing embedded newlines. Both peers can act
+// as caller and callee (the agent calls `session/request_permission` on the
+// client), so this connection is symmetric: it dispatches incoming requests
+// to registered handlers AND tracks ids of our own outgoing requests.
+//
+// Hand-rolled on purpose — the repo rule is no new npm dependencies, and the
+// framing is small enough that a library would cost more than it saves.
+
+export const JSONRPC_ERROR_CODES = Object.freeze({
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+});
+
+export class JsonRpcError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    if (data !== undefined) this.data = data;
+  }
+}
+
+export class JsonRpcConnection {
+  /**
+   * @param {{ input: import("node:stream").Readable,
+   *           output: import("node:stream").Writable,
+   *           onError?: (err: Error) => void }} opts
+   */
+  constructor({ input, output, onError = null }) {
+    this.output = output;
+    this.onError = onError;
+    this.handlers = new Map();
+    this.pending = new Map(); // id → {resolve, reject} for our outgoing requests
+    this.nextId = 0;
+    this.buffer = "";
+    this.closed = false;
+    this._closeResolvers = [];
+
+    input.setEncoding?.("utf8");
+    input.on("data", (chunk) => this._onData(String(chunk)));
+    input.on("end", () => this._close());
+    input.on("close", () => this._close());
+    input.on("error", () => this._close());
+  }
+
+  /** Register a handler for an incoming method (request or notification). */
+  method(name, handler) {
+    this.handlers.set(name, handler);
+    return this;
+  }
+
+  /** Resolves when the peer closes its side of the pipe. */
+  whenClosed() {
+    if (this.closed) return Promise.resolve();
+    return new Promise((resolve) => this._closeResolvers.push(resolve));
+  }
+
+  /** Send a one-way notification to the peer. */
+  notify(method, params) {
+    this._send({ jsonrpc: "2.0", method, params });
+  }
+
+  /** Send a request to the peer and await its response. */
+  request(method, params) {
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      if (this.closed) return reject(new Error("connection closed"));
+      this.pending.set(id, { resolve, reject });
+      this._send({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+
+  _close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const { reject } of this.pending.values()) {
+      reject(new Error("connection closed"));
+    }
+    this.pending.clear();
+    for (const resolve of this._closeResolvers) resolve();
+    this._closeResolvers = [];
+  }
+
+  _send(msg) {
+    if (this.closed) return;
+    try {
+      this.output.write(JSON.stringify(msg) + "\n");
+    } catch (e) {
+      this.onError?.(e);
+    }
+  }
+
+  _onData(text) {
+    this.buffer += text;
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        this._send({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: JSONRPC_ERROR_CODES.PARSE_ERROR, message: "parse error" },
+        });
+        continue;
+      }
+      // Fire-and-forget: a long-running request (session/prompt) must not
+      // block later frames — `session/cancel` has to be processed while the
+      // prompt handler is still awaiting the daemon stream.
+      this._dispatch(msg).catch((e) => this.onError?.(e));
+    }
+  }
+
+  async _dispatch(msg) {
+    if (!msg || typeof msg !== "object") return;
+
+    if (typeof msg.method === "string") {
+      const hasId = msg.id !== undefined && msg.id !== null;
+      const handler = this.handlers.get(msg.method);
+      if (!handler) {
+        if (hasId) {
+          this._send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: {
+              code: JSONRPC_ERROR_CODES.METHOD_NOT_FOUND,
+              message: `method not found: ${msg.method}`,
+            },
+          });
+        }
+        return;
+      }
+      try {
+        const result = await handler(msg.params ?? {});
+        if (hasId) this._send({ jsonrpc: "2.0", id: msg.id, result: result ?? null });
+      } catch (e) {
+        if (hasId) {
+          this._send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: {
+              code: typeof e?.code === "number" ? e.code : JSONRPC_ERROR_CODES.INTERNAL_ERROR,
+              message: e?.message || "internal error",
+              ...(e?.data !== undefined ? { data: e.data } : {}),
+            },
+          });
+        } else {
+          this.onError?.(e);
+        }
+      }
+      return;
+    }
+
+    // Response to one of our outgoing requests.
+    if (msg.id !== undefined && this.pending.has(msg.id)) {
+      const { resolve, reject } = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        reject(
+          Object.assign(new Error(msg.error.message || "remote error"), {
+            code: msg.error.code,
+            data: msg.error.data,
+          })
+        );
+      } else {
+        resolve(msg.result);
+      }
+    }
+  }
+}