@bitkyc08/opencodex 2.52.0-preview.20260912 → 2.53.0-preview.20260913

package/src/remote-control/workspace-agent-connection.ts

@@ -0,0 +1,366 @@
+import type { RemoteControlIdentityKeyPair } from "./crypto";
+import {
+  RemoteControlClientHandshake,
+  acceptRemoteControlClientHello,
+} from "./crypto";
+import type { RemoteWorkspaceExecutor } from "./workspace-executor";
+import { REMOTE_CONTROL_MAX_SESSIONS_PER_DEVICE } from "./protocol";
+import {
+  EncryptedRemoteWorkspaceExecutorEndpoint,
+  EncryptedRemoteWorkspaceTransport,
+} from "./workspace-rpc";
+import {
+  REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+  parseRemoteWorkspaceAgentMessage,
+  parseRemoteWorkspaceHubMessage,
+  serializeRemoteWorkspaceAgentMessage,
+  serializeRemoteWorkspaceHubMessage,
+  type RemoteWorkspaceAgentProfile,
+} from "./workspace-agent-protocol";
+import {
+  parseRemoteWorkspaceCapabilities,
+  type RemoteWorkspaceCapability,
+} from "./workspace-tools";
+import { truncateRemoteWorkspaceUtf8 } from "./workspace-utf8";
+
+const SESSION_OPEN_TIMEOUT_MS = 10_000;
+
+export interface RemoteWorkspaceControlSocket {
+  send(value: string): void | Promise<void>;
+  close(code: number, reason: string): void;
+}
+
+interface PendingHubSession {
+  handshake: RemoteControlClientHandshake;
+  resolve(transport: EncryptedRemoteWorkspaceTransport): void;
+  reject(error: Error): void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+function safeReason(value: string): string {
+  const cleaned = value.replace(/[\x00-\x1f\x7f]/g, " ").trim();
+  const selected = cleaned || "remote workspace session closed";
+  return truncateRemoteWorkspaceUtf8(selected, 120);
+}
+
+/** Hub-side representation of one authenticated, online OCX-only executor. */
+export class RemoteWorkspaceHubAgentConnection {
+  private readonly pending = new Map<string, PendingHubSession>();
+  private readonly active = new Map<string, EncryptedRemoteWorkspaceTransport>();
+  private readonly cancelledSessionIds = new Set<string>();
+  private closed = false;
+  private presenceAccepted = false;
+  private presencePending = false;
+  private currentCapabilities: RemoteWorkspaceCapability[];
+
+  constructor(private readonly options: {
+    deviceId: string;
+    devicePublicKey: string;
+    hubIdentity: RemoteControlIdentityKeyPair;
+    socket: RemoteWorkspaceControlSocket;
+    capabilities?: readonly RemoteWorkspaceCapability[];
+    onCapabilities?: (capabilities: readonly RemoteWorkspaceCapability[]) => void;
+    sessionOpenTimeoutMs?: number;
+  }) {
+    this.currentCapabilities = parseRemoteWorkspaceCapabilities(options.capabilities);
+  }
+
+  isOnline(): boolean {
+    return !this.closed && this.presenceAccepted;
+  }
+
+  capabilities(): RemoteWorkspaceCapability[] {
+    return [...this.currentCapabilities];
+  }
+
+  async openSession(options: {
+    sessionId: string;
+    rootId: string;
+    profile: RemoteWorkspaceAgentProfile;
+    capabilities: readonly RemoteWorkspaceCapability[];
+  }): Promise<EncryptedRemoteWorkspaceTransport> {
+    if (!this.isOnline()) throw new Error("remote workspace executor is offline");
+    if (this.pending.has(options.sessionId) || this.active.has(options.sessionId)) {
+      throw new Error("remote workspace session already exists");
+    }
+    if (this.pending.size + this.active.size >= REMOTE_CONTROL_MAX_SESSIONS_PER_DEVICE) {
+      throw new Error("remote workspace executor session limit reached");
+    }
+    if (!Array.isArray(options.capabilities)) throw new Error("remote workspace session requires explicit capabilities");
+    const requestedCapabilities = parseRemoteWorkspaceCapabilities(options.capabilities);
+    if (requestedCapabilities.some(capability => !this.currentCapabilities.includes(capability))) {
+      throw new Error("remote workspace session requests an unavailable capability");
+    }
+    const handshake = RemoteControlClientHandshake.create({
+      sessionId: options.sessionId,
+      deviceId: this.options.deviceId,
+      commandProfile: options.profile,
+      capabilities: requestedCapabilities,
+      accountPrivateKey: this.options.hubIdentity.privateKey,
+    });
+    const timeoutMs = this.options.sessionOpenTimeoutMs ?? SESSION_OPEN_TIMEOUT_MS;
+    const opened = new Promise<EncryptedRemoteWorkspaceTransport>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(options.sessionId);
+        this.rememberCancelledSession(options.sessionId);
+        reject(new Error("remote workspace session handshake timed out"));
+      }, timeoutMs);
+      this.pending.set(options.sessionId, { handshake, resolve, reject, timer });
+    });
+    try {
+      await this.options.socket.send(serializeRemoteWorkspaceHubMessage({
+        version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+        type: "session_open",
+        rootId: options.rootId,
+        clientHello: handshake.hello,
+      }));
+    } catch (error) {
+      const pending = this.pending.get(options.sessionId);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(options.sessionId);
+        pending.reject(error instanceof Error ? error : new Error("remote workspace session send failed"));
+      }
+    }
+    return await opened;
+  }
+
+  receive(raw: string | Uint8Array): void {
+    if (this.closed) throw new Error("remote workspace executor is offline");
+    const message = parseRemoteWorkspaceAgentMessage(raw);
+    if (message.type === "presence") {
+      if (this.presenceAccepted || this.presencePending) {
+        throw new Error("remote workspace executor sent duplicate presence");
+      }
+      const approved = parseRemoteWorkspaceCapabilities(this.options.capabilities);
+      const capabilities = parseRemoteWorkspaceCapabilities(message.capabilities.filter(capability => approved.includes(capability)));
+      this.presencePending = true;
+      const accept = () => {
+        if (this.closed) return;
+        this.options.onCapabilities?.(capabilities);
+        this.currentCapabilities = capabilities;
+        this.presenceAccepted = true;
+        this.presencePending = false;
+      };
+      let sent: void | Promise<void>;
+      try {
+        sent = this.options.socket.send(serializeRemoteWorkspaceHubMessage({
+          version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+          type: "presence_ack",
+          capabilities,
+        }));
+      } catch (error) {
+        this.presencePending = false;
+        throw error;
+      }
+      if (sent && typeof sent.then === "function") {
+        void sent.then(accept).catch(() => this.close("remote workspace presence acknowledgement failed"));
+      } else {
+        accept();
+      }
+      return;
+    }
+    if (!this.presenceAccepted) {
+      throw new Error("remote workspace executor presence is required before session traffic");
+    }
+    if (message.type === "heartbeat") return;
+    if (message.type === "session_accept") {
+      const pending = this.pending.get(message.sessionId);
+      if (!pending) {
+        if (!this.cancelledSessionIds.delete(message.sessionId)) {
+          throw new Error("remote workspace accepted an unknown session");
+        }
+        void Promise.resolve(this.options.socket.send(serializeRemoteWorkspaceHubMessage({
+          version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+          type: "session_close",
+          sessionId: message.sessionId,
+          reason: "remote workspace session was already cancelled",
+        }))).catch(() => this.close("remote workspace cancelled-session cleanup failed"));
+        return;
+      }
+      const cipher = pending.handshake.complete(message.hostHello, this.options.devicePublicKey);
+      const transport = new EncryptedRemoteWorkspaceTransport({
+        executorDeviceId: this.options.deviceId,
+        cipher,
+        sendCiphertext: value => this.options.socket.send(serializeRemoteWorkspaceHubMessage({
+          version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+          type: "ciphertext",
+          sessionId: message.sessionId,
+          payload: value,
+        })),
+      });
+      clearTimeout(pending.timer);
+      this.pending.delete(message.sessionId);
+      this.active.set(message.sessionId, transport);
+      pending.resolve(transport);
+      return;
+    }
+    if (message.type === "session_reject") {
+      const pending = this.pending.get(message.sessionId);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(message.sessionId);
+      pending.reject(new Error(safeReason(message.reason)));
+      return;
+    }
+    const transport = this.active.get(message.sessionId);
+    if (!transport) throw new Error("remote workspace ciphertext targeted an unknown session");
+    transport.receiveCiphertext(message.payload);
+  }
+
+  async closeSession(sessionId: string, reason = "remote workspace session closed"): Promise<void> {
+    const pending = this.pending.get(sessionId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this.pending.delete(sessionId);
+      this.rememberCancelledSession(sessionId);
+      pending.reject(new Error(safeReason(reason)));
+    }
+    const transport = this.active.get(sessionId);
+    if (transport) {
+      this.active.delete(sessionId);
+      transport.close(safeReason(reason));
+    }
+    if (this.closed) return;
+    await this.options.socket.send(serializeRemoteWorkspaceHubMessage({
+      version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+      type: "session_close",
+      sessionId,
+      reason: safeReason(reason),
+    }));
+  }
+
+  close(reason = "remote workspace executor disconnected"): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(safeReason(reason)));
+    }
+    this.pending.clear();
+    for (const transport of this.active.values()) transport.close(safeReason(reason));
+    this.active.clear();
+    this.cancelledSessionIds.clear();
+    try { this.options.socket.close(1008, safeReason(reason)); } catch { /* socket is already gone */ }
+  }
+
+  private rememberCancelledSession(sessionId: string): void {
+    this.cancelledSessionIds.add(sessionId);
+    while (this.cancelledSessionIds.size > 16) {
+      const oldest = this.cancelledSessionIds.values().next();
+      if (oldest.done) break;
+      this.cancelledSessionIds.delete(oldest.value);
+    }
+  }
+}
+
+/** Executor-side connection. It owns no Codex, Claude Code, Pi, provider key, or model session. */
+export class RemoteWorkspaceExecutorAgentConnection {
+  private readonly sessions = new Map<string, EncryptedRemoteWorkspaceExecutorEndpoint>();
+  private closed = false;
+
+  constructor(private readonly options: {
+    deviceId: string;
+    deviceIdentity: RemoteControlIdentityKeyPair;
+    hubPublicKey: string;
+    executor: RemoteWorkspaceExecutor;
+    capabilities?: readonly RemoteWorkspaceCapability[];
+    onPresenceAccepted?: () => void;
+    socket: RemoteWorkspaceControlSocket;
+  }) {
+    this.currentCapabilities = parseRemoteWorkspaceCapabilities(options.capabilities);
+  }
+
+  private currentCapabilities: RemoteWorkspaceCapability[];
+
+  async receive(raw: string | Uint8Array): Promise<void> {
+    if (this.closed) throw new Error("remote workspace agent connection is closed");
+    const message = parseRemoteWorkspaceHubMessage(raw);
+    if (message.type === "presence_ack") {
+      if (message.capabilities.some(capability => !this.currentCapabilities.includes(capability))) {
+        throw new Error("remote workspace Hub acknowledged different executor capabilities");
+      }
+      this.currentCapabilities = [...message.capabilities];
+      this.options.onPresenceAccepted?.();
+      return;
+    }
+    if (message.type === "session_open") {
+      let endpoint: EncryptedRemoteWorkspaceExecutorEndpoint | null = null;
+      try {
+        if (this.sessions.has(message.clientHello.sessionId)) {
+          throw new Error("remote workspace executor session already exists");
+        }
+        if (this.sessions.size >= REMOTE_CONTROL_MAX_SESSIONS_PER_DEVICE) {
+          throw new Error("remote workspace executor session limit reached");
+        }
+        if (message.clientHello.deviceId !== this.options.deviceId) {
+          throw new Error("remote workspace session targeted another executor");
+        }
+        if (!this.options.executor.hasApprovedRoot(message.rootId)) {
+          throw new Error("remote workspace root is not approved");
+        }
+        const accepted = acceptRemoteControlClientHello(message.clientHello, {
+          expectedSessionId: message.clientHello.sessionId,
+          expectedDeviceId: this.options.deviceId,
+          accountPublicKey: this.options.hubPublicKey,
+          devicePrivateKey: this.options.deviceIdentity.privateKey,
+          allowedCapabilities: this.currentCapabilities,
+        });
+        endpoint = new EncryptedRemoteWorkspaceExecutorEndpoint({
+          executorDeviceId: this.options.deviceId,
+          sessionId: message.clientHello.sessionId,
+          rootId: message.rootId,
+          capabilities: parseRemoteWorkspaceCapabilities(accepted.hello.capabilities),
+          cipher: accepted.cipher,
+          executor: this.options.executor,
+          sendCiphertext: value => this.options.socket.send(serializeRemoteWorkspaceAgentMessage({
+            version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+            type: "ciphertext",
+            sessionId: message.clientHello.sessionId,
+            payload: value,
+          })),
+        });
+        this.sessions.set(message.clientHello.sessionId, endpoint);
+        await this.options.socket.send(serializeRemoteWorkspaceAgentMessage({
+          version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+          type: "session_accept",
+          sessionId: message.clientHello.sessionId,
+          hostHello: accepted.hello,
+        }));
+      } catch (error) {
+        if (endpoint) {
+          this.sessions.delete(message.clientHello.sessionId);
+          endpoint.close();
+        }
+        await this.options.socket.send(serializeRemoteWorkspaceAgentMessage({
+          version: REMOTE_WORKSPACE_AGENT_PROTOCOL_VERSION,
+          type: "session_reject",
+          sessionId: message.clientHello.sessionId,
+          reason: safeReason(error instanceof Error ? error.message : "remote workspace session refused"),
+        }));
+      }
+      return;
+    }
+    if (message.type === "session_close") {
+      this.sessions.get(message.sessionId)?.close();
+      this.sessions.delete(message.sessionId);
+      return;
+    }
+    const endpoint = this.sessions.get(message.sessionId);
+    if (!endpoint) throw new Error("remote workspace ciphertext targeted an unknown executor session");
+    // Decryption and counter validation happen synchronously before this returns. The execution
+    // promise is intentionally detached so an unencrypted session_close control frame can abort a
+    // long-running command instead of waiting behind that command on the socket's ordered queue.
+    void endpoint.receiveCiphertext(message.payload).catch(() => {
+      this.close();
+      this.options.socket.close(1008, "remote workspace protocol error");
+    });
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const endpoint of this.sessions.values()) endpoint.close();
+    this.sessions.clear();
+  }
+}

