replicas-engine 0.1.964 → 0.1.965

package/dist/src/index.js

@@ -32,7 +32,7 @@ import {
   reportCommandProtectionBlock,
   resolveDiffBase,
   runGitCommand
-} from "./chunk-3NDASIOV.js";
+} from "./chunk-SLRHEFTS.js";
 import {
   ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
   AGENT_MESSAGE_DELTA_METHOD,
@@ -56,7 +56,7 @@ import {
 } from "./chunk-UPCC4BX5.js";
 import {
   publishedPullRequestUrls
-} from "./chunk-N6JCCYO3.js";
+} from "./chunk-YDKFWJY7.js";
 import {
   BaseRefreshManager,
   CodexAspAuthMethodChangedError,
@@ -71,7 +71,7 @@ import {
   refreshDelayMs,
   restartCodexAspHost,
   routineRefreshExclusions
-} from "./chunk-5M2ZF4NX.js";
+} from "./chunk-MEVE5U5A.js";
 import {
   ENGINE_ENV,
   monolithRequest,
@@ -79,16 +79,16 @@ import {
   readRuntimeEnvFile,
   reloadEngineEnv,
   setAgentCredentialSnapshot
-} from "./chunk-3ZBHY2YI.js";
+} from "./chunk-ACUYRC4H.js";
 import {
   AspClient,
   getCodexModelProvider
-} from "./chunk-TDVZOQMQ.js";
+} from "./chunk-AOF42AV2.js";
 import {
   SUBPROCESS_MAX_BUFFER,
   execAsync,
   execFileAsync
-} from "./chunk-33CDUZ6W.js";
+} from "./chunk-TP5NFRFE.js";
 import {
   isRecord as isRecord2
 } from "./chunk-UZSNFLDQ.js";
