ds-harness-remote 0.4.16 → 0.4.17

package/dist/index.js

@@ -4695,7 +4695,7 @@ var LoopbackHost = class {
         const response = handle.response;
         let chunk = response.read(Math.min(response.readableLength || LOOPBACK_CHUNK_BYTES, LOOPBACK_CHUNK_BYTES));
         if (chunk === null && !response.readableEnded && !response.destroyed) {
-          await new Promise((resolve3, reject) => {
+          await new Promise((resolve4, reject) => {
             const timer = setTimeout(() => finish(new Error("timeout")), 2e4);
             const ready = () => finish();
             const fail4 = () => finish(new Error("closed"));
@@ -4705,7 +4705,7 @@ var LoopbackHost = class {
               response.off("end", ready);
               response.off("close", ready);
               response.off("error", fail4);
-              error === void 0 ? resolve3() : reject(error);
+              error === void 0 ? resolve4() : reject(error);
             };
             response.once("readable", ready);
             response.once("end", ready);
@@ -4735,22 +4735,22 @@ var LoopbackHost = class {
           this.close(value.id);
           throw new RpcError("RATE_LIMITED", "Preview WebSocket buffer exceeded its limit.");
         }
-        await new Promise((resolve3, reject) => handle.socket.send(data2, { binary: value.binary }, (error) => error ? reject(new RpcError("LOOPBACK_CLOSED", "Preview socket closed.")) : resolve3()));
+        await new Promise((resolve4, reject) => handle.socket.send(data2, { binary: value.binary }, (error) => error ? reject(new RpcError("LOOPBACK_CLOSED", "Preview socket closed.")) : resolve4()));
         return { sent: true };
       }
       if (value.op === "ws.read") {
         if (handle.reading) throw new RpcError("REQUEST_CONFLICT", "Only one preview read may be pending.");
         handle.reading = true;
         try {
-          if (handle.messages.length === 0 && !handle.closed) await new Promise((resolve3) => {
+          if (handle.messages.length === 0 && !handle.closed) await new Promise((resolve4) => {
             const timer = setTimeout(() => {
               handle.wake = void 0;
-              resolve3();
+              resolve4();
             }, 2e4);
             handle.wake = () => {
               clearTimeout(timer);
               handle.wake = void 0;
-              resolve3();
+              resolve4();
             };
           });
           let bytes = 0;
@@ -4792,7 +4792,7 @@ var LoopbackHost = class {
   openHttp(value) {
     const body = value.body === void 0 ? void 0 : Buffer.from(value.body, "base64");
     if ((body?.length ?? 0) > LOOPBACK_MAX_BODY_BYTES) throw new Error("body limit");
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const headers = Object.fromEntries(cleanHeaders(value.headers));
       const request = httpRequest({
         hostname: "127.0.0.1",
@@ -4811,7 +4811,7 @@ var LoopbackHost = class {
         handle.response = response;
         response.on("error", () => void 0);
         clearTimeout(timer);
-        resolve3({ status: response.statusCode ?? 502, headers: cleanHeaders(headerPairs(response.headers)) });
+        resolve4({ status: response.statusCode ?? 502, headers: cleanHeaders(headerPairs(response.headers)) });
       });
       const timer = setTimeout(() => {
         request.destroy();
@@ -4826,7 +4826,7 @@ var LoopbackHost = class {
     });
   }
   openWs(value) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const socket = new WebSocket2(`ws://127.0.0.1:${value.port}${value.path}`, value.protocols, {
         headers: Object.fromEntries(cleanHeaders(value.headers)),
         followRedirects: false,
@@ -4836,7 +4836,7 @@ var LoopbackHost = class {
       });
       const handle = { kind: "ws", socket, messages: [], bytes: 0, reading: false, closed: false, touched: Date.now() };
       this.handles.set(value.id, handle);
-      socket.once("open", () => resolve3({ protocol: socket.protocol }));
+      socket.once("open", () => resolve4({ protocol: socket.protocol }));
       socket.on("message", (data2, binary) => {
         const message = { data: Buffer.from(data2).toString("base64"), binary };
         if (handle.bytes + message.data.length > 1024 * 1024 || handle.messages.length >= 256) {
@@ -4894,7 +4894,7 @@ var LoopbackPreview = class {
       for (const client of running.ws.clients) client.terminate();
       running.ws.close();
       running.server.closeAllConnections();
-      await new Promise((resolve3) => running.server.close(() => resolve3()));
+      await new Promise((resolve4) => running.server.close(() => resolve4()));
     }
     this.servers.clear();
   }
@@ -4949,11 +4949,11 @@ var LoopbackPreview = class {
         void this.release(id4);
       });
     });
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       server.once("error", reject);
       server.listen(0, "127.0.0.1", () => {
         server.off("error", reject);
-        resolve3();
+        resolve4();
       });
     });
     const address = server.address();
@@ -5019,10 +5019,10 @@ var LoopbackPreview = class {
       while (!signal.aborted) {
         const chunk = await this.client.rpc("loopback.call", { op: "http.read", id: id4 }, signal);
         if (chunk.data !== "" && !res.write(Buffer.from(chunk.data, "base64"))) {
-          await new Promise((resolve3, reject) => {
+          await new Promise((resolve4, reject) => {
             const ready = () => {
               cleanup();
-              resolve3();
+              resolve4();
             };
             const closed = () => {
               cleanup();
@@ -5082,7 +5082,7 @@ var LoopbackPreview = class {
           const result = await this.client.rpc("loopback.call", { op: "ws.read", id: id4 }, signal);
           for (const message of result.messages) {
             if (socket.bufferedAmount > 1024 * 1024) throw new Error("slow preview");
-            await new Promise((resolve3, reject) => socket.send(Buffer.from(message.data, "base64"), { binary: message.binary }, (error) => error ? reject(error) : resolve3()));
+            await new Promise((resolve4, reject) => socket.send(Buffer.from(message.data, "base64"), { binary: message.binary }, (error) => error ? reject(error) : resolve4()));
           }
           if (result.closed) break;
         }
@@ -5719,17 +5719,18 @@ var RemoteClientCore = class {
       throw error;
     }
   }
-  async rpc(method, params, signal) {
+  async rpc(method, params, signal, options) {
     if (signal?.aborted)
       throw rpcAbortedError(method, signal.reason);
+    const timeoutMs = callTimeoutMs(this.timeoutMs, options);
     const request = createRpcRequest(method, params);
-    const result = new Promise((resolve3, reject) => {
+    const result = new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
-        this.rejectPending(request.id, new RemoteClientError("RPC_TIMEOUT", `RPC ${method} timed out after ${this.timeoutMs}ms`));
-      }, this.timeoutMs);
+        this.rejectPending(request.id, new RemoteClientError("RPC_TIMEOUT", `RPC ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
       const pending = {
         method,
-        resolve: resolve3,
+        resolve: resolve4,
         reject,
         timer
       };
@@ -5836,6 +5837,12 @@ var RemoteClientCore = class {
 function rpcAbortedError(method, reason) {
   return new RemoteClientError("RPC_ABORTED", `RPC ${method} was aborted`, reason === void 0 ? void 0 : { cause: reason });
 }
+function callTimeoutMs(fallback, options) {
+  const timeoutMs = options?.timeoutMs;
+  if (typeof timeoutMs !== "number")
+    return fallback;
+  return Number.isSafeInteger(timeoutMs) && timeoutMs > 0 && timeoutMs <= 2147483647 ? timeoutMs : fallback;
+}
 function transportSendError(error) {
   return error instanceof Error ? error : new Error("remote transport send failed", { cause: error });
 }
@@ -5846,7 +5853,7 @@ async function waitForRelayCapacity(socket) {
   while ((socket.bufferedAmount ?? 0) > 512 * 1024) {
     if (socket.readyState !== 1 || Date.now() - started > 1e4)
       throw new Error("Relay consumer is too slow or disconnected");
-    await new Promise((resolve3) => setTimeout(resolve3, 10));
+    await new Promise((resolve4) => setTimeout(resolve4, 10));
   }
   if (socket.readyState !== 1)
     throw new Error("Relay transport closed");
@@ -6305,8 +6312,8 @@ var RtcDataChannelTransport = class {
     if (this.connectPromise !== void 0)
       return this.connectPromise;
     this.armAbort(signal);
-    this.connectPromise = new Promise((resolve3, reject) => {
-      this.openResolve = resolve3;
+    this.connectPromise = new Promise((resolve4, reject) => {
+      this.openResolve = resolve4;
       this.openReject = reject;
       this.negotiateTimer = setTimeout(() => {
         void this.failOpenAfterStats(new RtcConnectError("RTC_CONNECT_TIMEOUT", `WebRTC negotiation timed out after ${this.negotiateTimeoutMs}ms.`));
@@ -6521,9 +6528,9 @@ var RtcDataChannelTransport = class {
       if (this.closed || this.opened)
         return;
       this.opened = true;
-      const resolve3 = this.openResolve;
+      const resolve4 = this.openResolve;
       this.clearNegotiation();
-      void this.resolveSelectedTransport().then(() => resolve3?.());
+      void this.resolveSelectedTransport().then(() => resolve4?.());
     };
     channel.onmessage = (event) => {
       if (this.closed || !this.opened)
@@ -6917,7 +6924,7 @@ function asError(error) {
   return error instanceof Error ? error : new RtcConnectError("RTC_FAILED", "WebRTC negotiation failed.");
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // ../webrtc/dist/adaptive-transport.js
@@ -6955,8 +6962,8 @@ var AdaptiveTransport = class extends BaseTransport {
     this.socket = new WebSocket(this.url);
     this.controlFrameLimits = {};
     this.socket.binaryType = "arraybuffer";
-    await new Promise((resolve3, reject) => {
-      this.readyResolve = resolve3;
+    await new Promise((resolve4, reject) => {
+      this.readyResolve = resolve4;
       this.readyReject = reject;
       this.handshakeTimer = setTimeout(() => this.failConnection(new Error("Adaptive control handshake timed out")), this.options.handshakeTimeoutMs ?? 15e3);
       const socket = this.socket;
@@ -14558,7 +14565,7 @@ var ClientSecureTransport = class {
   }
 };
 async function waitForResponder(inner, noise) {
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     let settled = false;
     const timer = setTimeout(() => finish(new Error("Noise IK handshake timed out.")), 1e4);
     const unsubscribe = inner.onHandshake((step, data2) => {
@@ -14577,7 +14584,7 @@ async function waitForResponder(inner, noise) {
       settled = true;
       clearTimeout(timer);
       unsubscribe();
-      if (error === void 0) resolve3();
+      if (error === void 0) resolve4();
       else reject(error);
     };
     void inner.sendHandshake(1, noise.writeHandshake()).catch((error) => {
@@ -15022,7 +15029,7 @@ var AsyncFrameQueue = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve3) => this.waiters.push(resolve3));
+      const next = await new Promise((resolve4) => this.waiters.push(resolve4));
       if (next.done) return;
       yield next.value;
     }
@@ -15387,7 +15394,7 @@ var AsyncValueQueue = class {
         if (this.error !== void 0) throw this.error;
         return;
       }
-      const next = await new Promise((resolve3) => this.waiters.push(resolve3));
+      const next = await new Promise((resolve4) => this.waiters.push(resolve4));
       if (next.done) {
         if (this.error !== void 0) throw this.error;
         return;
@@ -15497,6 +15504,29 @@ var MAX_CODEX_IMAGE_BASE64 = 288 * 1024 * 1024;
 var CODEX_IMAGE_MEDIA_TYPES2 = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
 var CODEX_IMAGE_ATTACHMENT_PREFIX = "codex-image:";
 var DATA_IMAGE_URL2 = /^data:(image\/(?:png|jpeg|webp|gif));base64,([A-Za-z0-9+/]+={0,2})$/u;
+var HOST_WORKSPACE_ENDPOINTS = /* @__PURE__ */ new Set([
+  "workspaceFiles/list",
+  "workspaceFiles/stat",
+  "workspaceFiles/read",
+  "workspaceFiles/readBytes",
+  "workspaceFiles/readAll",
+  "workspaceFiles/readRelated",
+  "terminal/environment",
+  "terminal/shells",
+  "terminal/list",
+  "terminal/create",
+  "terminal/write",
+  "terminal/resize",
+  "terminal/rename",
+  "terminal/close"
+]);
+var HOST_WORKSPACE_STREAM_ENDPOINTS = /* @__PURE__ */ new Set(["workspaceFiles/changes", "terminal/follow", "terminal/retain"]);
+function isHostWorkspaceEndpoint(endpoint) {
+  return HOST_WORKSPACE_ENDPOINTS.has(endpoint);
+}
+function isHostWorkspaceStreamEndpoint(endpoint) {
+  return HOST_WORKSPACE_STREAM_ENDPOINTS.has(endpoint);
+}
 function codexProjectWorkspaceId(projectId) {
   return `${CODEX_WORKSPACE_PREFIX}project:${projectId}`;
 }
@@ -15504,10 +15534,11 @@ async function discoverCodexVirtualWorkspaces(client, signal) {
   return (await loadCatalog(client, signal)).workspaces;
 }
 var CodexVirtualHarness = class _CodexVirtualHarness {
-  constructor(client, host, sessionGeneration = "legacy") {
+  constructor(client, host, sessionGeneration = "legacy", hostCarrier) {
     this.client = client;
     this.host = host;
     this.sessionGeneration = sessionGeneration;
+    this.hostCarrier = hostCarrier;
     this.api = this.createApiProxy();
   }
   api;
@@ -15531,8 +15562,8 @@ var CodexVirtualHarness = class _CodexVirtualHarness {
   commandSeq = 0;
   selectedWorkspaceId;
   closed = false;
-  static remote(core, host, sessionGeneration = "legacy") {
-    return new _CodexVirtualHarness(new CodexRemoteClient(core), host, sessionGeneration);
+  static remote(core, host, sessionGeneration = "legacy", hostCarrier) {
+    return new _CodexVirtualHarness(new CodexRemoteClient(core), host, sessionGeneration, hostCarrier);
   }
   async workspaces(signal) {
     return (await this.refreshCatalog(signal)).workspaces;
@@ -15579,6 +15610,10 @@ var CodexVirtualHarness = class _CodexVirtualHarness {
   }
   async dispatch(endpoint, payload, signal) {
     try {
+      if (isHostWorkspaceEndpoint(endpoint)) {
+        if (this.hostCarrier === void 0) return fail("method-not-found", `CodeX virtual Harness does not implement ${endpoint}.`);
+        return await this.hostCarrier.dispatch(endpoint, payload, signal);
+      }
       const args = carrierArgs(payload);
       switch (endpoint) {
         case "$events/result":
@@ -15665,6 +15700,16 @@ var CodexVirtualHarness = class _CodexVirtualHarness {
     }
   }
   async open(endpoint, payload, signal) {
+    if (isHostWorkspaceStreamEndpoint(endpoint)) {
+      if (this.hostCarrier === void 0) {
+        throw Object.assign(new Error(`CodeX virtual Harness does not implement stream ${endpoint}.`), {
+          isDSHRemoteError: true,
+          code: "method-not-found",
+          details: {}
+        });
+      }
+      return this.hostCarrier.open(endpoint, payload, signal);
+    }
     const args = carrierArgs(payload);
     if (endpoint === "workspace/follow") return this.workspaceFollow(signal);
     if (endpoint === "session/control") return this.sessionControl(signal);
@@ -17983,7 +18028,7 @@ var AsyncValueQueue2 = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve3) => this.waiters.push(resolve3));
+      const next = await new Promise((resolve4) => this.waiters.push(resolve4));
       if (next.done) return;
       yield next.value;
     }
@@ -18027,7 +18072,7 @@ var ServerCredentialStore = class {
       } catch (error) {
         if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") throw error;
         if (Date.now() >= deadline) throw new ServerCredentialsBusyError();
-        await new Promise((resolve3) => setTimeout(resolve3, 50));
+        await new Promise((resolve4) => setTimeout(resolve4, 50));
       }
     }
     try {
@@ -18198,7 +18243,7 @@ function normalizeServerUrl(value) {
 }
 
 // src/version.ts
-var PLUGIN_VERSION = "0.4.16";
+var PLUGIN_VERSION = "0.4.17";
 
 // src/server-api.ts
 var TERMINAL_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/u;
@@ -18867,10 +18912,10 @@ function isUsableExternalNode(candidate, requireFrom) {
 }
 function isExecutableFile(candidate) {
   try {
-    const stat6 = statSync(candidate);
-    if (!stat6.isFile()) return false;
+    const stat7 = statSync(candidate);
+    if (!stat7.isFile()) return false;
     if (process.platform === "win32") return true;
-    return (stat6.mode & 73) !== 0;
+    return (stat7.mode & 73) !== 0;
   } catch {
     return false;
   }
@@ -18959,8 +19004,8 @@ var ExternalNativePeerConnection = class {
   request(method, payload) {
     if (this.closed) return Promise.reject(new Error("native rtc helper is closed"));
     const id4 = this.nextRequestId++;
-    const promise = new Promise((resolve3, reject) => {
-      this.pending.set(id4, { resolve: resolve3, reject });
+    const promise = new Promise((resolve4, reject) => {
+      this.pending.set(id4, { resolve: resolve4, reject });
     });
     this.write({ id: id4, method, payload });
     return promise;
@@ -19754,10 +19799,10 @@ function parseRouteTarget(value) {
 async function detectRouteHostIpv4(target2, timeoutMs) {
   const socket = createSocket("udp4");
   try {
-    return await new Promise((resolve3, reject) => {
+    return await new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         cleanup();
-        resolve3(void 0);
+        resolve4(void 0);
       }, timeoutMs);
       const cleanup = () => {
         clearTimeout(timer);
@@ -19771,7 +19816,7 @@ async function detectRouteHostIpv4(target2, timeoutMs) {
       socket.connect(target2.port, target2.host, () => {
         cleanup();
         const address = socket.address();
-        resolve3(typeof address === "string" ? void 0 : address.address);
+        resolve4(typeof address === "string" ? void 0 : address.address);
       });
     });
   } finally {
@@ -20097,7 +20142,7 @@ var ClientModeRuntime = class {
     const virtual = CodexVirtualHarness.remote(remote.client, {
       deviceId: remote.target.deviceId,
       name: remote.target.name
-    }, harnessSessionGeneration(this.host?.localHarnessVersion?.()));
+    }, harnessSessionGeneration(this.host?.localHarnessVersion?.()), new RemoteTypertGateway2(remote.client));
     let workspace;
     try {
       workspace = await virtual.selectWorkspace(workspaceId, signal);
@@ -20870,7 +20915,7 @@ async function probeRemoteHostFeatures(client, clientVersion) {
 }
 async function waitForCodexFrames(stream, signal) {
   if (signal?.aborted) throw new ClientModeError("RPC_ABORTED", "The Codex event poll was cancelled.");
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     const previousWake = stream.wake;
     const timer = setTimeout(done, 25e3);
     const onAbort = () => {
@@ -20884,7 +20929,7 @@ async function waitForCodexFrames(stream, signal) {
     }
     function done() {
       cleanup();
-      resolve3();
+      resolve4();
     }
     stream.wake = () => {
       previousWake();
@@ -21608,6 +21653,13 @@ function redact(value, key = "") {
   return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [childKey, redact(child, childKey)]));
 }
 
+// src/codex/session-id.ts
+function parseCodexSessionId(value) {
+  if (typeof value !== "string") return void 0;
+  const match = /^codex:([A-Za-z0-9][A-Za-z0-9._-]{0,255})$/.exec(value);
+  return match === null ? void 0 : { sessionId: value, threadId: match[1] };
+}
+
 // src/terminal-policy.ts
 var TERMINAL_CALLS = /* @__PURE__ */ new Set([
   "terminal/environment",
@@ -21620,7 +21672,7 @@ var TERMINAL_CALLS = /* @__PURE__ */ new Set([
   "terminal/close"
 ]);
 var TERMINAL_STREAMS = /* @__PURE__ */ new Set(["terminal/follow", "terminal/retain"]);
-var id2 = external_exports.string().regex(/^[\w-]{1,128}$/);
+var id2 = external_exports.string().regex(/^[A-Za-z0-9_:-]{1,256}$/);
 var TerminalPolicy = class {
   constructor(enabled, deviceId, owners) {
     this.enabled = enabled;
@@ -21634,7 +21686,10 @@ var TerminalPolicy = class {
       "Remote terminal is disabled on this Host. Enable Remote terminal in the Host Remote settings; the switch saves and applies immediately. / \u8FDC\u7A0B\u7EC8\u7AEF\u672A\u5F00\u542F\uFF0C\u8BF7\u5728 Host \u7684 Remote \u8BBE\u7F6E\u4E2D\u5F00\u542F\u300C\u8FDC\u7A0B\u7EC8\u7AEF\u300D\uFF0C\u5F00\u5173\u5207\u6362\u540E\u7ACB\u5373\u4FDD\u5B58\u5E76\u751F\u6548\u3002"
     );
     const args = external_exports.object({ args: external_exports.record(external_exports.unknown()) }).strict().parse(payload).args;
-    const sessionId = id2.parse(args.agentId ?? args.sessionId);
+    const rawSessionId = args.agentId ?? args.sessionId;
+    const sessionId = id2.parse(rawSessionId);
+    const codexSession = parseCodexSessionId(sessionId);
+    void codexSession;
     if (endpoint === "terminal/environment" || endpoint === "terminal/shells" || endpoint === "terminal/list") return {};
     const request = endpoint === "terminal/create" ? external_exports.object({ id: id2 }).passthrough().parse(args.request) : void 0;
     const terminalId = id2.parse(request?.id ?? args.id);
@@ -22334,7 +22389,7 @@ var HostServerConnection = class {
     this.controlFrameLimits = {};
     let acknowledged = false;
     let messageQueue = Promise.resolve();
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       let settled = false;
       const helloTimer = setTimeout(() => socket.close(4001, "hello timeout"), 1e4);
       const finish = (error) => {
@@ -22343,7 +22398,7 @@ var HostServerConnection = class {
         clearTimeout(helloTimer);
         this.online = false;
         if (this.socket === socket) this.socket = void 0;
-        void this.dropTunnels().finally(() => error === void 0 ? resolve3() : reject(error));
+        void this.dropTunnels().finally(() => error === void 0 ? resolve4() : reject(error));
       };
       socket.onopen = () => {
         this.sendControl("hello", {
@@ -22881,14 +22936,14 @@ var HostServerConnection = class {
   waitBeforeRetry(baseDelay) {
     const spread = baseDelay * this.config.reconnect.jitter;
     const delay = Math.max(0, Math.round(baseDelay - spread + Math.random() * spread * 2));
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const timer = setTimeout(() => {
         this.retryWake = void 0;
-        resolve3();
+        resolve4();
       }, delay);
       this.retryWake = () => {
         clearTimeout(timer);
-        resolve3();
+        resolve4();
       };
     });
   }
@@ -23921,7 +23976,7 @@ function historyRequestPayload(payload, maxMessages) {
   return { ...payload, maxMessages };
 }
 function withTimeout(promise, ms, message) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const timer = setTimeout(() => {
       reject(new RpcError("TIMEOUT", message, void 0, true));
     }, ms);
@@ -23929,7 +23984,7 @@ function withTimeout(promise, ms, message) {
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve3(value);
+        resolve4(value);
       },
       (error) => {
         clearTimeout(timer);
@@ -24032,6 +24087,7 @@ var HARNESS_REMOTE_ALLOWLIST = [
   "messageFeedback/list",
   "messageFeedback/put",
   "pluginInventory/list",
+  "permissionPresets/catalog",
   "session/attachment",
   "session/cancel",
   "session/canOpenWorkspacePath",
@@ -24075,12 +24131,13 @@ var HARNESS_REMOTE_ALLOWLIST = [
 ];
 var allowedEndpoints = new Set(HARNESS_REMOTE_ALLOWLIST);
 var HarnessRemoteBridge = class {
-  constructor(gateway, publish, logger, harnessVersion, terminal = new TerminalPolicy(() => false, "", /* @__PURE__ */ new Map())) {
+  constructor(gateway, publish, logger, harnessVersion, terminal = new TerminalPolicy(() => false, "", /* @__PURE__ */ new Map()), codexWorkspace) {
     this.gateway = gateway;
     this.publish = publish;
     this.logger = logger;
     this.harnessVersion = harnessVersion;
     this.terminal = terminal;
+    this.codexWorkspace = codexWorkspace;
   }
   streams = /* @__PURE__ */ new Map();
   incomingTransfers = /* @__PURE__ */ new Map();
@@ -24096,6 +24153,18 @@ var HarnessRemoteBridge = class {
       }
     }
     const reservation = params.endpoint.startsWith("terminal/") ? this.terminal.check(params.endpoint, params.payload) : void 0;
+    let codexResult;
+    if (this.codexWorkspace !== void 0) {
+      try {
+        codexResult = await this.codexWorkspace.call(params.endpoint, params.payload, AbortSignal.timeout(6e4));
+      } catch (error) {
+        if (reservation !== void 0) {
+          this.terminal.result(params.endpoint, params.payload, { ok: false, error: { code: "FAILED", message: "", details: {} } }, reservation);
+        }
+        throw error;
+      }
+    }
+    if (codexResult !== void 0) return reservation === void 0 ? codexResult : this.terminal.result(params.endpoint, params.payload, codexResult, reservation);
     if (params.endpoint === "session/canOpenWorkspacePath") {
       return { ok: true, value: true };
     }
@@ -24248,7 +24317,7 @@ var HarnessRemoteBridge = class {
     this.streams.set(params.streamId, { controller });
     let source;
     try {
-      source = await this.gateway.open(params.endpoint, params.payload, controller.signal);
+      source = (this.codexWorkspace === void 0 ? void 0 : await this.codexWorkspace.open(params.endpoint, params.payload, controller.signal)) ?? await this.gateway.open(params.endpoint, params.payload, controller.signal);
       controller.signal.throwIfAborted();
     } catch (error) {
       this.streams.delete(params.streamId);
@@ -24273,6 +24342,7 @@ var HarnessRemoteBridge = class {
     this.incomingTransfers.clear();
     this.outgoingTransfers.clear();
     for (const [, stream] of streams) stream.controller.abort(reason);
+    await this.codexWorkspace?.closeAll();
   }
   assertAllowed(endpoint) {
     if (!allowedEndpoints.has(endpoint) && !TERMINAL_CALLS.has(endpoint) && !TERMINAL_STREAMS.has(endpoint)) {
@@ -24445,15 +24515,15 @@ var CodexAppServerClient = class {
     const child = this.process;
     this.process = void 0;
     if (child === void 0 || child.exitCode !== null || child.killed) return;
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       const timer = setTimeout(() => {
         child.kill("SIGKILL");
-        resolve3();
+        resolve4();
       }, 2e3);
       timer.unref?.();
       child.once("exit", () => {
         clearTimeout(timer);
-        resolve3();
+        resolve4();
       });
       child.kill("SIGTERM");
     });
@@ -24509,13 +24579,13 @@ var CodexAppServerClient = class {
   }
   request(method, params, timeoutMs) {
     const id4 = this.nextId++;
-    const result = new Promise((resolve3, reject) => {
+    const result = new Promise((resolve4, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id4);
         reject(new CodexAppServerError("CODEX_REQUEST_TIMEOUT", "Codex App Server request timed out."));
       }, timeoutMs);
       timer.unref?.();
-      this.pending.set(id4, { resolve: resolve3, reject, timer });
+      this.pending.set(id4, { resolve: resolve4, reject, timer });
     });
     try {
       this.write({ id: id4, method, params });
@@ -25053,6 +25123,19 @@ var CodexRemoteDomain = class {
       ...this.unavailableCode === void 0 ? {} : { error: this.unavailableCode }
     };
   }
+  /** Resolve a thread cwd for Host-owned workspace/terminal carriers. */
+  async resolveThreadWorkspace(connectionId, threadId) {
+    if (!this.peers.has(connectionId)) throw new RpcError("CODEX_THREAD_UNAVAILABLE", "The CodeX thread is not available on this connection.");
+    try {
+      const known = await this.readKnownThread(threadId);
+      return known.cwd;
+    } catch (error) {
+      if (error instanceof RpcError && error.code === "CODEX_THREAD_NOT_ALLOWED") {
+        throw new RpcError("CODEX_THREAD_UNAVAILABLE", "The CodeX thread is not available.");
+      }
+      throw new RpcError("CODEX_THREAD_UNAVAILABLE", "The CodeX thread is not available.");
+    }
+  }
   createPeer(context, publish) {
     if (!this.config.enabled) return void 0;
     const bridge = new CodexPeerBridge(this, context, publish, this.logger);
@@ -26127,7 +26210,7 @@ var StdioAcpAdapter = class {
     const c = this.ensure();
     const id4 = this.nextId++;
     c.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: id4, method, params }) + "\n");
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       let buf = "";
       const onData = async (d) => {
         buf += d;
@@ -26138,7 +26221,7 @@ var StdioAcpAdapter = class {
             const m = JSON.parse(l);
             if (m.id === id4) {
               c.stdout.off("data", onData);
-              m.error ? reject(new Error(m.error.message ?? "ACP error")) : resolve3(m.result);
+              m.error ? reject(new Error(m.error.message ?? "ACP error")) : resolve4(m.result);
             } else if (m.method && onNotification) await onNotification(m.params);
           } catch {
           }
@@ -26152,14 +26235,460 @@ var StdioAcpAdapter = class {
 
 // src/service.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
+
+// src/codex-workspace-bridge.ts
+import { spawn as spawn4 } from "node:child_process";
+import { realpath as realpath2, lstat, readdir as readdir3, readFile as readFile4, stat as stat5, watch } from "node:fs/promises";
+import { isAbsolute as isAbsolute4, join as join6, relative as relative2, resolve as resolve3 } from "node:path";
+var MAX_READ_BYTES = 4 * 1024 * 1024;
+var MAX_INPUT_BYTES = 64 * 1024;
+var MAX_COLS = 240;
+var MAX_ROWS = 100;
+var MAX_TERMINALS = 256;
+var MAX_SCREEN_BYTES = 256 * 1024;
+var TERMINAL_SCROLLBACK = 2e3;
+var TERMINAL_TYPE = "xterm-256color";
+var CodexWorkspaceState = class {
+  terminals = /* @__PURE__ */ new Map();
+};
+var DEFAULT_SHELL = process.platform === "win32" ? { path: "cmd.exe", args: [], name: "Command Prompt" } : { path: "/bin/sh", args: [], name: "sh" };
+var AsyncQueue = class {
+  values = [];
+  waiters = [];
+  ended = false;
+  push(value) {
+    if (this.ended) return;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter({ done: false, value });
+    else this.values.push(value);
+  }
+  end() {
+    this.ended = true;
+    while (this.waiters.length) this.waiters.shift()({ done: true, value: void 0 });
+  }
+  next() {
+    const value = this.values.shift();
+    if (value !== void 0) return Promise.resolve({ done: false, value });
+    if (this.ended) return Promise.resolve({ done: true, value: void 0 });
+    return new Promise((resolve4) => this.waiters.push(resolve4));
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+var CodexWorkspaceBridge = class {
+  constructor(resolveCwd, terminalEnabled, state = new CodexWorkspaceState(), spawnTerminal = pipeTerminalSpawner()) {
+    this.resolveCwd = resolveCwd;
+    this.terminalEnabled = terminalEnabled;
+    this.terminals = state.terminals;
+    this.spawnTerminal = spawnTerminal;
+  }
+  terminals;
+  ownedSubscribers = /* @__PURE__ */ new Set();
+  spawnTerminal;
+  isCodeXScope(value) {
+    return parseCodexSessionId(value) !== void 0;
+  }
+  async call(endpoint, payload, signal) {
+    const args = argsOf(payload);
+    const scope = args.workspaceFileScopeId;
+    const session = args.agentId ?? args.sessionId;
+    const raw = scope ?? session;
+    const codex = parseCodexSessionId(raw);
+    if (codex === void 0) {
+      if (typeof raw === "string" && raw.startsWith("codex:")) throw new RpcError("CODEX_SESSION_INVALID", "The CodeX session identifier is invalid.");
+      return void 0;
+    }
+    if (endpoint.startsWith("workspaceFiles/")) return this.fileCall(endpoint, codex.sessionId, args, signal);
+    if (endpoint.startsWith("terminal/")) return this.terminalCall(endpoint, codex.sessionId, args, signal);
+    return void 0;
+  }
+  async open(endpoint, payload, signal) {
+    const args = argsOf(payload);
+    const raw = args.workspaceFileScopeId ?? args.agentId ?? args.sessionId;
+    const codex = parseCodexSessionId(raw);
+    if (codex === void 0) {
+      if (typeof raw === "string" && raw.startsWith("codex:")) throw new RpcError("CODEX_SESSION_INVALID", "The CodeX session identifier is invalid.");
+      return void 0;
+    }
+    if (endpoint === "workspaceFiles/changes") return this.watchChanges(codex.sessionId, args, signal);
+    if (endpoint === "terminal/retain") return this.retain(codex.sessionId, args, signal);
+    if (endpoint === "terminal/follow") return this.follow(codex.sessionId, args, signal);
+    return void 0;
+  }
+  async closeAll() {
+    for (const queue of this.ownedSubscribers) queue.end();
+    this.ownedSubscribers.clear();
+  }
+  async fileCall(endpoint, sessionId, args, signal) {
+    const root = await this.rootFor(sessionId, signal);
+    const path = typeof args.path === "string" ? args.path : ".";
+    const target2 = await this.safePath(root, path, endpoint === "workspaceFiles/list");
+    try {
+      if (endpoint === "workspaceFiles/list") {
+        const entries = await readdir3(target2, { withFileTypes: true });
+        const result = [];
+        for (const entry of entries.slice(0, 500)) {
+          const item = join6(target2, entry.name);
+          const info2 = await lstat(item);
+          if (info2.isSymbolicLink()) continue;
+          result.push({ name: entry.name, type: info2.isDirectory() ? "directory" : info2.isFile() ? "file" : "other", ...info2.isFile() ? { size: info2.size } : {} });
+        }
+        return { ok: true, value: { path, entries: result, truncated: entries.length > 500 } };
+      }
+      const info = await stat5(target2);
+      if (endpoint === "workspaceFiles/stat") return { ok: true, value: { path, type: info.isDirectory() ? "directory" : info.isFile() ? "file" : "other", size: info.size, modifiedAt: info.mtimeMs } };
+      if (!info.isFile()) throw new RpcError("CODEX_WORKSPACE_INVALID_PATH", "The requested workspace path is not a file.");
+      const offset = readOffset(args);
+      const limit = readLimit(args);
+      const bytes = await readFile4(target2);
+      if (bytes.byteLength > MAX_READ_BYTES) throw new RpcError("CODEX_WORKSPACE_TOO_LARGE", "The requested workspace file is too large.");
+      if (endpoint === "workspaceFiles/readBytes") {
+        const slice2 = bytes.subarray(offset, Math.min(offset + limit, bytes.length));
+        return { ok: true, value: { path, offset, bytes: slice2.toString("base64"), eof: offset + slice2.length >= bytes.length } };
+      }
+      const text = bytes.toString("utf8");
+      const slice = text.slice(offset, offset + limit);
+      return { ok: true, value: { absolutePath: target2, version: `${info.mtimeMs}:${info.size}`, text: slice, offset, lines: slice.split("\n").length, eof: offset + slice.length >= text.length } };
+    } catch (error) {
+      if (error instanceof RpcError) throw error;
+      throw new RpcError("CODEX_WORKSPACE_UNAVAILABLE", "The CodeX workspace file is unavailable.");
+    }
+  }
+  async watchChanges(sessionId, args, signal) {
+    const root = await this.rootFor(sessionId, signal);
+    const target2 = await this.safePath(root, typeof args.path === "string" ? args.path : ".", true);
+    const queue = new AsyncQueue();
+    const watcher = watch(target2, { recursive: false });
+    const abort = () => {
+      watcher.return?.();
+      queue.end();
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    void (async () => {
+      try {
+        for await (const event of watcher) queue.push({ type: event.eventType, path: event.filename ?? "" });
+      } catch {
+      } finally {
+        signal.removeEventListener("abort", abort);
+        queue.end();
+      }
+    })();
+    return queue;
+  }
+  /**
+   * `terminal/retain` only acknowledges the retention window: it never takes
+   * input ownership and never replays output. Recovery reads the next snapshot.
+   */
+  async retain(sessionId, args, signal) {
+    this.assertTerminalEnabled();
+    await this.rootFor(sessionId, signal);
+    this.requireTerminal(sessionId, String(args.id));
+    const queue = new AsyncQueue();
+    queue.push({ type: "retained" });
+    this.ownedSubscribers.add(queue);
+    signal.addEventListener("abort", () => {
+      this.ownedSubscribers.delete(queue);
+      queue.end();
+    }, { once: true });
+    return queue;
+  }
+  /** `terminal/follow` takes input ownership and starts with a screen snapshot. */
+  async follow(sessionId, args, signal) {
+    this.assertTerminalEnabled();
+    await this.rootFor(sessionId, signal);
+    const attachmentId = typeof args.attachmentId === "string" && args.attachmentId.length > 0 ? args.attachmentId : void 0;
+    if (attachmentId === void 0) throw new RpcError("INVALID_MESSAGE", "The terminal attachment is invalid.");
+    const terminal = this.requireTerminal(sessionId, String(args.id));
+    const queue = new AsyncQueue();
+    if (terminal.controllerId !== attachmentId) {
+      terminal.controllerId = attachmentId;
+      this.emit(terminal, { type: "state", info: terminalInfo(terminal) });
+    }
+    queue.push({ type: "snapshot", sequence: terminal.sequence, screen: screenOf(terminal), info: terminalInfo(terminal) });
+    terminal.subscribers.add(queue);
+    this.ownedSubscribers.add(queue);
+    signal.addEventListener("abort", () => {
+      terminal.subscribers.delete(queue);
+      this.ownedSubscribers.delete(queue);
+      queue.end();
+      if (terminal.controllerId === attachmentId) {
+        terminal.controllerId = void 0;
+        this.emit(terminal, { type: "state", info: terminalInfo(terminal) });
+      }
+    }, { once: true });
+    return queue;
+  }
+  async terminalCall(endpoint, sessionId, args, signal) {
+    this.assertTerminalEnabled();
+    const cwd = await this.rootFor(sessionId, signal);
+    if (endpoint === "terminal/environment") {
+      return { ok: true, value: { cwd, maxInputBytes: MAX_INPUT_BYTES, maxCols: MAX_COLS, maxRows: MAX_ROWS, scrollback: TERMINAL_SCROLLBACK } };
+    }
+    if (endpoint === "terminal/shells") return { ok: true, value: [shellInfo(DEFAULT_SHELL)] };
+    if (endpoint === "terminal/list") return { ok: true, value: [...this.terminals.values()].filter((item) => item.sessionId === sessionId).map(terminalInfo) };
+    if (endpoint === "terminal/create") return this.createTerminal(sessionId, cwd, args);
+    const id4 = stringId(args.id);
+    const terminal = this.requireTerminal(sessionId, id4);
+    if (endpoint === "terminal/write") {
+      const data2 = typeof args.data === "string" ? args.data : "";
+      if (Buffer.byteLength(data2) > MAX_INPUT_BYTES) throw new RpcError("INVALID_MESSAGE", "Terminal input is too large.");
+      if (terminal.process === void 0) throw new RpcError("CODEX_TERMINAL_NOT_FOUND", "The CodeX terminal is no longer available.");
+      await terminal.process.write(data2);
+      return { ok: true };
+    }
+    if (endpoint === "terminal/resize") {
+      terminal.cols = bounded(args.cols, terminal.cols, MAX_COLS);
+      terminal.rows = bounded(args.rows, terminal.rows, MAX_ROWS);
+      await terminal.process?.resize(terminal.cols, terminal.rows);
+      return { ok: true };
+    }
+    if (endpoint === "terminal/rename") {
+      if (typeof args.title === "string" && args.title.length > 0) terminal.title = args.title.slice(0, 128);
+      return { ok: true };
+    }
+    if (endpoint === "terminal/close") {
+      this.disposeTerminal(terminal);
+      this.terminals.delete(`${sessionId}/${id4}`);
+      return { ok: true };
+    }
+    throw new RpcError("METHOD_NOT_FOUND", "The requested terminal method does not exist.");
+  }
+  async createTerminal(sessionId, cwd, args) {
+    const request = isRecord13(args.request) ? args.request : {};
+    const id4 = stringId(request.id);
+    if ([...this.terminals.values()].some((item) => item.sessionId === sessionId && item.id === id4)) throw new RpcError("REQUEST_CONFLICT", "The terminal id is already active.");
+    if (this.terminals.size >= MAX_TERMINALS) throw new RpcError("RATE_LIMITED", "Too many remote terminals are active.", void 0, true);
+    if (request.shellPath !== void 0 && request.shellPath !== DEFAULT_SHELL.path) throw new RpcError("INVALID_MESSAGE", "The requested shell is not available for this workspace.");
+    const cols = bounded(request.cols, 80, MAX_COLS);
+    const rows = bounded(request.rows, 24, MAX_ROWS);
+    const terminal = {
+      sessionId,
+      id: id4,
+      title: DEFAULT_SHELL.name,
+      shell: DEFAULT_SHELL,
+      cwd,
+      cols,
+      rows,
+      sequence: 0,
+      screen: [],
+      screenBytes: 0,
+      truncated: false,
+      subscribers: /* @__PURE__ */ new Set(),
+      state: "running",
+      exitCode: null
+    };
+    this.terminals.set(`${sessionId}/${id4}`, terminal);
+    try {
+      terminal.process = await this.spawnTerminal({
+        argv: [DEFAULT_SHELL.path, ...DEFAULT_SHELL.args],
+        cwd,
+        cols,
+        rows,
+        terminalType: TERMINAL_TYPE,
+        env: { DSH_SESSION_ID: sessionId }
+      });
+    } catch {
+      this.terminals.delete(`${sessionId}/${id4}`);
+      throw new RpcError("CODEX_TERMINAL_UNAVAILABLE", "The CodeX terminal could not be started.");
+    }
+    void this.pump(terminal, terminal.process);
+    return { ok: true, value: terminalInfo(terminal) };
+  }
+  /** Streams process output as ordered `output` frames, then reports the exit. */
+  async pump(terminal, process2) {
+    try {
+      for await (const chunk of process2.output) {
+        if (chunk.length === 0) continue;
+        terminal.sequence += 1;
+        this.appendScreen(terminal, chunk);
+        this.emit(terminal, { type: "output", sequence: terminal.sequence, data: chunk });
+      }
+    } catch {
+      terminal.state = "failed";
+      terminal.error = "The terminal output stream failed.";
+    }
+    const outcome = await process2.completed;
+    terminal.exitCode = outcome.exitCode;
+    if (terminal.state === "running") terminal.state = "exited";
+    this.emit(terminal, { type: "state", info: terminalInfo(terminal) });
+    this.endSubscribers(terminal);
+  }
+  appendScreen(terminal, chunk) {
+    terminal.screen.push(chunk);
+    terminal.screenBytes += Buffer.byteLength(chunk);
+    while (terminal.screenBytes > MAX_SCREEN_BYTES && terminal.screen.length > 1) {
+      terminal.screenBytes -= Buffer.byteLength(terminal.screen.shift());
+      terminal.truncated = true;
+    }
+  }
+  async rootFor(sessionId, signal) {
+    const parsed = parseCodexSessionId(sessionId);
+    if (!parsed) throw new RpcError("CODEX_SESSION_INVALID", "The CodeX session identifier is invalid.");
+    const cwd = await this.resolveCwd(parsed.threadId, signal);
+    if (!cwd) throw new RpcError("CODEX_WORKSPACE_UNAVAILABLE", "The CodeX thread has no available workspace.");
+    try {
+      const root = await realpath2(cwd);
+      const info = await stat5(root);
+      if (!info.isDirectory()) throw new Error();
+      return root;
+    } catch {
+      throw new RpcError("CODEX_WORKSPACE_UNAVAILABLE", "The CodeX workspace is unavailable.");
+    }
+  }
+  async safePath(root, path, directory) {
+    if (isAbsolute4(path)) throw new RpcError("CODEX_WORKSPACE_PATH_DENIED", "The requested workspace path is outside the CodeX workspace.");
+    const candidate = resolve3(root, path);
+    const rel = relative2(root, candidate);
+    if (rel.startsWith("..") || isAbsolute4(rel)) throw new RpcError("CODEX_WORKSPACE_PATH_DENIED", "The requested workspace path is outside the CodeX workspace.");
+    try {
+      const info = await lstat(candidate);
+      if (info.isSymbolicLink()) throw new Error();
+      const canonical = await realpath2(candidate);
+      const canonicalRel = relative2(root, canonical);
+      if (canonicalRel.startsWith("..") || isAbsolute4(canonicalRel)) throw new Error();
+      if (directory && !info.isDirectory()) throw new Error();
+      return canonical;
+    } catch {
+      throw new RpcError("CODEX_WORKSPACE_PATH_DENIED", "The requested workspace path is unavailable.");
+    }
+  }
+  emit(terminal, value) {
+    for (const subscriber of terminal.subscribers) subscriber.push(value);
+  }
+  endSubscribers(terminal) {
+    for (const subscriber of terminal.subscribers) subscriber.end();
+    terminal.subscribers.clear();
+  }
+  requireTerminal(sessionId, id4) {
+    const terminal = this.terminals.get(`${sessionId}/${id4}`);
+    if (!terminal) throw new RpcError("CODEX_TERMINAL_NOT_FOUND", "The CodeX terminal is no longer available.");
+    return terminal;
+  }
+  assertTerminalEnabled() {
+    if (!this.terminalEnabled()) throw new RpcError("TERMINAL_DISABLED", "Remote terminal is disabled on this Host.");
+  }
+  disposeTerminal(terminal) {
+    void Promise.resolve(terminal.process?.terminate()).catch(() => void 0);
+    if (terminal.state === "running") {
+      terminal.state = "exited";
+      this.emit(terminal, { type: "state", info: terminalInfo(terminal) });
+    }
+    this.endSubscribers(terminal);
+  }
+};
+function pipeTerminalSpawner() {
+  return async (spec) => {
+    const child = spawn4(spec.argv[0], spec.argv.slice(1), {
+      cwd: spec.cwd,
+      stdio: "pipe",
+      windowsHide: true,
+      env: { ...process.env, ...spec.env }
+    });
+    const queue = new AsyncQueue();
+    child.stdout.on("data", (data2) => queue.push(Buffer.from(data2).toString("utf8")));
+    child.stderr.on("data", (data2) => queue.push(Buffer.from(data2).toString("utf8")));
+    child.on("error", () => queue.end());
+    const completed = new Promise((resolve4) => {
+      child.on("error", () => {
+        queue.end();
+        resolve4({ exitCode: null });
+      });
+      child.on("exit", (code) => {
+        queue.end();
+        resolve4({ exitCode: code });
+      });
+    });
+    return {
+      output: queue,
+      write: (data2) => {
+        child.stdin.write(data2);
+      },
+      resize: () => void 0,
+      terminate: () => {
+        if (!child.killed) child.kill();
+      },
+      completed
+    };
+  };
+}
+function subprocessTerminalSpawner(subprocess) {
+  return async (spec) => {
+    const handle = await subprocess.spawnTerminal({
+      argv: [...spec.argv],
+      cwd: spec.cwd,
+      cols: spec.cols,
+      rows: spec.rows,
+      terminalType: spec.terminalType,
+      env: spec.env
+    });
+    const queue = new AsyncQueue();
+    handle.output.setEncoding?.("utf8");
+    handle.output.on("data", (chunk) => queue.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8")));
+    handle.output.once("close", () => queue.end());
+    handle.output.once("error", () => queue.end());
+    return {
+      output: queue,
+      write: (data2) => handle.write(data2),
+      resize: (cols, rows) => handle.resize(cols, rows),
+      terminate: () => handle.terminate(),
+      completed: handle.done.then((outcome) => ({ exitCode: typeof outcome?.exitCode === "number" ? outcome.exitCode : null })).catch(() => ({ exitCode: null }))
+    };
+  };
+}
+function shellInfo(shell) {
+  return { path: shell.path, args: [...shell.args], name: shell.name };
+}
+function terminalInfo(terminal) {
+  return {
+    id: terminal.id,
+    title: terminal.title,
+    shell: shellInfo(terminal.shell),
+    cwd: terminal.cwd,
+    cols: terminal.cols,
+    rows: terminal.rows,
+    state: terminal.state,
+    exitCode: terminal.exitCode,
+    ...terminal.error === void 0 ? {} : { error: terminal.error },
+    ...terminal.controllerId === void 0 ? {} : { controllerId: terminal.controllerId }
+  };
+}
+function screenOf(terminal) {
+  return (terminal.truncated ? "\x1Bc" : "") + terminal.screen.join("");
+}
+function argsOf(payload) {
+  const value = isRecord13(payload) ? payload : {};
+  return isRecord13(value.args) ? value.args : value;
+}
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringId(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9_.:-]{1,128}$/.test(value)) throw new RpcError("INVALID_MESSAGE", "The terminal identifier is invalid.");
+  return value;
+}
+function bounded(value, fallback, max) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? Math.min(value, max) : fallback;
+}
+function readOffset(args) {
+  const range = isRecord13(args.range) ? args.range : args;
+  return typeof range.offset === "number" && Number.isInteger(range.offset) && range.offset >= 0 ? range.offset : 0;
+}
+function readLimit(args) {
+  const range = isRecord13(args.range) ? args.range : args;
+  return typeof range.limit === "number" && Number.isInteger(range.limit) && range.limit > 0 ? Math.min(range.limit, MAX_READ_BYTES) : MAX_READ_BYTES;
+}
+
+// src/service.ts
 var HostPluginRuntime = class {
-  constructor(config, identities, apiProxy, logger, localGateway, fileViewerHost) {
+  constructor(config, identities, apiProxy, logger, localGateway, fileViewerHost, terminalSpawner) {
     this.config = config;
     this.identities = identities;
     this.apiProxy = apiProxy;
     this.logger = logger;
     this.localGateway = localGateway;
     this.fileViewerHost = fileViewerHost;
+    this.terminalSpawner = terminalSpawner;
     this.terminalEnabled = config.terminal.enabled;
     this.loopback = new LoopbackHost(config.loopback.ports);
     this.codex = new CodexRemoteDomain(config.codex, logger);
@@ -26177,7 +26706,13 @@ var HostPluginRuntime = class {
         (event, data2) => send(createEvent(event, data2)),
         this.logger,
         this.harnessVersion,
-        new TerminalPolicy(() => this.terminalEnabled, context.peerDeviceId, this.terminalOwners)
+        new TerminalPolicy(() => this.terminalEnabled, context.peerDeviceId, this.terminalOwners),
+        new CodexWorkspaceBridge(
+          (threadId, signal) => this.codex.resolveThreadWorkspace(context.connectionId, threadId),
+          () => this.terminalEnabled,
+          this.codexWorkspaceState,
+          this.terminalSpawner
+        )
       ) : void 0;
       const fileViewer = new RemoteFileViewerBridge(
         () => this.fileViewerHost?.(),
@@ -26215,6 +26750,7 @@ var HostPluginRuntime = class {
   harnessVersion;
   closed = false;
   codex;
+  codexWorkspaceState = new CodexWorkspaceState();
   localCodexPeer;
   localCodexPublish = async () => void 0;
   setTerminalEnabled(enabled) {
@@ -26498,9 +27034,9 @@ function isPlainRecord(value) {
 }
 
 // src/cli.ts
-import { stat as stat5 } from "node:fs/promises";
+import { stat as stat6 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var QR_POLL_INTERVAL_MS = 2e3;
 var TERMINAL_QR_MARGIN = 4;
 async function runCli(args = process.argv.slice(2), dependencies = {}) {
@@ -26577,7 +27113,7 @@ async function status(args, runtime) {
     `Server: ${serverUrl}`,
     "Host control: enabled (dsh-TUI default)"
   ];
-  if (!await exists3(join6(directory, "device.json"))) {
+  if (!await exists3(join7(directory, "device.json"))) {
     lines.push("Device: not initialized", "Authorization: logged out", "Credential: unavailable");
     write(runtime.stdout, `${lines.join("\n")}
 
@@ -26621,7 +27157,7 @@ async function logout(args, runtime) {
   const serverUrl = selectedServer();
   const root = new IdentityStore({ env: runtime.env }).directory;
   const directory = serverStorageDirectory(root, serverUrl, "host");
-  if (!await exists3(join6(directory, "device.json"))) {
+  if (!await exists3(join7(directory, "device.json"))) {
     await new ServerCredentialStore(directory).clear();
     write(runtime.stdout, "This Host is already logged out.\n");
     return 0;
@@ -26663,7 +27199,7 @@ function resolveDependencies(input2) {
     stdout: input2.stdout ?? process.stdout,
     stderr: input2.stderr ?? process.stderr,
     now: input2.now ?? Date.now,
-    wait: input2.wait ?? ((milliseconds) => new Promise((resolve3) => setTimeout(resolve3, milliseconds))),
+    wait: input2.wait ?? ((milliseconds) => new Promise((resolve4) => setTimeout(resolve4, milliseconds))),
     renderQr: input2.renderQr ?? renderTerminalQr,
     createIdentityStore: input2.createIdentityStore ?? ((options) => new IdentityStore(options)),
     createHostApi: input2.createHostApi ?? ((serverUrl, store) => new HostServerApi(serverUrl, store))
@@ -26749,7 +27285,7 @@ function terminalLink(url, target2) {
 }
 async function exists3(path) {
   try {
-    await stat5(path);
+    await stat6(path);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
@@ -27108,7 +27644,7 @@ function errorCode4(error) {
   return "CONNECTION_FAILED";
 }
 function wait(milliseconds) {
-  return new Promise((resolve3) => setTimeout(resolve3, milliseconds));
+  return new Promise((resolve4) => setTimeout(resolve4, milliseconds));
 }
 
 // src/remote-file-content-provider.ts
@@ -27277,13 +27813,15 @@ async function activate(ctx, input2, tuiBinding) {
   const apiProxy = ctx.get("apiProxy");
   const nativeTypertGateway = ctx.get("typertGateway");
   const localTypertGateway = new TypertGatewaySwitch(nativeTypertGateway).local();
+  const subprocess = ctx.get("subprocess", false);
   const runtime = new HostPluginRuntime(
     config,
     hostIdentities,
     apiProxy,
     logger,
     localTypertGateway,
-    () => ctx.get("fileViewerHost")
+    () => ctx.get("fileViewerHost"),
+    subprocess === void 0 ? void 0 : subprocessTerminalSpawner(subprocess)
   );
   let clientRuntime;
   const hostControl = runtime;