@xyagent/cli 1.0.0 → 1.1.1

package/src-ext/core/scanWorkspaces.mjs

@@ -11,6 +11,7 @@
 
 import crypto from "node:crypto";
 import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -22,6 +23,7 @@ const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 500;
 const HARD_TIMEOUT_MS = 5000;
 const GIT_BRANCH_TIMEOUT_MS = 200;
+const execFileAsync = promisify(execFile);
 
 // Runtime metadata — agentKind values must match dart stub ScannedAgentGroup.kind exactly.
 const RUNTIME_META = {
@@ -49,6 +51,11 @@ const RUNTIME_META = {
     tagline: "Agentlink 内置对话智能体",
     idPrefix: "hm",
   },
+  Qwen: { agentKind: "Qwen", emoji: "🌊", tagline: "Qwen CLI", idPrefix: "qw" },
+  Kimi: { agentKind: "Kimi", emoji: "🌙", tagline: "Kimi CLI", idPrefix: "km" },
+  CodeBuddy: { agentKind: "CodeBuddy", emoji: "🤖", tagline: "CodeBuddy", idPrefix: "cb" },
+  Cursor: { agentKind: "Cursor", emoji: "⌨️", tagline: "Cursor", idPrefix: "cu" },
+  OpenCode: { agentKind: "OpenCode", emoji: "🧩", tagline: "OpenCode", idPrefix: "oo" },
 };
 
 // runtimeKind string → RUNTIME_META key
@@ -58,6 +65,7 @@ const RUNTIME_KIND_MAP = {
   claude: "Claude Code",
   codex: "Codex",
   hermes: "Hermes",
+  qwen: "Qwen", kimi: "Kimi", codebuddy: "CodeBuddy", cursor: "Cursor", opencode: "OpenCode",
 };
 
 // ─── utility functions ───────────────────────────────────────────────────────