@@ -179,6 +179,7 @@ import {
   SUBAGENT_MCP_SERVER_NAME,
   SUBAGENT_MCP_TOOLS,
   SUBAGENT_MCP_TOOL_NAMES,
+  TERMINAL_RTC_ICE_SERVER,
   TIMEOUT,
   TOKEN_USAGE_PATH,
   TaskAccumulator,
@@ -318,7 +319,7 @@ import {
   workspaceCredentialProviderSchema,
   workspaceTokenRequestSchema,
   workspaceTokenResponseSchema
-} from "./chunk-MEN62XEB.js";
+} from "./chunk-BYJ6CIME.js";
 import {
   cloneMcpConfig,
   ensureCompatibilityImports,
@@ -776,7 +777,7 @@ var require_parse = __commonJS({
       }
       return parsed;
     }
-    function parse(command, args, options) {
+    function parse2(command, args, options) {
       if (args && !Array.isArray(args)) {
         options = args;
         args = null;
@@ -795,7 +796,7 @@ var require_parse = __commonJS({
       };
       return options.shell ? parsed : parseNonShell(parsed);
     }
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -854,16 +855,16 @@ var require_cross_spawn = __commonJS({
   "../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports, module) {
     "use strict";
     var cp2 = __require("child_process");
-    var parse = require_parse();
+    var parse2 = require_parse();
     var enoent = require_enoent();
     function spawn9(command, args, options) {
-      const parsed = parse(command, args, options);
+      const parsed = parse2(command, args, options);
       const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
     function spawnSync3(command, args, options) {
-      const parsed = parse(command, args, options);
+      const parsed = parse2(command, args, options);
       const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
@@ -871,7 +872,7 @@ var require_cross_spawn = __commonJS({
     module.exports = spawn9;
     module.exports.spawn = spawn9;
     module.exports.sync = spawnSync3;
-    module.exports._parse = parse;
+    module.exports._parse = parse2;
     module.exports._enoent = enoent;
   }
 });
@@ -4481,21 +4482,21 @@ var require_fast_uri2 = __commonJS({
         normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse(serialize(uri, options), options);
+        parse2(serialize(uri, options), options);
       }
       return uri;
     }
     function resolve7(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse(serialize(base, options), options);
-        relative3 = parse(serialize(relative3, options), options);
+        base = parse2(serialize(base, options), options);
+        relative3 = parse2(serialize(relative3, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative3.scheme) {
@@ -4718,7 +4719,7 @@ var require_fast_uri2 = __commonJS({
       }
       return { parsed, malformedAuthorityOrPort };
     }
-    function parse(uri, opts) {
+    function parse2(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
     }
     function normalizeString(uri, opts) {
@@ -4747,7 +4748,7 @@ var require_fast_uri2 = __commonJS({
       resolveComponent,
       equal,
       serialize,
-      parse
+      parse: parse2
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -8561,6 +8562,7 @@ import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
 import { randomUUID as randomUUID13 } from "crypto";
 import { connect } from "net";
+import { WebSocketServer } from "ws";
 
 // src/managers/github-token-manager.ts
 import path from "path";
@@ -17754,20 +17756,20 @@ var OpencodeManager = class extends CodingAgentManager {
           }
         };
       }
-      const server2 = await createOpencodeServer({
+      const server3 = await createOpencodeServer({
         port: 0,
         timeout: OPENCODE_SERVER_STARTUP_TIMEOUT_MS,
         config
       });
       const client = createOpencodeClient({
-        baseUrl: server2.url,
+        baseUrl: server3.url,
         fetch: opencodeFetch,
         headers: {
           Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
         }
       });
       this.client = client;
-      this.server = server2;
+      this.server = server3;
       this.serverSubagentMcpParentChatId = subagentMcpParentChatId;
       this.configuredModels = new Set(providerModels);
       const eventController = new AbortController();
@@ -22718,11 +22720,11 @@ var ResourceParseError = class extends McpUiError {
 };
 var ConsentError = class extends McpUiError {
   denied;
-  constructor(server2, options) {
-    const message = options.denied ? `Tool calls for "${server2}" were denied for this session` : `Tool call approval required for "${server2}"`;
+  constructor(server3, options) {
+    const message = options.denied ? `Tool calls for "${server3}" were denied for this session` : `Tool call approval required for "${server3}"`;
     super(message, {
       code: options.denied ? "CONSENT_DENIED" : "CONSENT_REQUIRED",
-      context: { server: server2 },
+      context: { server: server3 },
       recoveryHint: options.denied ? "The user denied tool access. Start a new session to try again." : "Prompt the user for consent before calling tools."
     });
     this.name = "ConsentError";
@@ -22785,13 +22787,13 @@ function findEmbeddedInputRequest(error) {
       const inputKey = boundedText(details?.inputKey, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
       const inputMethod = boundedText(details?.inputMethod, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
       if (inputKey && inputMethod && INPUT_REQUIRED_METHODS.has(inputMethod)) {
-        const server2 = boundedText(details?.server, MAX_INPUT_REQUIRED_SERVER_LENGTH);
+        const server3 = boundedText(details?.server, MAX_INPUT_REQUIRED_SERVER_LENGTH);
         const tool = boundedText(details?.tool, MAX_INPUT_REQUIRED_TARGET_LENGTH);
         const resourceUri = boundedText(details?.resourceUri, MAX_INPUT_REQUIRED_TARGET_LENGTH);
         return {
           inputKey,
           inputMethod,
-          ...server2 ? { server: server2 } : {},
+          ...server3 ? { server: server3 } : {},
           ...tool ? { tool } : {},
           ...resourceUri ? { resourceUri } : {}
         };
@@ -22812,15 +22814,15 @@ function findEmbeddedInputRequest(error) {
 function getInputRequiredNeedsUiDetails(error, identity) {
   const request = findEmbeddedInputRequest(error);
   if (!request) return void 0;
-  const server2 = boundedText(request.server ?? identity.server, MAX_INPUT_REQUIRED_SERVER_LENGTH) ?? "unknown";
+  const server3 = boundedText(request.server ?? identity.server, MAX_INPUT_REQUIRED_SERVER_LENGTH) ?? "unknown";
   const tool = boundedText(request.tool ?? identity.tool, MAX_INPUT_REQUIRED_TARGET_LENGTH);
   const resourceUri = boundedText(request.resourceUri ?? identity.resourceUri, MAX_INPUT_REQUIRED_TARGET_LENGTH);
   const target = resourceUri ? `read resource "${resourceUri}"` : tool ? `call tool "${tool}"` : "complete the MCP request";
   const guidance = request.inputMethod === "elicitation/create" ? "Run this call in an interactive Pi session with elicitation enabled, then retry." : "Run this call in an interactive Pi session with the required MCP capability enabled, then retry.";
-  const message = `MCP server "${server2}" requested input to ${target}, but this session has no handler for "${request.inputMethod}" (input "${request.inputKey}"). ${guidance}`;
+  const message = `MCP server "${server3}" requested input to ${target}, but this session has no handler for "${request.inputMethod}" (input "${request.inputKey}"). ${guidance}`;
   return {
     error: INPUT_REQUIRED_NEEDS_UI,
-    server: server2,
+    server: server3,
     ...tool ? { tool } : {},
     ...resourceUri ? { resourceUri } : {},
     inputKey: request.inputKey,
@@ -28585,8 +28587,8 @@ var require_content_type = /* @__PURE__ */ __commonJSMin(((exports) => {
   var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
   var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
   var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-  exports.parse = parse;
-  function parse(string3) {
+  exports.parse = parse2;
+  function parse2(string3) {
     if (!string3) throw new TypeError("argument string is required");
     var header = typeof string3 === "object" ? getcontenttype(string3) : string3;
     if (typeof header !== "string") throw new TypeError("argument string is required to be a string");
@@ -31741,21 +31743,21 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
   const { SCHEMES, getSchemeHandler } = require_schemes();
   function normalize(uri, options) {
-    if (typeof uri === "string") uri = serialize(parse(uri, options), options);
-    else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
+    if (typeof uri === "string") uri = serialize(parse2(uri, options), options);
+    else if (typeof uri === "object") uri = parse2(serialize(uri, options), options);
     return uri;
   }
   function resolve7(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+    const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
   function resolveComponent(base, relative3, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
-      base = parse(serialize(base, options), options);
-      relative3 = parse(serialize(relative3, options), options);
+      base = parse2(serialize(base, options), options);
+      relative3 = parse2(serialize(relative3, options), options);
     }
     options = options || {};
     if (!options.tolerant && relative3.scheme) {
@@ -31799,7 +31801,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   function equal(uriA, uriB, options) {
     if (typeof uriA === "string") {
       uriA = unescape(uriA);
-      uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), {
+      uriA = serialize(normalizeComponentEncoding(parse2(uriA, options), true), {
         ...options,
         skipEscape: true
       });
@@ -31809,7 +31811,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     });
     if (typeof uriB === "string") {
       uriB = unescape(uriB);
-      uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), {
+      uriB = serialize(normalizeComponentEncoding(parse2(uriB, options), true), {
         ...options,
         skipEscape: true
       });
@@ -31862,7 +31864,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     return uriTokens.join("");
   }
   const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-  function parse(uri, opts) {
+  function parse2(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
       scheme: void 0,
@@ -31923,7 +31925,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     resolveComponent,
     equal,
     serialize,
-    parse
+    parse: parse2
   };
   module.exports = fastUri;
   module.exports.default = fastUri;
@@ -40214,10 +40216,10 @@ var StdioClientTransport = class {
   onclose;
   onerror;
   onmessage;
-  constructor(server2) {
-    this._serverParams = server2;
-    this._readBuffer = new ReadBuffer({ maxBufferSize: server2.maxBufferSize });
-    if (server2.stderr === "pipe" || server2.stderr === "overlapped") this._stderrStream = new PassThrough();
+  constructor(server3) {
+    this._serverParams = server3;
+    this._readBuffer = new ReadBuffer({ maxBufferSize: server3.maxBufferSize });
+    if (server3.stderr === "pipe" || server3.stderr === "overlapped") this._stderrStream = new PassThrough();
   }
   /**
   * Starts the server process and prepares to communicate with it.
@@ -44739,14 +44741,14 @@ function messageBytes(message) {
     return void 0;
   }
 }
-function createMcpTraceEvent(direction, server2, transport, message, status, options) {
+function createMcpTraceEvent(direction, server3, transport, message, status, options) {
   const kind = messageKind(message);
   const bytes = messageBytes(message);
   const event = {
     version: MCP_TRACE_SCHEMA_VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     direction,
-    server: redactTraceText(server2, 120),
+    server: redactTraceText(server3, 120),
     transport,
     kind,
     status,
@@ -44848,7 +44850,7 @@ function createMcpTraceWriter(sessionCwd, settings2 = {}, randomSuffix = Math.ra
 function isMcpTraceEnabled(definition, settings2) {
   return definition.trace ?? settings2?.enabled === true;
 }
-function wrapTransportWithMcpTrace(transport, server2, transportKind, observer) {
+function wrapTransportWithMcpTrace(transport, server3, transportKind, observer) {
   let messageHandler = transport.onmessage;
   let tracedMessageHandler;
   const originalSend = transport.send;
@@ -44868,7 +44870,7 @@ function wrapTransportWithMcpTrace(transport, server2, transportKind, observer)
       set(handler) {
         messageHandler = handler;
         tracedMessageHandler = handler ? ((message, extra) => {
-          record3(createMcpTraceEvent("inbound", server2, transportKind, message, "received"));
+          record3(createMcpTraceEvent("inbound", server3, transportKind, message, "received"));
           handler(message, extra);
         }) : void 0;
       }
@@ -44882,13 +44884,13 @@ function wrapTransportWithMcpTrace(transport, server2, transportKind, observer)
     try {
       await originalSend.call(transport, message, options);
       for (const item of messages) {
-        record3(createMcpTraceEvent("outbound", server2, transportKind, item, "sent", {
+        record3(createMcpTraceEvent("outbound", server3, transportKind, item, "sent", {
           durationMs: performance.now() - started
         }));
       }
     } catch (error) {
       for (const item of messages) {
-        record3(createMcpTraceEvent("outbound", server2, transportKind, item, "error", {
+        record3(createMcpTraceEvent("outbound", server3, transportKind, item, "error", {
           durationMs: performance.now() - started
         }));
       }
@@ -49953,7 +49955,7 @@ async function startUiServer(options) {
   const eventLog = [];
   let latestCheckpointEventId;
   let streamSummary;
-  let server2 = null;
+  let server3 = null;
   let sandboxProxyServer = null;
   let sandboxProxyUrl = null;
   let closeTimer = null;
@@ -50114,7 +50116,7 @@ data: ${JSON.stringify(payload)}
       closeTimer = null;
     }
     try {
-      server2?.close();
+      server3?.close();
     } catch {
     }
     try {
@@ -50468,7 +50470,7 @@ data: ${JSON.stringify(payload)}
       sendJson(res, status, { ok: false, error: wrapped.message });
     }
   });
-  server2 = hostServer;
+  server3 = hostServer;
   if (options.initialResultPromise) {
     options.initialResultPromise.then(
       (result) => pushEvent("tool-result", result),
@@ -55322,11 +55324,11 @@ function normalizeSearchText(value) {
 function tokenize(value) {
   return normalizeSearchText(value).split(/[^a-z0-9]+/).filter(Boolean);
 }
-function prepareToolSearch(tool, server2, keywords) {
+function prepareToolSearch(tool, server3, keywords) {
   const fields = {
     name: normalizeSearchText(tool.name),
     originalName: normalizeSearchText(tool.originalName),
-    server: normalizeSearchText(server2),
+    server: normalizeSearchText(server3),
     description: normalizeSearchText(tool.description)
   };
   const preparedFields = Object.entries(fields).map(([field, value]) => [field, value, tokenize(value)]);
@@ -55432,14 +55434,14 @@ function getPreparedTools(state, serverName, metadata, definition, globalPrefix,
   }
   return prepared;
 }
-function rankToolMatches(state, query2, server2, includeKeywords = true) {
+function rankToolMatches(state, query2, server3, includeKeywords = true) {
   const matches = [];
   const normalizedQuery = normalizeSearchText(query2).trim();
   const queryTokens = tokenize(query2);
   if (queryTokens.length === 0) return matches;
   const globalPrefix = state.config.settings?.toolPrefix ?? "server";
   for (const [serverName, metadata] of state.toolMetadata.entries()) {
-    if (server2 && serverName !== server2) continue;
+    if (server3 && serverName !== server3) continue;
     const definition = state.config.mcpServers[serverName];
     if (isServerDisabled(definition)) continue;
     if (isServerInActiveFailureBackoff(state, serverName)) continue;
@@ -55464,7 +55466,7 @@ function paginate(items, offset, limit) {
   };
 }
 function rankSuggestions(state, name, limit) {
-  const stripped = Object.keys(state.config.mcpServers).flatMap((server2) => ["server", "short", "mcp"].map((prefix) => getServerPrefix(server2, prefix))).filter((candidate) => Boolean(candidate) && name.startsWith(`${candidate}_`)).sort((a, b) => b.length - a.length).map((candidate) => name.slice(candidate.length + 1));
+  const stripped = Object.keys(state.config.mcpServers).flatMap((server3) => ["server", "short", "mcp"].map((prefix) => getServerPrefix(server3, prefix))).filter((candidate) => Boolean(candidate) && name.startsWith(`${candidate}_`)).sort((a, b) => b.length - a.length).map((candidate) => name.slice(candidate.length + 1));
   const query2 = stripped[0] ?? name;
   return rankToolMatches(state, query2, void 0, false).slice(0, limit).map((match) => match.tool.name);
 }
@@ -55498,9 +55500,9 @@ function getToolMatches(metadata, toolName, exact) {
 }
 function getEnabledToolMatches(state, toolName, exact) {
   const matches = [];
-  for (const [server2, metadata] of state.toolMetadata) {
-    if (isServerDisabled(state.config.mcpServers[server2])) continue;
-    for (const tool of getToolMatches(metadata, toolName, exact)) matches.push({ server: server2, tool });
+  for (const [server3, metadata] of state.toolMetadata) {
+    if (isServerDisabled(state.config.mcpServers[server3])) continue;
+    for (const tool of getToolMatches(metadata, toolName, exact)) matches.push({ server: server3, tool });
   }
   return matches;
 }
@@ -55754,34 +55756,34 @@ function executeStatus(state) {
   let text = `MCP: ${connectedCount}/${enabledServers.length} servers, ${totalTools} tools`;
   if (disabledCount > 0) text += ` (${disabledCount} disabled)`;
   text += "\n\n";
-  for (const server2 of servers) {
-    if (server2.disabled) {
-      text += `\u2298 ${server2.name} (disabled)
+  for (const server3 of servers) {
+    if (server3.disabled) {
+      text += `\u2298 ${server3.name} (disabled)
 `;
       continue;
     }
-    if (server2.status === "connected") {
-      const listen2 = server2.listenState === "active" ? server2.catalogStale ? ", listen active, catalog may be stale" : ", listen active" : server2.listenState === "dropped" ? ", catalog may be stale; will reconcile on next keep-alive or tool use" : server2.listenState === "re-establishing" ? ", re-establishing listen" : server2.listenState === "legacy" ? ", legacy notification path" : ", not listening for catalog updates";
-      text += `\u2713 ${server2.name} (${server2.toolCount} tools${listen2})
+    if (server3.status === "connected") {
+      const listen2 = server3.listenState === "active" ? server3.catalogStale ? ", listen active, catalog may be stale" : ", listen active" : server3.listenState === "dropped" ? ", catalog may be stale; will reconcile on next keep-alive or tool use" : server3.listenState === "re-establishing" ? ", re-establishing listen" : server3.listenState === "legacy" ? ", legacy notification path" : ", not listening for catalog updates";
+      text += `\u2713 ${server3.name} (${server3.toolCount} tools${listen2})
 `;
       continue;
     }
-    if (server2.status === "needs-auth") {
-      text += `\u26A0 ${server2.name} (needs auth)
+    if (server3.status === "needs-auth") {
+      text += `\u26A0 ${server3.name} (needs auth)
 `;
       continue;
     }
-    if (server2.status === "cached") {
-      text += `\u25CB ${server2.name} (${server2.toolCount} tools, cached; not listening)
+    if (server3.status === "cached") {
+      text += `\u25CB ${server3.name} (${server3.toolCount} tools, cached; not listening)
 `;
       continue;
     }
-    if (server2.status === "failed") {
-      text += `\u2717 ${server2.name} (failed ${server2.failedAgo ?? 0}s ago)
+    if (server3.status === "failed") {
+      text += `\u2717 ${server3.name} (failed ${server3.failedAgo ?? 0}s ago)
 `;
       continue;
     }
-    text += `\u25CB ${server2.name} (not listening; disconnected)
+    text += `\u25CB ${server3.name} (not listening; disconnected)
 `;
   }
   const directToolsFrozen = state.config.settings?.freezeDirectTools === true;
@@ -55880,18 +55882,18 @@ function executeDescribe(state, toolName) {
   let disabledMatch;
   let failedMatch;
   if (!toolMeta) {
-    for (const [server2, metadata] of state.toolMetadata.entries()) {
+    for (const [server3, metadata] of state.toolMetadata.entries()) {
       const found = findToolByName(metadata, toolName);
       if (!found) continue;
-      if (isServerDisabled(state.config.mcpServers[server2])) {
-        disabledMatch ??= server2;
+      if (isServerDisabled(state.config.mcpServers[server3])) {
+        disabledMatch ??= server3;
         continue;
       }
-      if (isServerInActiveFailureBackoff(state, server2)) {
-        failedMatch ??= server2;
+      if (isServerInActiveFailureBackoff(state, server3)) {
+        failedMatch ??= server3;
         continue;
       }
-      serverName = server2;
+      serverName = server3;
       toolMeta = found;
       break;
     }
@@ -55937,10 +55939,10 @@ No parameters defined.`;
     details: { mode: "describe", tool: toolMeta, server: serverName }
   };
 }
-function executeSearch(state, query2, regex, server2, includeSchemas, limit = 12, offset = 0) {
+function executeSearch(state, query2, regex, server3, includeSchemas, limit = 12, offset = 0) {
   const showSchemas = includeSchemas !== false;
-  if (server2 && isServerDisabled(state.config.mcpServers[server2])) return disabledResult("search", server2);
-  if (server2 && isServerInActiveFailureBackoff(state, server2)) return serverBackoffResult(state, "search", server2);
+  if (server3 && isServerDisabled(state.config.mcpServers[server3])) return disabledResult("search", server3);
+  if (server3 && isServerInActiveFailureBackoff(state, server3)) return serverBackoffResult(state, "search", server3);
   let matches;
   if (regex) {
     let pattern;
@@ -55981,27 +55983,27 @@ function executeSearch(state, query2, regex, server2, includeSchemas, limit = 12
       const definition = state.config.mcpServers[serverName];
       if (isServerDisabled(definition)) continue;
       if (isServerInActiveFailureBackoff(state, serverName)) continue;
-      if (server2 && serverName !== server2) continue;
+      if (server3 && serverName !== server3) continue;
       for (const tool of metadata) {
         const matched = pattern.test(tool.name) || pattern.test(tool.description) || resolveSearchKeywords(definition, tool.originalName, serverName, globalPrefix).some((keyword) => pattern.test(keyword));
         if (matched) matches.push({ server: serverName, tool, score: 0 });
       }
     }
   } else if (query2.trim().length === 0) {
-    if (!server2) {
+    if (!server3) {
       return {
         content: [{ type: "text", text: "Search query cannot be empty" }],
         details: { mode: "search", error: "empty_query" }
       };
     }
-    matches = (state.toolMetadata.get(server2) ?? []).map((tool) => ({ server: server2, tool, score: 0 })).sort((a, b) => a.tool.name.localeCompare(b.tool.name));
+    matches = (state.toolMetadata.get(server3) ?? []).map((tool) => ({ server: server3, tool, score: 0 })).sort((a, b) => a.tool.name.localeCompare(b.tool.name));
   } else {
-    matches = rankToolMatches(state, query2, server2);
+    matches = rankToolMatches(state, query2, server3);
   }
   const page2 = paginate(matches, offset, limit);
   if (page2.total === 0) {
-    const connectingServers = server2 ? state.config.mcpServers[server2] && state.manager.isConnecting(server2) ? [server2] : [] : Object.keys(state.config.mcpServers).filter((name) => !isServerDisabled(state.config.mcpServers[name]) && state.manager.isConnecting(name)).sort((a, b) => a.localeCompare(b));
-    const msg = server2 ? `No tools matching "${query2}" in "${server2}"` : `No tools matching "${query2}"`;
+    const connectingServers = server3 ? state.config.mcpServers[server3] && state.manager.isConnecting(server3) ? [server3] : [] : Object.keys(state.config.mcpServers).filter((name) => !isServerDisabled(state.config.mcpServers[name]) && state.manager.isConnecting(name)).sort((a, b) => a.localeCompare(b));
+    const msg = server3 ? `No tools matching "${query2}" in "${server3}"` : `No tools matching "${query2}"`;
     const connectingMessage = connectingServers.length === 1 ? ` Server "${connectingServers[0]}" is still connecting; retry in a moment.` : connectingServers.length > 1 ? ` Servers ${connectingServers.map((name) => `"${name}"`).join(", ")} are still connecting; retry in a moment.` : "";
     return {
       content: [{ type: "text", text: `${msg}${connectingMessage}` }],
@@ -56060,25 +56062,25 @@ ${page2.items.length} of ${page2.total} \u2014 offset: ${page2.nextOffset} for m
     }
   };
 }
-function executeList(state, server2) {
-  const definition = state.config.mcpServers[server2];
+function executeList(state, server3) {
+  const definition = state.config.mcpServers[server3];
   if (!definition) {
     return {
-      content: [{ type: "text", text: `Server "${server2}" not found. Use mcp({}) to see available servers.` }],
-      details: { mode: "list", server: server2, tools: [], count: 0, error: "not_found" }
+      content: [{ type: "text", text: `Server "${server3}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "list", server: server3, tools: [], count: 0, error: "not_found" }
     };
   }
-  if (isServerDisabled(definition)) return disabledResult("list", server2);
-  const metadata = state.toolMetadata.get(server2);
+  if (isServerDisabled(definition)) return disabledResult("list", server3);
+  const metadata = state.toolMetadata.get(server3);
   const toolNames = metadata?.map((m) => m.name) ?? [];
-  const connection = state.manager.getConnection(server2);
-  if (isServerInActiveFailureBackoff(state, server2)) {
+  const connection = state.manager.getConnection(server3);
+  if (isServerInActiveFailureBackoff(state, server3)) {
     return {
-      ...serverBackoffResult(state, "list", server2),
-      details: { mode: "list", server: server2, tools: [], count: 0, error: "server_backoff" }
+      ...serverBackoffResult(state, "list", server3),
+      details: { mode: "list", server: server3, tools: [], count: 0, error: "server_backoff" }
     };
   }
-  const instructions = state.serverInstructions.get(server2);
+  const instructions = state.serverInstructions.get(server3);
   let instructionsText = "";
   if (instructions) {
     const preview = truncateAtWord(instructions, INSTRUCTIONS_PREVIEW_LENGTH);
@@ -56088,36 +56090,36 @@ Server instructions:
 ${preview}`;
     if (preview !== instructions) {
       instructionsText += `
-Use mcp({ instructions: "${server2}" }) for the full text.`;
+Use mcp({ instructions: "${server3}" }) for the full text.`;
     }
   }
   if (toolNames.length === 0) {
     if (connection?.status === "connected") {
       return {
-        content: [{ type: "text", text: `Server "${server2}" has no tools.${instructionsText}` }],
-        details: { mode: "list", server: server2, tools: [], count: 0, hasInstructions: Boolean(instructions) }
+        content: [{ type: "text", text: `Server "${server3}" has no tools.${instructionsText}` }],
+        details: { mode: "list", server: server3, tools: [], count: 0, hasInstructions: Boolean(instructions) }
       };
     }
     if (metadata !== void 0) {
       return {
-        content: [{ type: "text", text: `Server "${server2}" has no cached tools (not connected).${instructionsText}` }],
-        details: { mode: "list", server: server2, tools: [], count: 0, cached: true, hasInstructions: Boolean(instructions) }
+        content: [{ type: "text", text: `Server "${server3}" has no cached tools (not connected).${instructionsText}` }],
+        details: { mode: "list", server: server3, tools: [], count: 0, cached: true, hasInstructions: Boolean(instructions) }
       };
     }
     return {
-      content: [{ type: "text", text: `Server "${server2}" is configured but not connected. Use mcp({ connect: "${server2}" }) or /mcp reconnect ${server2} to retry.${instructionsText}` }],
-      details: { mode: "list", server: server2, tools: [], count: 0, error: "not_connected", hasInstructions: Boolean(instructions) }
+      content: [{ type: "text", text: `Server "${server3}" is configured but not connected. Use mcp({ connect: "${server3}" }) or /mcp reconnect ${server3} to retry.${instructionsText}` }],
+      details: { mode: "list", server: server3, tools: [], count: 0, error: "not_connected", hasInstructions: Boolean(instructions) }
     };
   }
   let cachedNote = "";
   if (connection?.status !== "connected") {
     if (connection?.status === "needs-auth") {
-      cachedNote = ` (needs auth \u2014 run mcp({ action: "auth-start", server: "${server2}" }))`;
+      cachedNote = ` (needs auth \u2014 run mcp({ action: "auth-start", server: "${server3}" }))`;
     } else {
-      cachedNote = ` (lazy: tools from cache, not connected yet \u2014 mcp({ connect: "${server2}" }) to connect)`;
+      cachedNote = ` (lazy: tools from cache, not connected yet \u2014 mcp({ connect: "${server3}" }) to connect)`;
     }
   }
-  let text = `${server2} (${toolNames.length} tools${cachedNote}):
+  let text = `${server3} (${toolNames.length} tools${cachedNote}):
 
 `;
   const descMap = /* @__PURE__ */ new Map();
@@ -56136,38 +56138,38 @@ Use mcp({ instructions: "${server2}" }) for the full text.`;
   text += instructionsText;
   return {
     content: [{ type: "text", text: text.trim() }],
-    details: { mode: "list", server: server2, tools: toolNames, count: toolNames.length, hasInstructions: Boolean(instructions) }
+    details: { mode: "list", server: server3, tools: toolNames, count: toolNames.length, hasInstructions: Boolean(instructions) }
   };
 }
-function executeInstructions(state, server2) {
-  const definition = state.config.mcpServers[server2];
+function executeInstructions(state, server3) {
+  const definition = state.config.mcpServers[server3];
   if (!definition) {
     return {
-      content: [{ type: "text", text: `Server "${server2}" not found. Use mcp({}) to see available servers.` }],
-      details: { mode: "instructions", server: server2, error: "not_found" }
+      content: [{ type: "text", text: `Server "${server3}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "instructions", server: server3, error: "not_found" }
     };
   }
-  if (isServerDisabled(definition)) return disabledResult("instructions", server2);
-  if (isServerInActiveFailureBackoff(state, server2)) return serverBackoffResult(state, "instructions", server2);
-  const instructions = state.serverInstructions.get(server2);
+  if (isServerDisabled(definition)) return disabledResult("instructions", server3);
+  if (isServerInActiveFailureBackoff(state, server3)) return serverBackoffResult(state, "instructions", server3);
+  const instructions = state.serverInstructions.get(server3);
   if (instructions) {
     return {
-      content: [{ type: "text", text: `${server2} instructions:
+      content: [{ type: "text", text: `${server3} instructions:
 
 ${instructions}` }],
-      details: { mode: "instructions", server: server2, length: instructions.length }
+      details: { mode: "instructions", server: server3, length: instructions.length }
     };
   }
-  const connection = state.manager.getConnection(server2);
+  const connection = state.manager.getConnection(server3);
   if (connection?.status === "connected") {
     return {
-      content: [{ type: "text", text: `Server "${server2}" does not provide instructions.` }],
-      details: { mode: "instructions", server: server2, error: "no_instructions" }
+      content: [{ type: "text", text: `Server "${server3}" does not provide instructions.` }],
+      details: { mode: "instructions", server: server3, error: "no_instructions" }
     };
   }
   return {
-    content: [{ type: "text", text: `No instructions cached for "${server2}". Use mcp({ connect: "${server2}" }) to connect and refresh.` }],
-    details: { mode: "instructions", server: server2, error: "not_connected" }
+    content: [{ type: "text", text: `No instructions cached for "${server3}". Use mcp({ connect: "${server3}" }) to connect and refresh.` }],
+    details: { mode: "instructions", server: server3, error: "not_connected" }
   };
 }
 async function executeConnect(state, serverName, signal) {
@@ -56278,26 +56280,26 @@ async function executeCall(state, toolName, args, serverOverride, getPiTools, si
       return ambiguousToolResult("call", toolName);
     }
     let disabledMatch;
-    for (const [server2, metadata] of state.toolMetadata.entries()) {
+    for (const [server3, metadata] of state.toolMetadata.entries()) {
       const found = metadata.find((tool) => tool.name === toolName);
       if (!found) continue;
-      if (isServerDisabled(state.config.mcpServers[server2])) {
-        disabledMatch ??= { serverName: server2, toolMeta: found };
+      if (isServerDisabled(state.config.mcpServers[server3])) {
+        disabledMatch ??= { serverName: server3, toolMeta: found };
         continue;
       }
-      serverName = server2;
+      serverName = server3;
       toolMeta = found;
       break;
     }
     if (!toolMeta && !disabledMatch) {
-      for (const [server2, metadata] of state.toolMetadata.entries()) {
+      for (const [server3, metadata] of state.toolMetadata.entries()) {
         const found = findToolByName(metadata, toolName);
         if (!found) continue;
-        if (isServerDisabled(state.config.mcpServers[server2])) {
-          disabledMatch ??= { serverName: server2, toolMeta: found };
+        if (isServerDisabled(state.config.mcpServers[server3])) {
+          disabledMatch ??= { serverName: server3, toolMeta: found };
           continue;
         }
-        serverName = server2;
+        serverName = server3;
         toolMeta = found;
         break;
       }
@@ -57026,11 +57028,11 @@ function collectCollapsedResultLines(content, maxLines, maxChars) {
 }
 function formatMcpToolResultIdentity(details) {
   if (details?.mode !== "call") return null;
-  const server2 = typeof details.server === "string" ? details.server : typeof details.hintServer === "string" ? details.hintServer : null;
-  if (!server2) return null;
-  if (typeof details.tool === "string") return `MCP ${server2}/${details.tool}`;
-  if (typeof details.resourceUri === "string") return `MCP ${server2} resource ${details.resourceUri}`;
-  if (typeof details.requestedTool === "string") return `MCP ${server2}/${details.requestedTool}`;
+  const server3 = typeof details.server === "string" ? details.server : typeof details.hintServer === "string" ? details.hintServer : null;
+  if (!server3) return null;
+  if (typeof details.tool === "string") return `MCP ${server3}/${details.tool}`;
+  if (typeof details.resourceUri === "string") return `MCP ${server3} resource ${details.resourceUri}`;
+  if (typeof details.requestedTool === "string") return `MCP ${server3}/${details.requestedTool}`;
   return null;
 }
 function formatMcpToolResultLines(result, expanded, maxCollapsedLines = DEFAULT_BOXED_COLLAPSED_LINES, maxCollapsedChars = DEFAULT_MAX_COLLAPSED_CHARS) {
@@ -57201,10 +57203,10 @@ async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_TIMEOUT_
       if (query2.trim() === "") {
         return { items: [], total: 0, hasMore: false, nextOffset: null };
       }
-      const server2 = typeof input?.server === "string" ? input.server : void 0;
+      const server3 = typeof input?.server === "string" ? input.server : void 0;
       const limit = typeof input?.limit === "number" ? input.limit : 12;
       const offset = typeof input?.offset === "number" ? input.offset : 0;
-      const page2 = paginate(rankToolMatches(state, query2, server2), offset, limit);
+      const page2 = paginate(rankToolMatches(state, query2, server3), offset, limit);
       return {
         ...page2,
         items: page2.items.map(({ server: matchServer, tool, score }) => ({
@@ -57227,15 +57229,15 @@ async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_TIMEOUT_
     const path7 = typeof input?.path === "string" ? input.path : "";
     let error;
     try {
-      for (const [server2, metadata] of state.toolMetadata) {
-        if (isServerInActiveFailureBackoff(state, server2)) continue;
+      for (const [server3, metadata] of state.toolMetadata) {
+        if (isServerInActiveFailureBackoff(state, server3)) continue;
         const tool = findToolByName(metadata, path7);
         if (!tool) continue;
         const inputTypeScript = tool.inputSchema ? renderTsShape(tool.inputSchema) ?? formatSchema(tool.inputSchema) : null;
         return {
           path: tool.name,
           name: tool.originalName,
-          server: server2,
+          server: server3,
           ...tool.description ? { description: tool.description } : {},
           ...inputTypeScript ? { inputTypeScript } : {}
         };
@@ -59072,8 +59074,8 @@ function mcpNameFromToolCall(message) {
   const parsedName = parseMcpToolName(message.tool);
   if (parsedName) return parsedName.server;
   if (message.tool.startsWith("mcp.")) {
-    const [server2, ...toolParts] = message.tool.slice("mcp.".length).split(".");
-    if (server2 && toolParts.length > 0) return server2;
+    const [server3, ...toolParts] = message.tool.slice("mcp.".length).split(".");
+    if (server3 && toolParts.length > 0) return server3;
   }
   return NON_MCP_SERVERS.has(message.server) ? null : message.server;
 }
@@ -59289,9 +59291,9 @@ function calculateCumulativeTokenUsageDelta(current, previous) {
     cacheWriteInputTokens: current.cacheWriteInputTokens - previous.cacheWriteInputTokens
   };
 }
-function recordParsedTokenUsage(event, harness, parse) {
+function recordParsedTokenUsage(event, harness, parse2) {
   if (event.type !== "usage-updated") return void 0;
-  const usage = parse(event.payload);
+  const usage = parse2(event.payload);
   if (!usage) return void 0;
   return {
     records: [{
@@ -62424,7 +62426,7 @@ var RepoFileService = class {
 
 // src/v1-routes.ts
 import { Hono } from "hono";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import { readdir as readdir11, stat as stat7, readFile as readFile23 } from "fs/promises";
 import { join as join39, resolve as resolve5 } from "path";
 
@@ -62816,9 +62818,18 @@ ${combinedScript}` : combinedScript;
 import { randomUUID as randomUUID12 } from "crypto";
 import { existsSync as existsSync20 } from "fs";
 import { spawn as spawn8 } from "node-pty";
+import { z as z4 } from "zod";
 var MAX_REPLAY_CHARS = 1024 * 1024;
 var MAX_TERMINAL_SESSIONS = 8;
 var MAX_PENDING_INPUT = 64;
+var terminalSizeSchema = z4.object({
+  cols: z4.number().int().min(2).max(500),
+  rows: z4.number().int().min(1).max(200)
+});
+var terminalCommandSchema = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("input"), data: z4.string() }),
+  terminalSizeSchema.extend({ type: z4.literal("resize") })
+]);
 var TerminalService = class {
   sessions = /* @__PURE__ */ new Map();
   nextTitleNumber = 1;
@@ -62894,6 +62905,12 @@ var TerminalService = class {
     }
     return true;
   }
+  command(id, command) {
+    const session = this.sessions.get(id);
+    if (!session || session.exited) return;
+    if (command.type === "input") session.pty.write(command.data);
+    else session.pty.resize(command.cols, command.rows);
+  }
   resize(id, cols, rows) {
     const session = this.sessions.get(id);
     if (!session || session.exited) return false;
@@ -62932,32 +62949,28 @@ var TerminalService = class {
 var terminalService = new TerminalService();
 
 // src/v1-routes.ts
-var createPreviewSchema = z4.object({
-  port: z4.number().int().min(1).max(65535),
-  publicUrl: z4.string().min(1)
-});
-var terminalSizeSchema = z4.object({
-  cols: z4.number().int().min(2).max(500),
-  rows: z4.number().int().min(1).max(200)
+var createPreviewSchema = z5.object({
+  port: z5.number().int().min(1).max(65535),
+  publicUrl: z5.string().min(1)
 });
-var writeTerminalSessionSchema = z4.object({
-  data: z4.string().max(64 * 1024),
-  generation: z4.number().int().nonnegative(),
-  sequence: z4.number().int().nonnegative()
+var writeTerminalSessionSchema = z5.object({
+  data: z5.string().max(64 * 1024),
+  generation: z5.number().int().nonnegative(),
+  sequence: z5.number().int().nonnegative()
 });
-var respondToolInputSchema = z4.object({
-  requestId: z4.string().min(1),
-  selectionId: z4.string().min(1)
+var respondToolInputSchema = z5.object({
+  requestId: z5.string().min(1),
+  selectionId: z5.string().min(1)
 });
-var updateGoalSchema = z4.object({
-  objective: z4.string().trim().min(1).max(MAX_CODEX_GOAL_OBJECTIVE_CHARS).optional(),
-  status: z4.enum(["active", "paused"]).optional()
+var updateGoalSchema = z5.object({
+  objective: z5.string().trim().min(1).max(MAX_CODEX_GOAL_OBJECTIVE_CHARS).optional(),
+  status: z5.enum(["active", "paused"]).optional()
 }).refine((body) => body.objective !== void 0 || body.status !== void 0, {
   message: "Goal objective or status required"
 });
-var updateTextFileSchema = (maxLength) => z4.object({
-  content: z4.string().max(maxLength),
-  expectedRevision: z4.string().regex(/^[a-f0-9]{64}$/)
+var updateTextFileSchema = (maxLength) => z5.object({
+  content: z5.string().max(maxLength),
+  expectedRevision: z5.string().regex(/^[a-f0-9]{64}$/)
 });
 function jsonError(message, details) {
   return { error: message, details };
@@ -63007,11 +63020,11 @@ function createV1Routes(deps) {
   const app2 = new Hono();
   app2.post("/pull-requests/check", async (c) => {
     if (c.req.header("content-type")?.includes("application/json")) {
-      const result = z4.object({
-        toolName: z4.string(),
-        toolInput: z4.unknown(),
-        output: z4.unknown(),
-        success: z4.boolean()
+      const result = z5.object({
+        toolName: z5.string(),
+        toolInput: z5.unknown(),
+        output: z5.unknown(),
+        success: z5.boolean()
       }).safeParse(await c.req.json().catch(() => null));
       if (!result.success) return c.json({ error: "Invalid PR tool result" }, 400);
       await pullRequestCheckService.onToolResult(result.data);
@@ -63240,7 +63253,7 @@ function createV1Routes(deps) {
       const chat = await deps.chatService.updateDisplayName(c.req.param("chatId"), body.displayName);
       return c.json({ chat });
     } catch (error) {
-      if (error instanceof z4.ZodError) {
+      if (error instanceof z5.ZodError) {
         return c.json(jsonError(error.issues[0]?.message || "Invalid tab name"), 400);
       }
       if (error instanceof ChatNotFoundError) {
@@ -63345,7 +63358,7 @@ function createV1Routes(deps) {
       const result = await deps.chatService.updateGoal(c.req.param("chatId"), body);
       return c.json(result);
     } catch (error) {
-      if (error instanceof z4.ZodError) {
+      if (error instanceof z5.ZodError) {
         return c.json(jsonError(error.issues[0]?.message || "Invalid goal update"), 400);
       }
       if (error instanceof ChatNotFoundError) {
@@ -63967,6 +63980,104 @@ data: ${JSON.stringify("Terminal session not found")}
   return app2;
 }
 
+// src/services/terminal-socket.ts
+import { z as z6 } from "zod";
+var ndcModule;
+var loadNdc = () => ndcModule ??= import("node-datachannel").then((module) => module.default, () => null);
+var CHANNEL_CHUNK_CHARS = 16384;
+var MAX_QUEUED_CANDIDATES = 32;
+var MAX_BUFFERED_BYTES = 8 * 1024 * 1024;
+var socketMessageSchema = z6.union([
+  terminalCommandSchema,
+  z6.object({ type: z6.literal("rtc-offer"), sdp: z6.string().max(64 * 1024) }),
+  z6.object({ type: z6.literal("rtc-candidate"), candidate: z6.string().max(1024), mid: z6.string().max(64) }),
+  z6.object({ type: z6.literal("rtc-switch") })
+]);
+function parse(schema, raw) {
+  try {
+    const result = schema.safeParse(JSON.parse(raw));
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+function attachTerminalSocket(id, socket) {
+  const send = (message) => socket.send(JSON.stringify(message));
+  let peer = null;
+  let channel = null;
+  const candidates = [];
+  let early = [];
+  const subscription = terminalService.subscribe(id, (data) => {
+    if (socket.bufferedAmount > MAX_BUFFERED_BYTES || (channel?.bufferedAmount() ?? 0) > MAX_BUFFERED_BYTES) {
+      socket.terminate();
+      return;
+    }
+    if (!channel?.isOpen()) {
+      send({ type: "output", data });
+      return;
+    }
+    for (let start = 0; start < data.length; ) {
+      let end = Math.min(start + CHANNEL_CHUNK_CHARS, data.length);
+      if (end < data.length && /[\uD800-\uDBFF]/.test(data[end - 1])) end--;
+      channel.sendMessage(data.slice(start, end));
+      start = end;
+    }
+  });
+  if (!subscription) {
+    socket.close(4410, "Terminal session not found");
+    return;
+  }
+  if (subscription.replay) send({ type: "output", data: subscription.replay });
+  const negotiate = async (offer) => {
+    const ndc = await loadNdc();
+    if (!ndc || peer || socket.readyState !== socket.OPEN) return;
+    const connection = new ndc.PeerConnection(`terminal-${id}`, { iceServers: [TERMINAL_RTC_ICE_SERVER] });
+    peer = connection;
+    connection.onLocalDescription((sdp) => send({ type: "rtc-answer", sdp }));
+    connection.onLocalCandidate((candidate, mid) => send({ type: "rtc-candidate", candidate, mid }));
+    connection.onDataChannel((dc) => {
+      dc.onMessage((raw) => {
+        const command = typeof raw === "string" ? parse(terminalCommandSchema, raw) : null;
+        if (!command) return;
+        if (early) early.push(command);
+        else terminalService.command(id, command);
+      });
+      dc.onClosed(() => {
+        if (channel === dc) channel = null;
+      });
+      const activate2 = () => {
+        channel = dc;
+        send({ type: "rtc-switch" });
+      };
+      if (dc.isOpen()) activate2();
+      else dc.onOpen(activate2);
+    });
+    connection.setRemoteDescription(offer, "offer");
+    for (const { candidate, mid } of candidates.splice(0)) connection.addRemoteCandidate(candidate, mid);
+  };
+  socket.on("message", (raw) => {
+    const message = parse(socketMessageSchema, raw.toString());
+    if (!message) return;
+    if (message.type === "rtc-offer") {
+      negotiate(message.sdp).catch(() => {
+        peer?.close();
+        peer = null;
+      });
+    } else if (message.type === "rtc-candidate") {
+      if (peer) peer.addRemoteCandidate(message.candidate, message.mid);
+      else if (candidates.length < MAX_QUEUED_CANDIDATES) candidates.push(message);
+    } else if (message.type === "rtc-switch") {
+      for (const command of early ?? []) terminalService.command(id, command);
+      early = null;
+    } else terminalService.command(id, message);
+  });
+  socket.on("close", () => {
+    subscription.unsubscribe();
+    channel = null;
+    peer?.close();
+  });
+}
+
 // src/services/heartbeat-service.ts
 function unrefTimer(timer) {
   if (typeof timer === "object" && timer !== null && "unref" in timer && typeof timer.unref === "function") {
@@ -64053,7 +64164,7 @@ function startGitPushTracker() {
 async function listen() {
   await mkdir23(ENGINE_DIR2, { recursive: true });
   await rm5(SOCKET_PATH, { force: true });
-  const server2 = createServer2((socket) => {
+  const server3 = createServer2((socket) => {
     let buffered = "";
     let ignored = false;
     let push = false;
@@ -64095,10 +64206,10 @@ async function listen() {
     });
   });
   await new Promise((resolve7, reject) => {
-    server2.once("error", reject);
-    server2.listen(SOCKET_PATH, () => {
-      server2.off("error", reject);
-      server2.on("error", (error) => console.error("[GitPushTracker] Socket error:", error));
+    server3.once("error", reject);
+    server3.listen(SOCKET_PATH, () => {
+      server3.off("error", reject);
+      server3.on("error", (error) => console.error("[GitPushTracker] Socket error:", error));
       resolve7();
     });
   });
@@ -64483,7 +64594,9 @@ async function sleep2() {
   await engineLogger.flush();
   return createSuccessResult({ state: lifecycle.state, workspaceId: lifecycle.workspaceId });
 }
-serve(
+var terminalSockets = new WebSocketServer({ noServer: true });
+var TERMINAL_SOCKET_PATH = /^\/terminal\/sessions\/([^/]+)\/ws$/;
+var server2 = serve(
   {
     fetch: app.fetch,
     port
@@ -64502,6 +64615,17 @@ serve(
     }
   }
 );
+server2.on("upgrade", (req, socket, head) => {
+  const sessionId = TERMINAL_SOCKET_PATH.exec(new URL(req.url ?? "/", "http://engine").pathname)?.[1];
+  if (!sessionId || req.headers["x-replicas-engine-secret"] !== ENGINE_ENV.REPLICAS_ENGINE_SECRET || !lifecycle.active) {
+    socket.end(`HTTP/1.1 ${sessionId ? "401 Unauthorized" : "404 Not Found"}\r
+Connection: close\r
+\r
+`);
+    return;
+  }
+  terminalSockets.handleUpgrade(req, socket, head, (ws) => attachTerminalSocket(decodeURIComponent(sessionId), ws));
+});
 /*! Bundled license information:
 
 @modelcontextprotocol/client/dist/src-D_zzAWoS.mjs: