agent-anywhere-gateway 0.1.0

package/src/runtimes/claude-code-runtime.js

@@ -0,0 +1,984 @@
+const fs = require("node:fs");
+const crypto = require("node:crypto");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { buildCapabilities } = require("../shared/capabilities");
+const { parseAllowedRoots, resolveProjectPath } = require("../shared/path-policy");
+const {
+  normalizeClaudeEffort,
+  resolveClaudeExecutable
+} = require("./claude-code-headless-runtime");
+
+const DEFAULT_CLAUDE_MODELS = [
+  "sonnet",
+  "opus",
+  "claude-sonnet-4-6",
+  "claude-opus-4-5"
+];
+
+const DEFAULT_READY_TIMEOUT_MS = 45_000;
+const DEFAULT_TURN_TIMEOUT_MS = 5 * 60_000;
+const TOOL_PROGRESS_NAMES = new Set(["Read", "Grep", "Glob", "LS"]);
+const CLAUDE_SESSION_ID_SUPPORT_CACHE = new Map();
+
+function remoteControlSandboxFlag(settings = {}) {
+  return settings.mode === "full-access" ? "--no-sandbox" : "--sandbox";
+}
+
+function claudePermissionMode(settings = {}) {
+  if (settings.mode === "full-access") return "bypassPermissions";
+  if (settings.mode === "auto-review") return "auto";
+  if (settings.approval_policy === "never") return "dontAsk";
+  return "default";
+}
+
+function remoteControlSessionName({ session = {}, project = {}, message = "" } = {}) {
+  if (session.title) {
+    return String(session.title);
+  }
+  const projectName = project.path ? project.path.split(/[\\/]/).filter(Boolean).pop() : "";
+  if (projectName) {
+    return `Agent Anywhere - ${projectName}`;
+  }
+  const text = String(message || "").trim();
+  if (text) {
+    return `Agent Anywhere - ${text.slice(0, 48)}`;
+  }
+  return "Agent Anywhere";
+}
+
+function buildClaudeRemoteControlArgs({
+  session,
+  project,
+  message,
+  settings = {},
+  sessionId,
+  useSessionId = false
+} = {}) {
+  const args = [
+    "--remote-control",
+    remoteControlSessionName({ session, project, message }),
+    "--permission-mode",
+    claudePermissionMode(settings)
+  ];
+  if (settings.model) {
+    args.push("--model", settings.model);
+  }
+  if (settings.reasoning_effort) {
+    args.push("--effort", normalizeClaudeEffort(settings.reasoning_effort));
+  }
+  if (useSessionId && sessionId) {
+    args.push("--session-id", sessionId);
+  }
+  return args;
+}
+
+function stripAnsi(text) {
+  return String(text || "")
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "")
+    .replace(/\x1b[>=<][ -~]?/g, "");
+}
+
+function extractRemoteControlUrl(text) {
+  const match = stripAnsi(text).match(/https:\/\/claude\.ai\/code[^\s)'"]*/);
+  return match ? match[0] : null;
+}
+
+function shouldConfirmRemoteControl(text) {
+  return /Enable Remote Control\?\s*\(y\/n\)/i.test(stripAnsi(text));
+}
+
+function hasConcreteClaudeSessionId(session = {}) {
+  return Boolean(session.runtime_session_id) &&
+    !String(session.runtime_session_id).startsWith("claude-remote-control:");
+}
+
+function remoteControlRuntimeSessionId(session = {}, { generate = false } = {}) {
+  if (hasConcreteClaudeSessionId(session)) {
+    return session.runtime_session_id;
+  }
+  if (generate) {
+    return crypto.randomUUID();
+  }
+  return session.runtime_session_id || `claude-remote-control:${session.id || Date.now()}`;
+}
+
+function supportsRemoteControlSessionId(claudePath, {
+  env = process.env,
+  spawnSyncImpl = spawnSync
+} = {}) {
+  if (env.AGENT_ANYWHERE_CLAUDE_DISABLE_SESSION_ID === "1") {
+    return false;
+  }
+  if (CLAUDE_SESSION_ID_SUPPORT_CACHE.has(claudePath)) {
+    return CLAUDE_SESSION_ID_SUPPORT_CACHE.get(claudePath);
+  }
+  let supported = false;
+  try {
+    const result = spawnSyncImpl(claudePath, ["--help"], {
+      encoding: "utf8",
+      env,
+      timeout: 5000
+    });
+    const output = `${result.stdout || ""}\n${result.stderr || ""}`;
+    supported = /(?:^|\s)--session-id(?:\s|,|$)/.test(output) &&
+      /(?:^|\s)--remote-control(?:\s|,|$)/.test(output);
+  } catch {
+    supported = false;
+  }
+  CLAUDE_SESSION_ID_SUPPORT_CACHE.set(claudePath, supported);
+  return supported;
+}
+
+function commandOutput(result = {}) {
+  return stripAnsi(`${result.stdout || ""}\n${result.stderr || ""}`)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+function assertClaudeRemoteControlAvailable(claudePath, {
+  env = process.env,
+  spawnSyncImpl = spawnSync
+} = {}) {
+  if (env.AGENT_ANYWHERE_CLAUDE_SKIP_REMOTE_CONTROL_CHECK === "1") {
+    return;
+  }
+  let result;
+  try {
+    result = spawnSyncImpl(claudePath, ["--help"], {
+      encoding: "utf8",
+      env,
+      timeout: 5000
+    });
+  } catch (cause) {
+    const error = new Error(`Claude Remote Control 预检失败：${cause?.message || cause}`);
+    error.cause = cause;
+    throw error;
+  }
+  const output = commandOutput(result);
+  if (result.error || result.status !== 0 || result.signal) {
+    const hint = output || result.error?.message || `exit=${result.status ?? "unknown"} signal=${result.signal || "none"}`;
+    const error = new Error(
+      `Claude Remote Control 预检失败：${hint}\n请确认服务进程使用的 Claude CLI 可正常运行。`
+    );
+    error.details = {
+      status: result.status,
+      signal: result.signal || null,
+      output
+    };
+    throw error;
+  }
+  if (!/(?:^|\s)--remote-control(?:\s|,|$)/.test(output)) {
+    const error = new Error(
+      "Claude Remote Control 不可用：当前 Claude CLI 不支持 --remote-control。\n请确认服务进程使用的是支持 Remote Control 的 Claude Code 版本。"
+    );
+    error.details = { output };
+    throw error;
+  }
+}
+
+function truthyEnv(value) {
+  return /^(1|true|yes|on)$/i.test(String(value || "").trim());
+}
+
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function claudeConfigPath(env = process.env) {
+  return env.CLAUDE_CONFIG_PATH || path.join(os.homedir(), ".claude.json");
+}
+
+function ensureClaudeWorkspaceTrusted(projectPath, {
+  configPath = claudeConfigPath(),
+  env = process.env,
+  fsImpl = fs
+} = {}) {
+  if (!truthyEnv(env.AGENT_ANYWHERE_CLAUDE_AUTO_TRUST) || !projectPath) {
+    return false;
+  }
+
+  const allowedRoots = parseAllowedRoots(env.AGENT_ANYWHERE_ALLOWED_ROOTS);
+  const resolvedProjectPath = resolveProjectPath(projectPath, allowedRoots);
+  let config = {};
+  if (fsImpl.existsSync(configPath)) {
+    config = JSON.parse(fsImpl.readFileSync(configPath, "utf8"));
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    config = {};
+  }
+  if (!config.projects || typeof config.projects !== "object" || Array.isArray(config.projects)) {
+    config.projects = {};
+  }
+
+  const existing = config.projects[resolvedProjectPath] &&
+    typeof config.projects[resolvedProjectPath] === "object" &&
+    !Array.isArray(config.projects[resolvedProjectPath])
+    ? config.projects[resolvedProjectPath]
+    : {};
+  if (existing.hasTrustDialogAccepted === true) {
+    return false;
+  }
+
+  config.projects[resolvedProjectPath] = {
+    allowedTools: [],
+    mcpContextUris: [],
+    mcpServers: {},
+    enabledMcpjsonServers: [],
+    disabledMcpjsonServers: [],
+    hasTrustDialogAccepted: true,
+    projectOnboardingSeenCount: 0,
+    hasClaudeMdExternalIncludesApproved: false,
+    hasClaudeMdExternalIncludesWarningShown: false,
+    ...existing,
+    hasTrustDialogAccepted: true
+  };
+  fsImpl.mkdirSync(path.dirname(configPath), { recursive: true });
+  fsImpl.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  return true;
+}
+
+function claudeProjectKey(projectPath) {
+  return path.resolve(projectPath).split(path.sep).join("-") || "project";
+}
+
+function claudeProjectDir(projectPath, homeDir = os.homedir()) {
+  return path.join(homeDir, ".claude", "projects", claudeProjectKey(projectPath));
+}
+
+function listTranscriptFiles(projectPath, { homeDir = os.homedir(), fsImpl = fs } = {}) {
+  const dir = claudeProjectDir(projectPath, homeDir);
+  if (!fsImpl.existsSync(dir)) {
+    return [];
+  }
+  return fsImpl.readdirSync(dir)
+    .filter((name) => name.endsWith(".jsonl"))
+    .map((name) => path.join(dir, name))
+    .sort((left, right) => fsImpl.statSync(right).mtimeMs - fsImpl.statSync(left).mtimeMs);
+}
+
+function readTranscript(filePath, { fsImpl = fs } = {}) {
+  if (!filePath || !fsImpl.existsSync(filePath)) {
+    return [];
+  }
+  return fsImpl.readFileSync(filePath, "utf8")
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function transcriptFileSize(filePath, { fsImpl = fs } = {}) {
+  if (!filePath || !fsImpl.existsSync(filePath)) {
+    return 0;
+  }
+  return fsImpl.statSync(filePath).size;
+}
+
+function textFromClaudeContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return content?.text || "";
+  }
+  return content
+    .map((item) => typeof item === "string" ? item : item?.type === "text" ? item.text : "")
+    .filter(Boolean)
+    .join("\n");
+}
+
+function userPromptOf(event = {}) {
+  return textFromClaudeContent(event.message?.content).trim();
+}
+
+function assistantTextOf(event = {}) {
+  if (!event) {
+    return "";
+  }
+  if (event.type !== "assistant" || event.message?.role !== "assistant") {
+    return "";
+  }
+  return textFromClaudeContent(event.message.content).trim();
+}
+
+function isAssistantFinal(event = {}) {
+  const stopReason = event.message?.stop_reason;
+  return stopReason == null || stopReason === "end_turn" || stopReason === "stop_sequence";
+}
+
+function eventTimeMs(event = {}) {
+  const time = Date.parse(event.timestamp || "");
+  return Number.isFinite(time) ? time : 0;
+}
+
+function findTranscriptState(projectPath, { afterMs = 0, prompt, homeDir = os.homedir(), fsImpl = fs } = {}) {
+  const promptText = prompt == null ? "" : String(prompt).trim();
+  for (const filePath of listTranscriptFiles(projectPath, { homeDir, fsImpl })) {
+    const events = readTranscript(filePath, { fsImpl });
+    const bridge = [...events].reverse().find((event) => (
+      event.type === "system" &&
+      event.subtype === "bridge_status" &&
+      event.url &&
+      eventTimeMs(event) >= afterMs
+    ));
+    let userIndex = -1;
+    if (promptText) {
+      for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (
+          event.type === "user" &&
+          eventTimeMs(event) >= afterMs &&
+          userPromptOf(event) === promptText
+        ) {
+          userIndex = index;
+          break;
+        }
+      }
+    }
+    let assistant = null;
+    if (userIndex >= 0) {
+      assistant = events.slice(userIndex + 1).find((event) => (
+        assistantTextOf(event) &&
+        isAssistantFinal(event)
+      ));
+    }
+    if (!bridge && userIndex < 0 && !assistant) {
+      continue;
+    }
+    const sessionEvent = bridge || events[userIndex] || assistant || events.find((event) => event.sessionId);
+    const sessionId = sessionEvent?.sessionId || path.basename(filePath, ".jsonl");
+    return {
+      filePath,
+      sessionId,
+      url: bridge?.url || null,
+      assistantText: assistantTextOf(assistant)
+    };
+  }
+  return { filePath: null, sessionId: null, url: null, assistantText: "" };
+}
+
+function findTranscriptBinding(projectPath, {
+  afterMs = 0,
+  expectedSessionId,
+  homeDir = os.homedir(),
+  fsImpl = fs
+} = {}) {
+  for (const filePath of listTranscriptFiles(projectPath, { homeDir, fsImpl })) {
+    const events = readTranscript(filePath, { fsImpl });
+    const bridge = [...events].reverse().find((event) => {
+      if (
+        event.type !== "system" ||
+        event.subtype !== "bridge_status" ||
+        !event.url ||
+        eventTimeMs(event) < afterMs
+      ) {
+        return false;
+      }
+      return !expectedSessionId || event.sessionId === expectedSessionId;
+    });
+    if (!bridge) {
+      continue;
+    }
+    return {
+      filePath,
+      sessionId: bridge.sessionId || path.basename(filePath, ".jsonl"),
+      url: bridge.url || null,
+      offset: transcriptFileSize(filePath, { fsImpl })
+    };
+  }
+  return { filePath: null, sessionId: null, url: null, offset: 0 };
+}
+
+class TranscriptTail {
+  constructor({ filePath, offset = 0, fsImpl = fs }) {
+    this.filePath = filePath;
+    this.offset = offset;
+    this.fsImpl = fsImpl;
+  }
+
+  readNewEvents() {
+    if (!this.filePath || !this.fsImpl.existsSync(this.filePath)) {
+      return [];
+    }
+    const size = this.fsImpl.statSync(this.filePath).size;
+    if (size <= this.offset) {
+      return [];
+    }
+    const fd = this.fsImpl.openSync(this.filePath, "r");
+    try {
+      const chunk = Buffer.alloc(size - this.offset);
+      const bytesRead = this.fsImpl.readSync(fd, chunk, 0, chunk.length, this.offset);
+      const buffer = chunk.subarray(0, bytesRead);
+      const lastNewline = buffer.lastIndexOf(0x0a);
+      if (lastNewline < 0) {
+        return [];
+      }
+      const consumed = buffer.subarray(0, lastNewline + 1);
+      this.offset += consumed.length;
+      return consumed.toString("utf8")
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean);
+    } finally {
+      this.fsImpl.closeSync(fd);
+    }
+  }
+}
+
+function renderClaudeValue(value) {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => renderClaudeValue(item)).filter(Boolean).join("\n");
+  }
+  if (typeof value === "object") {
+    if (typeof value.text === "string") {
+      return value.text;
+    }
+    if (Array.isArray(value.content)) {
+      return renderClaudeValue(value.content);
+    }
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+
+function claudeContentBlocks(content) {
+  if (Array.isArray(content)) {
+    return content;
+  }
+  if (content === undefined || content === null) {
+    return [];
+  }
+  return [{ type: "text", text: String(content) }];
+}
+
+function toolProgressMessage(block = {}) {
+  if (!TOOL_PROGRESS_NAMES.has(block.name)) {
+    return null;
+  }
+  const input = block.input || {};
+  if (block.name === "Read" && input.file_path) {
+    return `读取文件：${input.file_path}`;
+  }
+  if (block.name === "Grep" && input.pattern) {
+    return `搜索文本：${input.pattern}`;
+  }
+  if (block.name === "Glob" && input.pattern) {
+    return `匹配文件：${input.pattern}`;
+  }
+  if (block.name === "LS" && input.path) {
+    return `列出目录：${input.path}`;
+  }
+  return `执行工具：${block.name}`;
+}
+
+function convertTranscriptEvent(event = {}, state = {}) {
+  if (state.sessionId && event.sessionId && event.sessionId !== state.sessionId) {
+    return [];
+  }
+
+  const events = [];
+  if (!state.seenPrompt) {
+    if (event.type === "user" && userPromptOf(event) === state.prompt) {
+      state.seenPrompt = true;
+    }
+    return events;
+  }
+
+  if (event.type === "assistant" && event.message?.role === "assistant") {
+    const final = isAssistantFinal(event);
+    for (const block of claudeContentBlocks(event.message.content)) {
+      if (block?.type === "text" && block.text) {
+        if (final && !state.emittedFinalText) {
+          state.emittedFinalText = true;
+          events.push({ type: "delta", payload: { text: block.text } });
+        } else if (!final) {
+          events.push({ type: "activity", payload: { message: block.text, kind: "status" } });
+        }
+      } else if (block?.type === "tool_use") {
+        if (!state.seenToolUseIds) {
+          state.seenToolUseIds = new Set();
+        }
+        if (!block.id || !state.seenToolUseIds.has(block.id)) {
+          if (block.id) {
+            state.seenToolUseIds.add(block.id);
+          }
+          events.push({
+            type: "tool_use",
+            payload: {
+              tool_name: block.name || "tool",
+              tool_input: block.input || {},
+              tool_use_id: block.id || null
+            }
+          });
+          const message = toolProgressMessage(block);
+          if (message) {
+            events.push({
+              type: "activity",
+              payload: {
+                message,
+                kind: "tool_progress",
+                tool_use_id: block.id || null
+              }
+            });
+          }
+        }
+      }
+    }
+    if (event.message.usage) {
+      events.push({ type: "usage", payload: { usage: event.message.usage } });
+    }
+    if (final) {
+      state.completed = true;
+    }
+    return events;
+  }
+
+  if (event.type === "user") {
+    for (const block of claudeContentBlocks(event.message?.content)) {
+      if (block?.type === "tool_result") {
+        events.push({
+          type: "tool_result",
+          payload: {
+            tool_use_id: block.tool_use_id || null,
+            content: renderClaudeValue(block.content),
+            is_error: Boolean(block.is_error)
+          }
+        });
+      }
+    }
+    return events;
+  }
+
+  if (event.type === "result" && (event.usage || event.total_usage)) {
+    events.push({
+      type: "usage",
+      payload: {
+        usage: event.usage || event.total_usage,
+        cost_usd: event.cost_usd ?? event.total_cost_usd ?? null
+      }
+    });
+  }
+  return events;
+}
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForTranscriptState(predicate, {
+  timeoutMs,
+  intervalMs = 250,
+  readState
+}) {
+  const started = Date.now();
+  let latest = null;
+  while (Date.now() - started < timeoutMs) {
+    latest = readState();
+    if (predicate(latest)) {
+      return latest;
+    }
+    await wait(intervalMs);
+  }
+  const error = new Error("等待 Claude transcript 超时。");
+  error.latest = latest;
+  throw error;
+}
+
+function recentTerminalOutput(active = {}) {
+  return (active.recentOutput || [])
+    .map((line) => String(line || "").trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+function createClaudeStartupError(active = {}, latest = {}) {
+  const output = recentTerminalOutput(active);
+  const suffix = output ? `：${output}` : "：Claude 进程已退出，但未生成 transcript。";
+  const error = new Error(`Claude Remote Control 启动失败${suffix}`);
+  error.details = {
+    project_path: active.projectPath || "",
+    runtime_session_id: active.runtimeSessionId || null,
+    transcript_file: latest?.filePath || active.transcriptFile || null,
+    exit_code: active.exitCode ?? null,
+    exit_signal: active.exitSignal ?? null,
+    recent_output: active.recentOutput || []
+  };
+  return error;
+}
+
+function isRemoteControlTerminalReady(active = {}) {
+  return Boolean(active.url) || /(?:Remote Control active|\/remote-control is active)/i.test(recentTerminalOutput(active));
+}
+
+function ensureNodePtyExecutable() {
+  try {
+    const helperRoot = path.join(process.cwd(), "node_modules", "node-pty", "prebuilds");
+    if (!fs.existsSync(helperRoot)) {
+      return;
+    }
+    for (const platformDir of fs.readdirSync(helperRoot)) {
+      const helperPath = path.join(helperRoot, platformDir, "spawn-helper");
+      if (fs.existsSync(helperPath)) {
+        fs.chmodSync(helperPath, 0o755);
+      }
+    }
+  } catch {
+    // Best effort. node-pty will surface a concrete error if the helper cannot run.
+  }
+}
+
+function createPtyTerminal(command, args, options = {}) {
+  ensureNodePtyExecutable();
+  const pty = require("node-pty");
+  const terminal = pty.spawn(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    cols: 120,
+    rows: 32,
+    name: "xterm-256color"
+  });
+  return {
+    write: (text) => terminal.write(text),
+    kill: () => terminal.kill(),
+    onData: (handler) => terminal.onData(handler),
+    onExit: (handler) => terminal.onExit(({ exitCode, signal }) => handler(exitCode, signal)),
+    get killed() {
+      return false;
+    }
+  };
+}
+
+class ClaudeCodeRuntime {
+  static activeRemoteControls = new Map();
+
+  constructor({
+    claudePathOverride,
+    cliPath,
+    env = process.env,
+    fsImpl = fs,
+    homeDir = os.homedir(),
+    provider = "claude-code",
+    spawnSyncImpl = spawnSync,
+    terminalFactory = createPtyTerminal,
+    trustConfigPath
+  } = {}) {
+    this.provider = provider;
+    this.env = env;
+    this.fsImpl = fsImpl;
+    this.homeDir = homeDir;
+    this.trustConfigPath = trustConfigPath;
+    this.claudePathOverride = claudePathOverride || cliPath || env.CLAUDE_CODE_CLI_PATH || env.CLAUDE_CLI_PATH || undefined;
+    this.spawnSyncImpl = spawnSyncImpl;
+    this.terminalFactory = terminalFactory;
+  }
+
+  startRemoteControl({ session, project, message, settings }) {
+    const claudePath = resolveClaudeExecutable(this.claudePathOverride);
+    assertClaudeRemoteControlAvailable(claudePath, {
+      env: this.env,
+      spawnSyncImpl: this.spawnSyncImpl
+    });
+    const canFixSessionId = supportsRemoteControlSessionId(claudePath, {
+      env: this.env,
+      spawnSyncImpl: this.spawnSyncImpl
+    });
+    const requestedSessionId = canFixSessionId
+      ? remoteControlRuntimeSessionId(session, { generate: true })
+      : null;
+    const args = buildClaudeRemoteControlArgs({
+      session,
+      project,
+      message,
+      settings,
+      sessionId: requestedSessionId,
+      useSessionId: canFixSessionId
+    });
+    const title = remoteControlSessionName({ session, project, message });
+    const terminal = this.terminalFactory(claudePath, args, {
+      cwd: project.path || process.cwd(),
+      env: this.env
+    });
+    const active = {
+      cancelled: false,
+      exited: false,
+      expectedSessionId: requestedSessionId,
+      transcriptFile: null,
+      transcriptOffset: 0,
+      projectPath: project.path || "",
+      recentOutput: [],
+      runtimeSessionId: requestedSessionId || remoteControlRuntimeSessionId(session),
+      terminal,
+      title,
+      url: null,
+      exitCode: null,
+      exitSignal: null
+    };
+    terminal.onData((chunk) => {
+      const text = stripAnsi(chunk);
+      const line = text.trim();
+      if (line) {
+        active.recentOutput.push(line.slice(-1000));
+        if (active.recentOutput.length > 8) {
+          active.recentOutput.shift();
+        }
+      }
+      if (shouldConfirmRemoteControl(text)) {
+        terminal.write("y\r");
+      }
+      const url = extractRemoteControlUrl(text);
+      if (url) {
+        active.url = url;
+      }
+    });
+    terminal.onExit((exitCode, signal) => {
+      active.exited = true;
+      active.exitCode = exitCode;
+      active.exitSignal = signal;
+    });
+    return active;
+  }
+
+  async *run({ session = {}, project = {}, message = "", settings = {} } = {}) {
+    const key = session.id || remoteControlRuntimeSessionId(session);
+    let active = ClaudeCodeRuntime.activeRemoteControls.get(key);
+    const didAutoTrust = ensureClaudeWorkspaceTrusted(project.path, {
+      configPath: this.trustConfigPath,
+      env: this.env
+    });
+    const turnStartedAt = Date.now();
+
+    if (!active || active.exited) {
+      active = this.startRemoteControl({ session, project, message, settings });
+      ClaudeCodeRuntime.activeRemoteControls.set(key, active);
+      yield {
+        type: "activity",
+        payload: { message: `启动 Claude Remote Control：${project.path || ""}`, kind: "status" }
+      };
+      if (didAutoTrust) {
+        yield {
+          type: "activity",
+          payload: { message: `已自动信任 Claude 工作区：${project.path}`, kind: "status" }
+        };
+      }
+      const ready = await waitForTranscriptState((state) => state.filePath || isRemoteControlTerminalReady(active), {
+        timeoutMs: positiveInteger(this.env.AGENT_ANYWHERE_CLAUDE_READY_TIMEOUT_MS, DEFAULT_READY_TIMEOUT_MS),
+        readState: () => {
+          const state = findTranscriptBinding(project.path, {
+            afterMs: turnStartedAt - 1000,
+            expectedSessionId: active.expectedSessionId,
+            homeDir: this.homeDir,
+            fsImpl: this.fsImpl
+          });
+          if (state.url) active.url = state.url;
+          if (state.sessionId) active.runtimeSessionId = state.sessionId;
+          if (state.filePath) active.transcriptFile = state.filePath;
+          if (state.offset) active.transcriptOffset = state.offset;
+          if (active.exited && !state.filePath && !isRemoteControlTerminalReady(active)) {
+            throw createClaudeStartupError(active, state);
+          }
+          return state;
+        }
+      });
+      active.url = active.url || ready.url;
+      active.runtimeSessionId = ready.sessionId || active.runtimeSessionId;
+      active.transcriptFile = ready.filePath || active.transcriptFile;
+      active.transcriptOffset = ready.offset || active.transcriptOffset || transcriptFileSize(active.transcriptFile, {
+        fsImpl: this.fsImpl
+      });
+      yield {
+        type: "runtime_session",
+        payload: {
+          runtime_session_id: active.runtimeSessionId,
+          working_directory: project.path || "",
+          title: active.title
+        }
+      };
+      if (active.url) {
+        yield {
+          type: "activity",
+          payload: { message: `Claude Remote Control 已连接：${active.url}`, kind: "status" }
+        };
+      }
+    } else {
+      yield {
+        type: "runtime_session",
+        payload: {
+          runtime_session_id: active.runtimeSessionId,
+          working_directory: active.projectPath,
+          title: active.title
+        }
+      };
+    }
+
+    const prompt = String(message || "").trim();
+    if (!prompt) {
+      yield { type: "complete", payload: { message: "Claude Remote Control 已连接。" } };
+      return;
+    }
+
+    const hadTranscriptBeforePrompt = Boolean(active.transcriptFile);
+    active.transcriptOffset = hadTranscriptBeforePrompt
+      ? transcriptFileSize(active.transcriptFile, { fsImpl: this.fsImpl })
+      : 0;
+    active.terminal.write(`${prompt}\r`);
+
+    if (!active.transcriptFile) {
+      const transcript = await waitForTranscriptState((state) => Boolean(state.filePath), {
+        timeoutMs: positiveInteger(this.env.AGENT_ANYWHERE_CLAUDE_READY_TIMEOUT_MS, DEFAULT_READY_TIMEOUT_MS),
+        readState: () => {
+          const state = findTranscriptState(project.path, {
+            afterMs: turnStartedAt - 1000,
+            prompt,
+            homeDir: this.homeDir,
+            fsImpl: this.fsImpl
+          });
+          if (state.url) active.url = state.url;
+          if (state.sessionId) active.runtimeSessionId = state.sessionId;
+          if (state.filePath) active.transcriptFile = state.filePath;
+          if (active.exited && !state.filePath) {
+            throw createClaudeStartupError(active, state);
+          }
+          return state;
+        }
+      });
+      active.url = active.url || transcript.url;
+      active.runtimeSessionId = transcript.sessionId || active.runtimeSessionId;
+      active.transcriptFile = transcript.filePath || active.transcriptFile;
+      active.transcriptOffset = 0;
+      yield {
+        type: "runtime_session",
+        payload: {
+          runtime_session_id: active.runtimeSessionId,
+          working_directory: active.projectPath,
+          title: active.title
+        }
+      };
+    }
+
+    const tail = new TranscriptTail({
+      filePath: active.transcriptFile,
+      offset: active.transcriptOffset,
+      fsImpl: this.fsImpl
+    });
+    const transcriptState = {
+      prompt,
+      sessionId: active.runtimeSessionId,
+      seenPrompt: false,
+      emittedFinalText: false,
+      completed: false,
+      seenToolUseIds: new Set()
+    };
+    const timeoutMs = positiveInteger(this.env.AGENT_ANYWHERE_CLAUDE_TURN_TIMEOUT_MS, DEFAULT_TURN_TIMEOUT_MS);
+    const waitStartedAt = Date.now();
+    while (Date.now() - waitStartedAt < timeoutMs) {
+      if (active.cancelled) {
+        yield { type: "cancelled", payload: { message: "Claude Remote Control 已取消。" } };
+        return;
+      }
+      for (const event of tail.readNewEvents()) {
+        if (event.url) active.url = event.url;
+        if (event.sessionId) {
+          active.runtimeSessionId = event.sessionId;
+          transcriptState.sessionId = event.sessionId;
+        }
+        for (const normalized of convertTranscriptEvent(event, transcriptState)) {
+          yield normalized;
+        }
+      }
+      active.transcriptOffset = tail.offset;
+      if (transcriptState.completed) {
+        yield {
+          type: "complete",
+          payload: { message: "Claude Remote Control 回合完成。" }
+        };
+        return;
+      }
+      if (active.exited) {
+        break;
+      }
+      await wait(250);
+    }
+
+    const error = new Error("等待 Claude Remote Control 回合完成超时。");
+    error.details = {
+      transcript_file: active.transcriptFile,
+      transcript_offset: active.transcriptOffset,
+      runtime_session_id: active.runtimeSessionId,
+      saw_prompt: transcriptState.seenPrompt,
+      recent_output: active.recentOutput
+    };
+    throw error;
+  }
+
+  async discoverCapabilities() {
+    return buildCapabilities(this.provider, {
+      models: DEFAULT_CLAUDE_MODELS,
+      default_model: "sonnet",
+      input_modalities: ["text"],
+      reasoning_efforts: ["medium"],
+      approval_policies: ["on-request"],
+      modes: ["default", "full-access"]
+    });
+  }
+
+  async cancelTurn({ session } = {}) {
+    const key = session?.id || session?.runtime_session_id;
+    const active = key ? ClaudeCodeRuntime.activeRemoteControls.get(key) : null;
+    if (!active) {
+      const error = new Error("没有可停止的 Claude Remote Control 进程。");
+      error.statusCode = 409;
+      throw error;
+    }
+    active.cancelled = true;
+    active.terminal.kill();
+    ClaudeCodeRuntime.activeRemoteControls.delete(key);
+    return {};
+  }
+}
+
+module.exports = {
+  ClaudeCodeRuntime,
+  assertClaudeRemoteControlAvailable,
+  buildClaudeRemoteControlArgs,
+  claudeProjectDir,
+  claudeProjectKey,
+  convertTranscriptEvent,
+  ensureClaudeWorkspaceTrusted,
+  extractRemoteControlUrl,
+  findTranscriptBinding,
+  findTranscriptState,
+  remoteControlSandboxFlag,
+  remoteControlSessionName,
+  shouldConfirmRemoteControl,
+  supportsRemoteControlSessionId,
+  textFromClaudeContent
+};