@@ -166,6 +174,7 @@ export async function readOpenClawWorkspaces({
   limit,
   includeBranch,
   workspaceRoot,
+  openclawHome,
 }) {
   const warnings = [];
 
@@ -174,7 +183,7 @@ export async function readOpenClawWorkspaces({
     dirs = [path.resolve(workspaceRoot)];
   } else {
     try {
-      dirs = resolveOpenClawAgentWorkspaceDirs();
+      dirs = readJsonlCwds(openclawHome ?? path.join(resolveOpenClawHomeDir(), "agents"));
     } catch (err) {
       warnings.push(`OpenClaw: failed to resolve workspace dirs: ${err.message}`);
       return { workspaces: [], warnings, truncated: false };
@@ -216,6 +225,29 @@ export async function readOpenClawWorkspaces({
   return { workspaces, warnings, truncated };
 }
 
+function readJsonlCwds(root) {
+  const found = new Set();
+  const visit = (dir) => {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const item = path.join(dir, entry.name);
+      if (entry.isDirectory()) visit(item);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try {
+          for (const line of fs.readFileSync(item, "utf8").split(/\r?\n/)) {
+            if (!line.trim()) continue;
+            const row = JSON.parse(line);
+            const cwd = row?.cwd ?? row?.message?.cwd ?? row?.context?.cwd;
+            if (typeof cwd === "string" && cwd) found.add(path.resolve(cwd));
+          }
+        } catch {}
+      }
+    }
+  };
+  visit(root);
+  return [...found];
+}
+
 // ─── Claude Code reader ───────────────────────────────────────────────────────
 
 /**
@@ -385,31 +417,19 @@ export async function readCodexWorkspaces({
   const cwdByPath = new Map(); // absolutePath → true (for dedupe)
 
   for (const dir of sessionDirs) {
-    let files;
-    try {
-      files = fs.readdirSync(dir);
-    } catch (err) {
-      if (err.code === "EACCES" || err.code === "EPERM") {
-        warnings.push(`Codex: permission denied reading ${dir}: ${err.message}`);
-      }
-      // ENOENT: dir doesn't exist — skip silently
-      continue;
-    }
-
-    for (const file of files) {
-      if (!file.endsWith(".jsonl")) continue;
-      const filePath = path.join(dir, file);
+    if (!fs.existsSync(dir)) continue;
+    for (const filePath of findFiles(dir, (name) => name.endsWith(".jsonl"))) {
       try {
         const content = fs.readFileSync(filePath, "utf8");
         const firstLine = content.split("\n")[0].trim();
         if (!firstLine) continue;
         const parsed = JSON.parse(firstLine);
-        const cwd = parsed?.cwd;
+        const cwd = parsed?.cwd ?? parsed?.payload?.cwd;
         if (typeof cwd === "string" && cwd) {
           cwdByPath.set(path.resolve(cwd.replace(/^~/, home)), true);
         }
       } catch (err) {
-        warnings.push(`Codex: failed to parse first line of ${file}: ${err.message}`);
+        warnings.push(`Codex: failed to parse session: ${err.message}`);
       }
     }
   }
@@ -714,7 +734,10 @@ export async function readHermesWorkspaces({
  */
 export async function scanWorkspacesByRuntime({ runtimeKind, gatewayId, params }) {
   const kind = normalizeRuntimeKind(runtimeKind);
-  const meta = RUNTIME_META[kind] ?? RUNTIME_META["OpenClaw"];
+  if (!kind) {
+    return { ok: true, agentKind: String(runtimeKind || ""), emoji: "", tagline: "", host: hostMeta(gatewayId), workspaces: [], truncated: false, scannedAt: new Date().toISOString(), warnings: [`unsupported runtime: ${runtimeKind}`] };
+  }
+  const meta = RUNTIME_META[kind];
   const limit = clampLimit(params?.limit ?? DEFAULT_LIMIT);
   const includeBranch = params?.includeBranch === true;
 
@@ -723,6 +746,9 @@ export async function scanWorkspacesByRuntime({ runtimeKind, gatewayId, params }
   if (params?.hermesProfilesRoot != null) {
     readerArgs.hermesProfilesRoot = params.hermesProfilesRoot;
   }
+  for (const key of ["root", "openclawHome", "hermesDbPath", "opencodeDbPath", "codexHome"]) {
+    if (params?.[key] != null) readerArgs[key] = params[key];
+  }
 
   // Wrap reader in 5s hard timeout
   const readerPromise = runReader(kind, readerArgs);
@@ -768,19 +794,24 @@ function clampLimit(raw) {
 }
 
 function normalizeRuntimeKind(kind) {
-  if (!kind) return "OpenClaw";
+  if (!kind) return null;
   const lower = String(kind).toLowerCase().trim();
-  return RUNTIME_KIND_MAP[lower] ?? "OpenClaw";
+  return RUNTIME_KIND_MAP[lower] ?? null;
 }
 
 async function runReader(kind, args) {
   try {
     switch (kind) {
       case "OpenClaw":    return await readOpenClawWorkspaces(args);
-      case "Claude Code": return await readClaudeWorkspaces(args);
+      case "Claude Code": return await readDirectoryNameWorkspaces(args, "Claude Code", path.join(os.homedir(), ".claude", "projects"), true);
       case "Codex":       return await readCodexWorkspaces(args);
-      case "Hermes":      return await readHermesWorkspaces(args);
-      default:            return await readOpenClawWorkspaces(args);
+      case "Hermes":      return args.hermesProfilesRoot ? await readHermesWorkspaces(args) : await readHermesDbWorkspaces(args);
+      case "Qwen":        return await readEncodedProjectWorkspaces(args, "Qwen", path.join(os.homedir(), ".qwen", "projects"));
+      case "Kimi":        return await readKimiWorkspaces(args);
+      case "CodeBuddy":   return await readCodeBuddyWorkspaces(args);
+      case "Cursor":      return await readCursorWorkspaces(args);
+      case "OpenCode":    return await readOpenCodeWorkspaces(args);
+      default:            return { workspaces: [], warnings: [`unsupported runtime: ${kind}`], truncated: false };
     }
   } catch (err) {
     // Permission errors degrade to warnings
@@ -791,6 +822,115 @@ async function runReader(kind, args) {
   }
 }
 
+async function workspaceEntries(paths, meta, limit, includeBranch) {
+  const selected = [...new Set(paths.map((p) => path.resolve(p)))].slice(0, clampLimit(limit));
+  const branches = await resolveBranches(selected, includeBranch);
+  return selected.map((absolutePath, i) => ({ id: pathToId(meta.idPrefix, absolutePath), name: path.basename(absolutePath), path: absolutePath, absolutePath, branch: branches[i], lastUsedAtMs: null }));
+}
+
+async function readProjectDirectoryWorkspaces({ limit, includeBranch, root }, kind, defaultRoot) {
+  const dir = root ?? defaultRoot; let entries = [];
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const paths = entries.filter((e) => e.isDirectory()).map((e) => path.join(dir, e.name));
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META[kind], limit, includeBranch), warnings: [], truncated: paths.length > clampLimit(limit) };
+}
+
+async function readDirectoryNameWorkspaces(args, kind, defaultRoot, decode) {
+  let entries = []; const root = args.root ?? defaultRoot;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const paths = entries.filter((e) => e.isDirectory()).map((e) => decode ? path.resolve("/" + e.name.replace(/^-/, "").replace(/-/g, path.sep)) : path.join(root, e.name));
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META[kind], args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+async function readEncodedProjectWorkspaces(args, kind, root) {
+  let entries = []; try { entries = fs.readdirSync(args.root ?? root, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const paths = entries.filter((e) => e.isDirectory()).map((e) => path.resolve("/" + e.name.replace(/^-/, "").replace(/-/g, path.sep)));
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META[kind], args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+function findFiles(root, predicate) {
+  const files = [];
+  const visit = (dir) => { let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; } for (const entry of entries) { const item = path.join(dir, entry.name); if (entry.isDirectory()) visit(item); else if (entry.isFile() && predicate(entry.name)) files.push(item); } };
+  visit(root); return files;
+}
+
+async function readKimiWorkspaces(args) {
+  const root = args.root ?? path.join(os.homedir(), ".kimi-code", "sessions");
+  const paths = [];
+  for (const file of findFiles(root, (name) => name === "state.json")) { try { const cwd = JSON.parse(fs.readFileSync(file, "utf8"))?.cwd; if (typeof cwd === "string" && cwd) paths.push(cwd); } catch {} }
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.Kimi, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+async function readCodeBuddyWorkspaces(args) {
+  const root = args.root ?? path.join(os.homedir(), ".codebuddy", "projects");
+  const paths = [];
+  for (const file of findFiles(root, (name) => name.endsWith(".jsonl"))) { try { for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) { const cwd = JSON.parse(line || "{}")?.cwd; if (typeof cwd === "string" && cwd) paths.push(cwd); } } catch {} }
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.CodeBuddy, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
+async function readCursorWorkspaces(args) {
+  const root = args.root ?? path.join(os.homedir(), ".cursor", "projects");
+  let entries = []; try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return { workspaces: [], warnings: [], truncated: false }; }
+  const projects = entries.filter((entry) =>
+    entry.isDirectory() && fs.existsSync(path.join(root, entry.name, "agent-transcripts")),
+  );
+  const paths = [];
+  let unresolvedCount = 0;
+  for (const project of projects) {
+    const resolved = resolveCursorProjectSlug(project.name);
+    if (resolved) paths.push(resolved);
+    else unresolvedCount += 1;
+  }
+  const warnings = unresolvedCount > 0
+    ? [`${unresolvedCount} Cursor project${unresolvedCount === 1 ? " was" : "s were"} skipped because ${unresolvedCount === 1 ? "its" : "their"} slug could not be resolved to an existing directory`]
+    : [];
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.Cursor, args.limit, args.includeBranch), warnings, truncated: paths.length > clampLimit(args.limit) };
+}
+
+// Cursor replaces path separators and punctuation (`/`, `-`, `_`, `.`) with
+// the same `-` in project directory names. That encoding is lossy: never turn
+// every dash back into `/`. Instead, walk the real directory tree from `/` and
+// accept a candidate only when every component exists on disk.
+const CURSOR_SLUG_JOINERS = ["-", "_", ".", ""];
+function resolveCursorProjectSlug(slug) {
+  const segments = String(slug ?? "").replace(/^-+/, "").split("-").filter(Boolean);
+  if (segments.length === 0) return null;
+
+  const walk = (base, index) => {
+    if (index >= segments.length) return isExistingDirectory(base) ? base : null;
+    for (let end = segments.length; end > index; end -= 1) {
+      const parts = segments.slice(index, end);
+      for (const joiner of CURSOR_SLUG_JOINERS) {
+        const candidate = path.join(base, parts.join(joiner));
+        if (!isExistingDirectory(candidate)) continue;
+        const resolved = walk(candidate, end);
+        if (resolved) return resolved;
+      }
+    }
+    return null;
+  };
+
+  return walk(path.parse(process.cwd()).root, 0);
+}
+
+function isExistingDirectory(candidate) {
+  try { return fs.statSync(candidate).isDirectory(); } catch { return false; }
+}
+
+async function readSqlitePaths(dbPath, sql) {
+  try { const { stdout } = await execFileAsync("sqlite3", [dbPath, "-noheader", "-separator", "\t", sql], { timeout: HARD_TIMEOUT_MS }); return stdout.split(/\r?\n/).filter(Boolean).map((line) => line.split("\t")[0]).filter(Boolean); } catch { return []; }
+}
+async function readHermesDbWorkspaces(args) {
+  const db = args.hermesDbPath ?? path.join(os.homedir(), ".hermes", "state.db");
+  const paths = await readSqlitePaths(db, "SELECT cwd FROM sessions WHERE cwd IS NOT NULL AND cwd != '' GROUP BY cwd ORDER BY COUNT(*) DESC");
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.Hermes, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+async function readOpenCodeWorkspaces(args) {
+  const db = args.opencodeDbPath ?? path.join(os.homedir(), ".local", "share", "opencode", "opencode.db");
+  const paths = await readSqlitePaths(db, "SELECT worktree FROM project WHERE worktree IS NOT NULL AND worktree != '' GROUP BY worktree ORDER BY MAX(time_updated) DESC");
+  return { workspaces: await workspaceEntries(paths, RUNTIME_META.OpenCode, args.limit, args.includeBranch), warnings: [], truncated: paths.length > clampLimit(args.limit) };
+}
+
 /**
  * Resolve OpenClaw home dir. Mirrors bin/agentlink resolveOpenClawHome():
  * OPENCLAW_HOME 环境变量优先，否则 <home>/.openclaw。

package/src-ext/core/unifiedDispatchHandler.mjs

@@ -265,7 +265,7 @@ export function createUnifiedDispatchHandler({
       return false; // not a dispatch request — let caller handle it
     }
 
-    const { thread_id, run_id, input, blocks = [], workspace_path } = request.request ?? {};
+    const { thread_id, run_id, input, blocks = [], workspace_path, resume_session_id } = request.request ?? {};
 
     // Idempotency check
     if (dispatchedRunIds.has(run_id)) {
@@ -352,6 +352,10 @@ export function createUnifiedDispatchHandler({
           input: effectiveInput,
           blocks: processedBlocks,
           workspace_path: workspace_path || null,
+          // relay only supplies this for the newest completed history import.
+          // Runtime adapters seed it only if their thread has no active local
+          // session, preventing later imported history from switching context.
+          resume_session_id: resume_session_id || null,
           // relay 信封顶层 sessionKey（App 侧 abort RPC 用它定位要杀的 run）
           session_key: request.sessionKey || null,
           onChunk: async (chunk) => {
@@ -423,8 +427,11 @@ export function createUnifiedDispatchHandler({
         });
       }
       try {
+        const failureCode = err?.code === "workspace_context_unavailable"
+          ? "workspace_context_unavailable"
+          : "runtime.crash";
         await producer.postEvents([
-          buildRunFailed(run_id, "runtime.crash", String(err?.message || err)),
+          buildRunFailed(run_id, failureCode, String(err?.message || err)),
         ]);
       } catch (postErr) {
         log.error("dispatch.post_failed.error", "failed to post run.failed envelope", {

package/src-ext/postinstall.mjs

@@ -0,0 +1,14 @@
+// npm postinstall 入口（openspec m-20260817-windows-runtime-parity 追加修复）。
+//
+// 🔴 为什么是独立文件而不是 package.json 里的 `node -e '...'` 内联：
+// 内联版用单引号包 JS 代码，Windows 上 npm 跑生命周期脚本走 cmd.exe，
+// 单引号不是引号 —— 代码带着字面引号被 node 当模块路径解析，postinstall
+// 必然 exit 1，进而把整个 `npm i -g @xyagent/cli` 判为安装失败
+// （2026-08-18 Windows 真机复现；macOS 的 sh 认单引号所以从未暴露）。
+// 脚本文件零引号问题，且放在 src-ext/ 下（package.json files 白名单已包含）。
+//
+// 行为与原内联版完全一致：best-effort 重启守护进程，任何失败都吞掉 ——
+// postinstall 绝不能因此把安装本身搞失败。
+import("./core/daemonRestart.mjs")
+  .then((m) => m.kickstartDaemons())
+  .catch(() => {});

package/src-ext/runtime/_shared/bridgedSessionLedger.mjs

@@ -0,0 +1,60 @@
+// 桥接会话账本 —— 「重复导入」问题的方案 ①（打标侧）。
+//
+// 背景：经 AgentLink 桥接的实时对话会同时被 CLI 记进本机会话文件，且该文件与
+// 用户手动 CLI 会话**无任何可区分标记**（实测 CodeBuddy 两类文件的
+// `providerData.agent` 均为 "cli"）。桌面端「重新导入历史」会把已经通过实时
+// 链路存在于线程里的同一段话再追加一遍。
+//
+// 方案：bridge 每捕获到一个 CLI 原生 session id（onSession / resume_hint），
+// 就把 (runtime, session_id) 追加进本账本；桌面端导入扫描时读它，命中的
+// 会话文件整个跳过 —— 那段对话已经在线程里了。
+//
+// 三条口径：
+//   1. 账本位置**固定** `~/.agentlink/bridged-cli-sessions.ndjson`，不跟 bridge
+//      的 --debug state 走：CLI 本机历史本来就不分 debug，账本也不该分。
+//   2. 打标是 best-effort：写失败（磁盘满 / 权限）静默吞掉，绝不影响对话链路；
+//      漏标的代价只是「那一条会话可能被重复导入」，远小于打断实时对话。
+//   3. 只追加不清理：账本行是 40 字节量级，一万条才 400KB，不值得引入压缩逻辑。
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** 测试用环境变量：覆盖账本路径（生产不设，走 ~/.agentlink 固定位置）。 */
+const LEDGER_PATH_ENV = "AGENTLINK_BRIDGED_LEDGER";
+
+/** 进程内已记录的 session id —— 同一会话每轮对话都会报同一个 id，只落一行。 */
+const recorded = new Set();
+
+export function bridgedSessionLedgerPath() {
+  const override = process.env[LEDGER_PATH_ENV];
+  if (override) return override;
+  return path.join(os.homedir(), ".agentlink", "bridged-cli-sessions.ndjson");
+}
+
+/**
+ * 记录一个经桥接产生的 CLI 原生 session id。幂等（进程内去重 + 跨进程靠
+ * 桌面端读取时按 session_id 建集合，重复行无害）。
+ */
+export function recordBridgedSession(runtime, sessionId) {
+  const id = String(sessionId || "").trim();
+  if (!id) return;
+  const key = `${runtime}
${id}`;
+  if (recorded.has(key)) return;
+  recorded.add(key);
+  try {
+    const ledger = bridgedSessionLedgerPath();
+    fs.mkdirSync(path.dirname(ledger), { recursive: true });
+    fs.appendFileSync(
+      ledger,
+      `${JSON.stringify({ runtime: String(runtime || ""), session_id: id, recorded_at: new Date().toISOString() })}\n`,
+    );
+  } catch {
+    // best-effort：见文件头口径 2。
+  }
+}
+
+/** 测试用：清空进程内去重缓存（账本文件由测试自己管理）。 */
+export function resetBridgedSessionCacheForTest() {
+  recorded.clear();
+}

package/src-ext/runtime/_shared/claudeSchemaEvent.mjs

@@ -0,0 +1,49 @@
+/**
+ * Qwen Code 与 CodeBuddy 的 stream-json 都采用 Claude 风格消息信封：
+ * system(init) → assistant/user 消息 → result。这里直接翻成 unified chunks，
+ * 避免把两套官方兼容协议各写一遍。
+ */
+export function translateClaudeSchemaEvent(event) {
+  if (!event || typeof event !== "object") return null;
+  if (event.type === "result") {
+    if (event.is_error || event.subtype === "error") {
+      const message = event.error?.message || event.result || "runtime failed";
+      return { event: "response.failed", error: { message: String(message) } };
+    }
+    return { event: "response.completed" };
+  }
+
+  const message = event.message;
+  const blocks = Array.isArray(message?.content) ? message.content : [];
+  const parent = event.parent_tool_use_id || null;
+  const withParent = (chunk) => parent ? { ...chunk, parent_tool_use_id: parent } : chunk;
+  const chunks = [];
+
+  if (event.type === "assistant") {
+    for (const block of blocks) {
+      if (block?.type === "text" && block.text) {
+        chunks.push(withParent({ event: "response.output_text.delta", delta: String(block.text) }));
+      } else if ((block?.type === "thinking" || block?.type === "reasoning") && block.text) {
+        chunks.push(withParent({ event: "response.reasoning_summary_text.delta", delta: String(block.text) }));
+      } else if (block?.type === "tool_use") {
+        const callId = String(block.id || "");
+        const name = String(block.name || "unknown");
+        const input = block.input && typeof block.input === "object" ? block.input : {};
+        chunks.push(withParent({ event: "response.tool_use.start", call_id: callId, name, input }));
+        chunks.push(withParent({ event: "response.tool_use.completed", call_id: callId, name, input }));
+      }
+    }
+  } else if (event.type === "user") {
+    for (const block of blocks) {
+      if (block?.type !== "tool_result") continue;
+      const text = typeof block.content === "string" ? block.content : "";
+      chunks.push(withParent({
+        event: "response.tool_result",
+        call_id: String(block.tool_use_id || ""),
+        output: text ? [{ type: "text", format: "plain", text }] : [],
+        is_error: !!block.is_error,
+      }));
+    }
+  }
+  return chunks;
+}

package/src-ext/runtime/_shared/headlessCliBridge.mjs

@@ -0,0 +1,168 @@
+import path from "node:path";
+import process from "node:process";
+
+import { bootstrapAgentlinkTools } from "../../core/agentlinkToolsBootstrap.mjs";
+import { createActiveRunRegistry } from "../../core/activeRuns.mjs";
+import { installAutoTunnel } from "../../core/autoTunnelWiring.mjs";
+import { runWorkerWithRevokeHandling } from "../../core/bridgeSelfUninstall.mjs";
+import { ensureDefaultWorkspace } from "../../core/defaultWorkspace.mjs";
+import { resolveSession } from "../../core/pairCodeClient.mjs";
+import { createRelayWorker } from "../../core/relayWorker.mjs";
+import { createUnifiedDispatchHandler } from "../../core/unifiedDispatchHandler.mjs";
+import { scanWorkspacesByRuntime } from "../../core/scanWorkspaces.mjs";
+
+export function createHeadlessRuntimeController({ log } = {}) {
+  const activeRuns = createActiveRunRegistry({ log });
+
+  async function invoke(invokeImpl, args) {
+    let unregister = () => {};
+    try {
+      return await invokeImpl({
+        ...args,
+        onProcess: (control) => {
+          unregister();
+          unregister = activeRuns.register({
+            sessionKey: args.session_key ?? "",
+            threadId: args.thread_id ?? "",
+            runId: args.run_id ?? "",
+            kill: (reason) => control.terminate(reason),
+          });
+          args.onProcess?.(control);
+        },
+      });
+    } finally {
+      unregister();
+    }
+  }
+
+  function handleRPC(method, params = {}) {
+    if (method !== "sessions.abort" && method !== "chat.abort") return null;
+    const result = activeRuns.abort({
+      key: params.key ?? params.sessionKey ?? "",
+      runId: params.runId ?? "",
+    });
+    if (result.aborted === 0 && !result.status) {
+      return { ok: true, ...result, status: "no-active-run" };
+    }
+    return { ok: true, ...result };
+  }
+
+  return {
+    invoke,
+    handleRPC,
+    shutdown: (reason) => activeRuns.abortAll(reason),
+    size: () => activeRuns.size(),
+  };
+}
+
+/** Shared long-poll bridge for headless NDJSON runtimes such as Cursor/OpenCode. */
+export async function runHeadlessCliBridge({ runtime, options, log, preflight, createInvoke }) {
+  const pre = preflight({ log });
+  if (!pre.ok) {
+    process.stderr.write(`${runtime} preflight failed: ${pre.error}\n`);
+    if (pre.hint) process.stderr.write(`${pre.hint}\n`);
+    process.exitCode = 65;
+    return;
+  }
+
+  let session;
+  try {
+    session = await resolveSession({ runtime, options, log });
+  } catch (err) {
+    process.stderr.write(`${err?.message || err}\n`);
+    process.exitCode = 65;
+    return;
+  }
+  if (!session.bridgeToken) {
+    process.stderr.write(`缺少 bridge_token，请重新运行 agentlink pair <code> -r ${runtime}\n`);
+    process.exitCode = 65;
+    return;
+  }
+
+  const fallbackWorkspace = path.resolve(options.cwd || await ensureDefaultWorkspace(runtime));
+  const sessLog = log.child({ gw: session.gwId });
+  const worker = createRelayWorker({
+    relayUrl: session.relayUrl,
+    gwId: session.gwId,
+    bridgeToken: session.bridgeToken,
+    runtime,
+    log: sessLog,
+  });
+  installAutoTunnel({ relayUrl: session.relayUrl, log: sessLog });
+
+  let lastRequestId = null;
+  let toolsLifecycle = null;
+  try {
+    toolsLifecycle = await bootstrapAgentlinkTools({
+      runtime,
+      gwId: session.gwId,
+      relayUrl: session.relayUrl,
+      bridgeToken: session.bridgeToken,
+      worker,
+      log: sessLog,
+      version: pre.version || "",
+      getLastRequestId: () => lastRequestId,
+    });
+  } catch (err) {
+    sessLog.warn("agentlink_tools.bootstrap.failed", "continuing without tools", {
+      err: err?.message || String(err),
+    });
+  }
+
+  const controller = createHeadlessRuntimeController({ log: sessLog });
+  const invoke = createInvoke({ fallbackWorkspace, log: sessLog, preflightResult: pre });
+  const dispatch = createUnifiedDispatchHandler({
+    relayUrl: session.relayUrl,
+    bridgeToken: session.bridgeToken,
+    gatewayId: session.gwId,
+    log: sessLog,
+    openclawInvoke: (args) => controller.invoke(invoke, args),
+  });
+  async function handleRequest(request, ctx) {
+    lastRequestId = ctx.requestId;
+    if (request?.request?.__relayKind === "rpc") {
+      if (request.request.method === "workspaces.scan") {
+        const result = await scanWorkspacesByRuntime({
+          runtimeKind: runtime,
+          gatewayId: session.gwId,
+          params: request.request.params ?? {},
+        });
+        await ctx.publishEvent({ event: "response", statusCode: 200, contentType: "application/json; charset=utf-8", body: JSON.stringify(result) });
+        await ctx.publishEvent({ event: "end" });
+        return;
+      }
+      const result = controller.handleRPC(request.request.method, request.request.params ?? {});
+      if (result) {
+        await ctx.publishEvent({
+          event: "response",
+          statusCode: 200,
+          contentType: "application/json; charset=utf-8",
+          body: JSON.stringify(result),
+        });
+        await ctx.publishEvent({ event: "end" });
+        return;
+      }
+    }
+    const consumed = await dispatch(request, ctx);
+    if (!consumed) {
+      throw new Error(`${runtime} 暂不支持该请求类型`);
+    }
+  }
+
+  let shuttingDown = false;
+  async function shutdown(reason) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    controller.shutdown(reason);
+    worker.stop(reason);
+    try { await toolsLifecycle?.stop?.(); } catch {}
+  }
+  process.once("SIGINT", () => { void shutdown("SIGINT"); });
+  process.once("SIGTERM", () => { void shutdown("SIGTERM"); });
+
+  sessLog.info("bridge.loop.entered", `${runtime} worker entering long-poll loop`, {
+    cwd: fallbackWorkspace,
+    version: pre.version || "",
+  });
+  await runWorkerWithRevokeHandling({ worker, handler: handleRequest, runtime, log: sessLog });
+}