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

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

@@ -0,0 +1,382 @@
+import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { findExecutableOnPath } from "./workspace-executable";
+import {
+  remoteWorkspaceProcessInvocation,
+  removeRemoteWorkspaceIsolation,
+  runRemoteWorkspaceCleanupSteps,
+  stopRemoteWorkspaceProcess,
+  waitForRemoteWorkspaceProcessExit,
+} from "./workspace-process";
+import { startRemoteWorkspaceToolBridge } from "./workspace-tool-bridge";
+import { REMOTE_WORKSPACE_DYNAMIC_TOOLS } from "./workspace-tools";
+import type {
+  RemoteWorkspaceRuntimeFactory,
+  RemoteWorkspaceRuntimeHandle,
+} from "./workspace-sessions";
+
+const MAX_JSON_LINE_BYTES = 2 * 1024 * 1024;
+
+interface PendingResponse {
+  resolve(value: Record<string, unknown>): void;
+  reject(error: Error): void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+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 messageText(value: unknown): string | null {
+  const message = record(value);
+  if (!message || message.role !== "assistant" || !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;
+}
+
+function remotePiInstructions(deviceName: string, tools: readonly string[]): string {
+  const name = deviceName.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 120) || "remote executor";
+  const remoteTools = tools.map(tool => `remote_${tool}`).join(", ");
+  return [
+    `You operate only on the OpenCodex remote executor named ${JSON.stringify(name)}.`,
+    `Use only these tools for filesystem and command work: ${remoteTools}.`,
+    "The Hub working directory is an empty isolation boundary, not the user's project.",
+    "If a remote tool fails or the executor is offline, stop and report it. Never substitute local operations.",
+  ].join(" ");
+}
+
+function extensionSource(tools: readonly string[]): string {
+  const allowed = new Set(tools);
+  const definitions = REMOTE_WORKSPACE_DYNAMIC_TOOLS[0].tools.filter(tool => allowed.has(tool.name)).map(tool => ({
+    remoteName: `remote_${tool.name}`,
+    tool: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema,
+  }));
+  return `const definitions = ${JSON.stringify(definitions)};
+const endpoint = process.env.OCX_REMOTE_WORKSPACE_BRIDGE_URL;
+const token = process.env.OCX_REMOTE_WORKSPACE_BRIDGE_TOKEN;
+
+export default function registerRemoteWorkspace(pi) {
+  if (!endpoint || !token) throw new Error("Remote Workspace bridge is unavailable");
+  for (const definition of definitions) {
+    pi.registerTool({
+      name: definition.remoteName,
+      label: definition.remoteName,
+      description: definition.description,
+      parameters: definition.parameters,
+      async execute(_toolCallId, parameters, signal) {
+        const response = await fetch(endpoint + "/invoke", {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: "Bearer " + token },
+          body: JSON.stringify({ tool: definition.tool, arguments: parameters }),
+          signal,
+        });
+        const result = await response.json();
+        if (!response.ok || !result || result.success !== true) {
+          throw new Error(result && typeof result.text === "string" ? result.text : "Remote Workspace tool failed");
+        }
+        return { content: [{ type: "text", text: result.text }], details: { remote: true } };
+      },
+    });
+  }
+}
+`;
+}
+
+class PiRpcProcess {
+  private readonly pending = new Map<string, PendingResponse>();
+  private nextId = 0;
+  private closed = false;
+  private activeSettle: { resolve(): void; reject(error: Error): void } | null = null;
+
+  onEvent: ((event: Record<string, unknown>) => void) | null = null;
+
+  constructor(private readonly child: Bun.Subprocess<"pipe", "pipe", "pipe">) {
+    void this.read();
+    void this.drainStderr();
+    void child.exited.then(code => this.fail(new Error(`Pi RPC exited with code ${code}`)));
+  }
+
+  async command(type: string, fields: Record<string, unknown> = {}, timeoutMs = 15_000): Promise<Record<string, unknown>> {
+    if (this.closed) throw new Error("Pi RPC is closed");
+    const id = `ocx-${++this.nextId}`;
+    const result = new Promise<Record<string, unknown>>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Pi RPC ${type} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+    });
+    try {
+      this.send({ id, type, ...fields });
+    } catch (error) {
+      const pending = this.pending.get(id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+        pending.reject(error instanceof Error ? error : new Error("Pi RPC write failed"));
+      }
+    }
+    return result;
+  }
+
+  async prompt(message: string): Promise<void> {
+    if (this.activeSettle) throw new Error("Pi Remote Workspace turn is already active");
+    const settled = new Promise<void>((resolve, reject) => { this.activeSettle = { resolve, reject }; });
+    try {
+      const accepted = await this.command("prompt", { message });
+      if (accepted.success !== true) throw new Error(safeError(accepted.error, "Pi rejected the prompt"));
+      await settled;
+    } catch (error) {
+      this.activeSettle = null;
+      throw error;
+    }
+  }
+
+  async abort(): Promise<void> {
+    if (!this.activeSettle) return;
+    await this.command("abort", {}, 3_000).catch(() => {});
+  }
+
+  async close(): Promise<void> {
+    try {
+      if (!this.closed) {
+        try { this.child.stdin.end(); } catch { /* already closed */ }
+      }
+      const graceful = await waitForRemoteWorkspaceProcessExit(this.child, 1_500);
+      if (!graceful) {
+        await stopRemoteWorkspaceProcess(this.child);
+      }
+    } finally {
+      // Active and pending RPC waiters cannot survive a failed process teardown.
+      this.fail(new Error("Pi Remote Workspace session closed"));
+    }
+  }
+
+  private send(value: Record<string, unknown>): void {
+    const line = `${JSON.stringify(value)}\n`;
+    if (Buffer.byteLength(line, "utf8") > MAX_JSON_LINE_BYTES) throw new Error("Pi RPC message is too large");
+    this.child.stdin.write(line);
+    this.child.stdin.flush();
+  }
+
+  private async read(): Promise<void> {
+    const reader = this.child.stdout.getReader();
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let buffer = "";
+    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_JSON_LINE_BYTES && !buffer.includes("\n")) {
+          throw new Error("Pi RPC 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_JSON_LINE_BYTES) throw new Error("Pi RPC output line is too large");
+          if (line) {
+            const event = record(JSON.parse(line));
+            if (!event) throw new Error("invalid Pi RPC event");
+            this.receive(event);
+          }
+          newline = buffer.indexOf("\n");
+        }
+      }
+    } catch (error) {
+      void stopRemoteWorkspaceProcess(this.child).catch(() => {});
+      this.fail(new Error(safeError(error, "Pi RPC output failed")));
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  private async drainStderr(): Promise<void> {
+    const reader = this.child.stderr.getReader();
+    try { while (!(await reader.read()).done) { /* drain without retaining secrets */ } }
+    catch { /* stdout/exit code owns the failure */ }
+    finally { reader.releaseLock(); }
+  }
+
+  private receive(event: Record<string, unknown>): void {
+    if (event.type === "response" && typeof event.id === "string") {
+      const pending = this.pending.get(event.id);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(event.id);
+      pending.resolve(event);
+      return;
+    }
+    if (event.type === "agent_settled") {
+      const active = this.activeSettle;
+      this.activeSettle = null;
+      active?.resolve();
+    }
+    if (event.type === "extension_error") {
+      const active = this.activeSettle;
+      this.activeSettle = null;
+      active?.reject(new Error(safeError(event.error, "Pi Remote Workspace extension failed")));
+    }
+    this.onEvent?.(event);
+  }
+
+  private fail(error: Error): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    const active = this.activeSettle;
+    this.activeSettle = null;
+    active?.reject(error);
+  }
+}
+
+export interface PiRemoteWorkspaceRuntimeOptions {
+  command?: readonly string[];
+  env?: Record<string, string | undefined>;
+  version?: string;
+}
+
+export class PiRemoteWorkspaceRuntimeFactory implements RemoteWorkspaceRuntimeFactory {
+  readonly profile = "pi" as const;
+
+  constructor(private readonly options: PiRemoteWorkspaceRuntimeOptions = {}) {}
+
+  async available(): Promise<{ available: boolean; version?: string; reason?: string }> {
+    const command = this.options.command && this.options.command.length > 0
+      ? this.options.command[0]
+      : findExecutableOnPath("pi");
+    return command
+      ? { available: true, ...(this.options.version ? { version: this.options.version } : {}) }
+      : { available: false, reason: "Pi 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("pi");
+    if (!executable) throw new Error("Pi is not installed on this Hub");
+    const commandPrefix = configuredCommand ?? [executable];
+    const isolation = mkdtempSync(join(tmpdir(), "ocx-remote-pi-"));
+    try {
+      chmodSync(isolation, 0o700);
+    } catch (error) {
+      removeRemoteWorkspaceIsolation(isolation);
+      throw error;
+    }
+    const extensionPath = join(isolation, "remote-workspace-extension.js");
+    try {
+      writeFileSync(extensionPath, extensionSource(options.tools), { mode: 0o600 });
+    } 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 childEnv = {
+      ...process.env,
+      ...this.options.env,
+      OCX_REMOTE_WORKSPACE_BRIDGE_URL: bridge.url,
+      OCX_REMOTE_WORKSPACE_BRIDGE_TOKEN: bridge.token,
+    };
+    const invocation = remoteWorkspaceProcessInvocation([
+      ...commandPrefix,
+      "--mode", "rpc",
+      "--session-id", threadId,
+      "--name", `OCX Remote: ${options.deviceName}`,
+      "--no-builtin-tools",
+      "--no-extensions",
+      "--no-skills",
+      "--no-prompt-templates",
+      "--no-themes",
+      "--no-context-files",
+      "--no-approve",
+      "--extension", extensionPath,
+      "--tools", options.tools.map(tool => `remote_${tool}`).join(","),
+      "--system-prompt", remotePiInstructions(options.deviceName, options.tools),
+    ], { env: childEnv });
+    let child: Bun.Subprocess<"pipe", "pipe", "pipe">;
+    try {
+      child = Bun.spawn([invocation.file, ...invocation.args], {
+        cwd: isolation,
+        env: childEnv,
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        ...invocation.options,
+      });
+    } catch (error) {
+      await bridge.stop();
+      removeRemoteWorkspaceIsolation(isolation);
+      throw error;
+    }
+    const rpc = new PiRpcProcess(child);
+    rpc.onEvent = event => {
+      if (event.type === "message_end") {
+        const text = messageText(event.message);
+        if (text) options.emit("assistant", text);
+      }
+      if (event.type === "tool_execution_start" && typeof event.toolName === "string") {
+        options.emit("tool", `Pi requested ${event.toolName}`);
+      }
+    };
+    try {
+      const state = await rpc.command("get_state");
+      if (state.success !== true) throw new Error(safeError(state.error, "Pi RPC failed to initialize"));
+    } catch (error) {
+      await rpc.close().catch(() => {});
+      await bridge.stop();
+      removeRemoteWorkspaceIsolation(isolation);
+      throw error;
+    }
+    let stopped = false;
+    let stopOperation: Promise<void> | null = null;
+    return {
+      threadId,
+      prompt: text => rpc.prompt(text),
+      stop(): Promise<void> {
+        if (stopOperation) return stopOperation;
+        stopped = true;
+        stopOperation = runRemoteWorkspaceCleanupSteps([
+          () => rpc.abort(),
+          () => rpc.close(),
+          () => bridge.stop(),
+          () => removeRemoteWorkspaceIsolation(isolation),
+        ]);
+        return stopOperation;
+      },
+    };
+  }
+}

package/src/remote-control/workspace-process.ts

@@ -0,0 +1,129 @@
+import { execFileSync } from "node:child_process";
+import { rmSync } from "node:fs";
+import { commandInvocation, type SpawnInvocation } from "../lib/win-exec";
+import { resolveTrustedWindowsTaskkillExe } from "../lib/windows-elevation";
+
+export interface RemoteWorkspaceProcessInvocationOptions {
+  platform?: NodeJS.Platform;
+  env?: Record<string, string | undefined>;
+}
+
+/**
+ * Preserve argv boundaries on Unix and route Windows npm `.cmd`/`.bat` shims through the
+ * repository's audited ComSpec escaping. `shell: true` is deliberately never used.
+ */
+export function remoteWorkspaceProcessInvocation(
+  command: readonly string[],
+  options: RemoteWorkspaceProcessInvocationOptions = {},
+): SpawnInvocation {
+  if (command.length < 1 || !command[0]) throw new Error("remote workspace process command is empty");
+  return commandInvocation(
+    command[0],
+    command.slice(1),
+    options.platform ?? process.platform,
+    { env: options.env ?? process.env },
+  );
+}
+
+export interface RemoteWorkspaceOwnedProcess {
+  pid: number;
+  exitCode: number | null;
+  exited: Promise<number>;
+  kill(signal?: number | NodeJS.Signals): void;
+}
+
+export interface StopRemoteWorkspaceProcessOptions {
+  platform?: NodeJS.Platform;
+  taskkillPath?: string;
+  execFile?: (file: string, args: readonly string[]) => void;
+  waitMs?: number;
+}
+
+export async function waitForRemoteWorkspaceProcessExit(
+  child: RemoteWorkspaceOwnedProcess,
+  waitMs: number,
+): Promise<boolean> {
+  if (!Number.isSafeInteger(waitMs) || waitMs < 1) throw new Error("invalid remote workspace process wait");
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    return await Promise.race([
+      child.exited.then(() => true, () => true),
+      new Promise<boolean>(resolve => { timer = setTimeout(() => resolve(false), waitMs); }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+/** Run every owned-resource cleanup step and report the first failure only after all were attempted. */
+export async function runRemoteWorkspaceCleanupSteps(
+  steps: readonly (() => void | Promise<void>)[],
+): Promise<void> {
+  let failed = false;
+  let firstFailure: unknown;
+  for (const step of steps) {
+    try {
+      await step();
+    } catch (error) {
+      if (!failed) firstFailure = error;
+      failed = true;
+    }
+  }
+  if (failed) {
+    throw firstFailure instanceof Error
+      ? firstFailure
+      : new Error("remote workspace cleanup failed");
+  }
+}
+
+/** Stop only the process OCX spawned; Windows must include its `.cmd` descendant tree. */
+export async function stopRemoteWorkspaceProcess(
+  child: RemoteWorkspaceOwnedProcess,
+  options: StopRemoteWorkspaceProcessOptions = {},
+): Promise<void> {
+  if (child.exitCode !== null) return;
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    const exec = options.execFile ?? ((file: string, args: readonly string[]) => {
+      execFileSync(file, [...args], { stdio: "ignore", timeout: 5_000, windowsHide: true });
+    });
+    try {
+      exec(options.taskkillPath ?? resolveTrustedWindowsTaskkillExe(), ["/PID", String(child.pid), "/T", "/F"]);
+    } catch {
+      try { child.kill(); } catch { /* child already exited */ }
+    }
+    if (!await waitForRemoteWorkspaceProcessExit(child, options.waitMs ?? 1_500)) {
+      throw new Error("remote workspace Windows process tree did not exit");
+    }
+  } else {
+    try { child.kill("SIGTERM"); } catch { /* child already exited */ }
+    const exited = await waitForRemoteWorkspaceProcessExit(child, options.waitMs ?? 1_500);
+    if (!exited) {
+      try { child.kill("SIGKILL"); } catch { /* child already exited */ }
+      if (!await waitForRemoteWorkspaceProcessExit(child, options.waitMs ?? 1_500)) {
+        throw new Error("remote workspace process did not exit after SIGKILL");
+      }
+    }
+  }
+}
+
+/** Windows AV/indexers can retain just-exited CLI files briefly; use Node's bounded retry. */
+export function removeRemoteWorkspaceIsolation(path: string): void {
+  rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 });
+}
+
+/**
+ * [Decision Log]
+ * - 목적과 의도: Make Hub-owned Codex, Claude Code, and Pi processes start and stop identically
+ *   across Linux, macOS, and Windows without leaving npm-shim descendants behind.
+ * - 기존 구현 및 제약 조건: Unix can spawn executable scripts directly. Windows npm exposes
+ *   `.cmd` files that Bun cannot safely launch shell-less, and killing cmd.exe alone can orphan Node.
+ * - 검토한 주요 대안: `shell: true`, three runtime-specific wrappers, direct `.cmd` spawn, or the
+ *   repository's existing escaped ComSpec invocation plus trusted System32 taskkill.
+ * - 선택한 방식: Share one launcher and one owned-process stop helper across all three runtimes.
+ * - 다른 대안 대신 이 방식을 선택한 이유: It preserves exact argv boundaries, avoids a PATH-
+ *   resolved shell/taskkill hijack, and matches already-tested OpenCodex Windows behavior.
+ * - 장점, 단점 및 영향: Windows npm installs work and stop cleanly. Windows stop is necessarily
+ *   forceful because its normal process kill is already forceful; Unix gets a graceful SIGTERM
+ *   window and then a bounded SIGKILL fallback so an ignoring child cannot outlive the session.
+ */