package/src/remote-control/workspace-claude-runtime.ts

@@ -0,0 +1,243 @@
+import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { remoteWorkspaceDeveloperInstructions } from "./workspace-tools";
+import { findExecutableOnPath } from "./workspace-executable";
+import {
+  remoteWorkspaceProcessInvocation,
+  removeRemoteWorkspaceIsolation,
+  runRemoteWorkspaceCleanupSteps,
+  stopRemoteWorkspaceProcess,
+} from "./workspace-process";
+import { startRemoteWorkspaceToolBridge } from "./workspace-tool-bridge";
+import type {
+  RemoteWorkspaceRuntimeFactory,
+  RemoteWorkspaceRuntimeHandle,
+} from "./workspace-sessions";
+
+const MAX_OUTPUT_LINE_BYTES = 2 * 1024 * 1024;
+const MAX_STDERR_BYTES = 64 * 1024;
+
+function safeError(value: unknown, fallback: string): string {
+  return (value instanceof Error ? value.message : typeof value === "string" ? value : fallback)
+    .replace(/[^\x20-\x7e\n\t]/g, " ")
+    .slice(0, 4_096);
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function assistantText(value: unknown): string | null {
+  const message = record(value);
+  if (!message || !Array.isArray(message.content)) return null;
+  const text = message.content.flatMap(raw => {
+    const part = record(raw);
+    return part?.type === "text" && typeof part.text === "string" ? [part.text] : [];
+  }).join("");
+  return text || null;
+}
+
+async function drain(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let retained = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      if (retained >= MAX_STDERR_BYTES) continue;
+      const chunk = next.value.subarray(0, MAX_STDERR_BYTES - retained);
+      chunks.push(chunk);
+      retained += chunk.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const merged = new Uint8Array(retained);
+  let offset = 0;
+  for (const chunk of chunks) { merged.set(chunk, offset); offset += chunk.byteLength; }
+  return new TextDecoder().decode(merged);
+}
+
+export interface ClaudeRemoteWorkspaceRuntimeOptions {
+  command?: readonly string[];
+  env?: Record<string, string | undefined>;
+  version?: string;
+}
+
+export class ClaudeRemoteWorkspaceRuntimeFactory implements RemoteWorkspaceRuntimeFactory {
+  readonly profile = "claude" as const;
+
+  constructor(private readonly options: ClaudeRemoteWorkspaceRuntimeOptions = {}) {}
+
+  async available(): Promise<{ available: boolean; version?: string; reason?: string }> {
+    const command = this.options.command && this.options.command.length > 0
+      ? this.options.command[0]
+      : findExecutableOnPath("claude");
+    return command
+      ? { available: true, ...(this.options.version ? { version: this.options.version } : {}) }
+      : { available: false, reason: "Claude Code is not installed on this Hub." };
+  }
+
+  async start(options: Parameters<RemoteWorkspaceRuntimeFactory["start"]>[0]): Promise<RemoteWorkspaceRuntimeHandle> {
+    const configuredCommand = this.options.command && this.options.command.length > 0
+      ? [...this.options.command]
+      : null;
+    const executable = configuredCommand?.[0] ?? findExecutableOnPath("claude");
+    if (!executable) throw new Error("Claude Code is not installed on this Hub");
+    const commandPrefix = configuredCommand ?? [executable];
+    const isolation = mkdtempSync(join(tmpdir(), "ocx-remote-claude-"));
+    try {
+      chmodSync(isolation, 0o700);
+    } catch (error) {
+      removeRemoteWorkspaceIsolation(isolation);
+      throw error;
+    }
+    const threadId = options.resumeThreadId ?? randomUUID();
+    const bridge = (() => {
+      try {
+        return startRemoteWorkspaceToolBridge({
+          coordinator: options.coordinator,
+          threadId,
+          tools: options.tools,
+          onTool: tool => options.emit("tool", `Running ${tool} on ${options.deviceName}/${options.rootLabel}`),
+        });
+      } catch (error) {
+        removeRemoteWorkspaceIsolation(isolation);
+        throw error;
+      }
+    })();
+    const mcpPath = join(isolation, "mcp.json");
+    try {
+      writeFileSync(mcpPath, `${JSON.stringify({
+        mcpServers: {
+          ocx_remote_workspace: {
+            type: "http",
+            url: `${bridge.url}/mcp`,
+            headers: { Authorization: `Bearer ${bridge.token}` },
+          },
+        },
+      })}\n`, { mode: 0o600 });
+    } catch (error) {
+      await bridge.stop();
+      removeRemoteWorkspaceIsolation(isolation);
+      throw error;
+    }
+    let firstTurn = options.resumeThreadId === undefined;
+    let active: Bun.Subprocess<"pipe", "pipe", "pipe"> | null = null;
+    let stopped = false;
+    let stopOperation: Promise<void> | null = null;
+
+    const runPrompt = async (text: string): Promise<void> => {
+      if (stopped) throw new Error("Claude Remote Workspace session is stopped");
+      if (active) throw new Error("Claude Remote Workspace turn is already active");
+      const args = [
+        ...commandPrefix,
+        "-p",
+        "--input-format", "text",
+        "--output-format", "stream-json",
+        "--verbose",
+        "--strict-mcp-config",
+        "--mcp-config", mcpPath,
+        "--setting-sources", "",
+        "--tools", "",
+        "--allowedTools", "mcp__ocx_remote_workspace__*",
+        "--permission-mode", "dontAsk",
+        "--disable-slash-commands",
+        "--no-chrome",
+        "--system-prompt", remoteWorkspaceDeveloperInstructions(options.deviceName, options.tools),
+        firstTurn ? "--session-id" : "--resume",
+        threadId,
+      ];
+      const childEnv = { ...process.env, ...this.options.env };
+      const invocation = remoteWorkspaceProcessInvocation(args, { env: childEnv });
+      const child = Bun.spawn([invocation.file, ...invocation.args], {
+        cwd: isolation,
+        env: childEnv,
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        ...invocation.options,
+      });
+      active = child;
+      try {
+        child.stdin.write(text);
+        child.stdin.end();
+      } catch (error) {
+        await stopRemoteWorkspaceProcess(child);
+        if (active === child) active = null;
+        throw error;
+      }
+      const stderrPromise = drain(child.stderr);
+      const reader = child.stdout.getReader();
+      const decoder = new TextDecoder("utf-8", { fatal: true });
+      let buffer = "";
+      let emittedAssistant = false;
+      let resultError: string | null = null;
+      try {
+        while (true) {
+          const next = await reader.read();
+          if (next.done) break;
+          buffer += decoder.decode(next.value, { stream: true });
+          if (Buffer.byteLength(buffer, "utf8") > MAX_OUTPUT_LINE_BYTES && !buffer.includes("\n")) {
+            throw new Error("Claude Code output line is too large");
+          }
+          let newline = buffer.indexOf("\n");
+          while (newline >= 0) {
+            const line = buffer.slice(0, newline).replace(/\r$/, "");
+            buffer = buffer.slice(newline + 1);
+            if (Buffer.byteLength(line, "utf8") > MAX_OUTPUT_LINE_BYTES) throw new Error("Claude Code output line is too large");
+            if (line) {
+              const event = record(JSON.parse(line));
+              if (event?.type === "assistant") {
+                const answer = assistantText(event.message);
+                if (answer) { options.emit("assistant", answer); emittedAssistant = true; }
+              }
+              if (event?.type === "result") {
+                if (event.is_error === true) resultError = safeError(event.result, "Claude Code turn failed");
+                else if (!emittedAssistant && typeof event.result === "string" && event.result) {
+                  options.emit("assistant", event.result);
+                  emittedAssistant = true;
+                }
+              }
+            }
+            newline = buffer.indexOf("\n");
+          }
+        }
+        const exitCode = await child.exited;
+        const stderr = await stderrPromise;
+        if (resultError) throw new Error(resultError);
+        if (exitCode !== 0) throw new Error(safeError(stderr, `Claude Code exited with code ${exitCode}`));
+        firstTurn = false;
+      } catch (error) {
+        await stopRemoteWorkspaceProcess(child);
+        await stderrPromise.catch(() => "");
+        throw error;
+      } finally {
+        reader.releaseLock();
+        if (active === child) active = null;
+      }
+    };
+
+    return {
+      threadId,
+      canResume: () => !firstTurn,
+      prompt: runPrompt,
+      stop(): Promise<void> {
+        if (stopOperation) return stopOperation;
+        stopped = true;
+        const child = active;
+        stopOperation = runRemoteWorkspaceCleanupSteps([
+          async () => { if (child) await stopRemoteWorkspaceProcess(child); },
+          () => bridge.stop(),
+          () => removeRemoteWorkspaceIsolation(isolation),
+        ]);
+        return stopOperation;
+      },
+    };
+  }
+}