@xyagent/cli 0.0.1 → 1.1.0

package/src-ext/runtime/hermes/handleRequest.mjs

@@ -24,6 +24,7 @@
  */
 
 import { randomBytes } from "node:crypto";
+import { statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
@@ -113,12 +114,19 @@ const SYSTEM_PROMPT_DEFAULT =
  */
 function _resolveWorkspacePathProfile(workspacePath) {
   if (!workspacePath || typeof workspacePath !== "string") return null;
+  const raw = workspacePath.trim();
+  if (!path.isAbsolute(raw) && raw !== "~" && !raw.startsWith("~/")) return null;
   // expand ~ 前缀
   const expanded = workspacePath.startsWith("~")
     ? path.join(os.homedir(), workspacePath.slice(1))
     : workspacePath;
   const normalized = path.resolve(expanded);
   if (!normalized) return null;
+  try {
+    if (!statSync(normalized).isDirectory()) return null;
+  } catch {
+    return null;
+  }
 
   // align-runtime-default-workspace: root hermesHome（~/.hermes）→ profileName="default"
   const hermesRoot = path.join(os.homedir(), ".hermes");
@@ -209,6 +217,11 @@ export function createHermesHandleRequest({ pre, log, gwId, usage, dispatchHandl
     let effectiveApiKey = pre.apiKey;  // 默认：bridge 启动时固定的 apiKey
 
     const workspaceResolved = workspace_path ? _resolveWorkspacePathProfile(workspace_path) : null;
+    if (workspace_path && !workspaceResolved) {
+      const error = new Error("hermes: requested workspace context is unavailable");
+      error.code = "workspace_context_unavailable";
+      throw error;
+    }
     if (workspaceResolved) {
       const { profileName, profileHome: reqProfileHome } = workspaceResolved;
       let gwResult;

package/src-ext/runtime/hermes/httpBackend.mjs

@@ -145,6 +145,17 @@ export async function* streamChat(messages, opts) {
           try { return JSON.parse(payload); } catch { return null; }
         })();
         if (parsed) {
+          // Hermes 网关在上游鉴权、额度或模型调用失败时仍保持 HTTP 200，
+          // 错误位于最后一个 SSE chunk。不能把它当作空的 completed，否则
+          // Desktop 会永久表现成“没有回复”且用户看不到真实处置原因。
+          const parsedChoice = parsed?.choices?.[0];
+          if (parsed?.error || parsedChoice?.finish_reason === "error") {
+            const message = String(
+              parsed?.error?.message || parsed?.hermes?.error || "Hermes upstream request failed",
+            ).trim();
+            yield { kind: "error", error: message || "Hermes upstream request failed" };
+            return;
+          }
           // OpenAI streaming shape: choices[].delta.content + optional usage on
           // last chunk (with stream_options.include_usage=true).
           //
@@ -156,7 +167,7 @@ export async function* streamChat(messages, opts) {
           // thinking inside delta.content (e.g. Gemini via OpenAI-compat
           // gateway) won't trigger this branch — that's expected, since the
           // upstream has not split reasoning out.
-          const choice = parsed?.choices?.[0];
+          const choice = parsedChoice;
           const reasoningDelta = choice?.delta?.reasoning_content;
           if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
             yield { kind: "thinking", text: reasoningDelta };

package/src-ext/runtime/hermes/index.mjs

@@ -109,7 +109,7 @@ export async function runHermesBridge({ options, positional, log }) {
   });
 
   const worker = createRelayWorker({
-    relayUrl: relayBase, gwId, bridgeToken, runtime: "hermes", log: sessLog,
+    relayUrl: relayBase, gwId, bridgeToken, runtime: "hermes", profileName, log: sessLog,
   });
   installAutoTunnel({ relayUrl: relayBase, log: sessLog });
 

package/src-ext/runtime/hermes/preflight.mjs

@@ -320,7 +320,8 @@ export async function hermesPreflightWithHeal({ options = {}, log, hermesHome }
   const envChanged =
     envResult.status === "patched" &&
     (envResult.overridden?.length > 0 ||
-      (envResult.appended || []).includes("API_SERVER_ENABLED"));
+      (envResult.appended || []).some((key) =>
+        key === "API_SERVER_ENABLED" || key === "API_SERVER_KEY"));
   const mode = envChanged ? "restart" : "ensure";
   const effectiveHome = hermesHome || resolveHermesHome();
   const logPath = path.join(effectiveHome, "gateway.log");

package/src-ext/runtime/kimi/index.mjs

@@ -0,0 +1,100 @@
+import { recordBridgedSession } from "../_shared/bridgedSessionLedger.mjs";
+import { runHeadlessCliBridge } from "../_shared/headlessCliBridge.mjs";
+import { probeBinary, runNdjsonProcess } from "../_shared/ndjsonProcess.mjs";
+import { resolveWorkspaceCwd } from "../_shared/resolveWorkspaceCwd.mjs";
+
+export function kimiPreflight({ probe = probeBinary } = {}) {
+  let result = probe("kimi");
+  let binary = "kimi";
+  if (!result.ok) {
+    const legacy = probe("kimi-cli");
+    if (legacy.ok) {
+      result = legacy;
+      binary = "kimi-cli";
+    }
+  }
+  if (!result.ok) result.hint = "请先安装 Kimi Code CLI，并执行 kimi login 完成认证。";
+  return { ...result, binary };
+}
+
+export function translateKimiEvent(event) {
+  if (!event || typeof event !== "object") return null;
+  if (event.role === "assistant") {
+    const chunks = [];
+    if (event.content) {
+      chunks.push({ event: "response.output_text.delta", delta: String(event.content) });
+    }
+    for (const call of Array.isArray(event.tool_calls) ? event.tool_calls : []) {
+      const callId = String(call?.id || "");
+      const name = String(call?.function?.name || "unknown");
+      let input = {};
+      try { input = JSON.parse(call?.function?.arguments || "{}"); } catch {}
+      chunks.push({ event: "response.tool_use.start", call_id: callId, name, input });
+      chunks.push({ event: "response.tool_use.completed", call_id: callId, name, input });
+    }
+    return chunks;
+  }
+  if (event.role === "tool") {
+    const text = typeof event.content === "string" ? event.content : "";
+    return {
+      event: "response.tool_result",
+      call_id: String(event.tool_call_id || ""),
+      output: text ? [{ type: "text", format: "plain", text }] : [],
+      is_error: false,
+    };
+  }
+  return null;
+}
+
+/**
+ * kimi 真实 session id 的前缀（`session.resume_hint` 事件回报的形态）。
+ *
+ * 🔴 2026-08-16 真机故障固化的两条口径（kimi 0.34.0 实测）：
+ *   1. `--print` 参数已不存在（报 `unknown option '--print' (Did you mean --prompt?)`），
+ *      `--prompt` 本身就是「非交互跑一轮并打印」；
+ *   2. `--session <id>` 是**纯 resume** 语义 —— 传一个不存在的 id 直接报
+ *      `Session "..." not found`，不再是旧版的 create-or-resume。所以首轮**不带**
+ *      `--session`（让 CLI 自己建），从输出的 `session.resume_hint` 事件抓真实 id，
+ *      续轮才 resume；老 bridge 存过的 randomUUID 一律不信（没有此前缀）。
+ */
+const KIMI_SESSION_ID_PREFIX = "session_";
+
+export function buildKimiArgs({ input, sessionId }) {
+  const args = ["--prompt", String(input || ""), "--output-format", "stream-json"];
+  if (sessionId) args.push("--session", sessionId);
+  return args;
+}
+
+export function createKimiInvoke({ fallbackWorkspace, preflightResult, log, runProcess = runNdjsonProcess }) {
+  const sessions = new Map();
+  return async ({ thread_id, input, workspace_path, resume_session_id, onChunk, onProcess }) => {
+    const { cwd } = resolveWorkspaceCwd({ workspacePath: workspace_path, fallbackWorkspace, runtime: "kimi", log });
+    // 只信带 kimi 真实前缀的 id（见 KIMI_SESSION_ID_PREFIX 的口径说明）。
+    const saved = sessions.get(thread_id) || resume_session_id;
+    const sessionId =
+      typeof saved === "string" && saved.startsWith(KIMI_SESSION_ID_PREFIX) ? saved : undefined;
+    await runProcess({
+      binary: preflightResult?.binary || "kimi",
+      args: buildKimiArgs({ input, sessionId }),
+      cwd,
+      parseEvent: (event) => {
+        // 首轮 CLI 自建会话后经 resume_hint 回报真实 id —— 记下来供续轮 resume。
+        if (
+          event?.type === "session.resume_hint" &&
+          typeof event.session_id === "string" &&
+          event.session_id.startsWith(KIMI_SESSION_ID_PREFIX)
+        ) {
+          sessions.set(thread_id, event.session_id);
+          recordBridgedSession("kimi", event.session_id); // 打标：桥接产生的 CLI 会话，导入时跳过
+        }
+        return translateKimiEvent(event);
+      },
+      onChunk,
+      onProcess,
+    });
+  };
+}
+
+export async function runKimiBridge({ options, log }) {
+  return runHeadlessCliBridge({ runtime: "kimi", options, log, preflight: kimiPreflight, createInvoke: createKimiInvoke });
+}

package/src-ext/runtime/openclaw/buildOpenclawDaemonInput.mjs

@@ -127,12 +127,6 @@ export async function buildOpenclawDaemonInput(textInput, blocks, {
         // text 文件内容 / binary 描述 / document text extraction fallback
         content.push({ type: "input_text", text: result.text });
         break;
-      case "url_ref":
-        // picoclaw only — openclaw/claude runtimes never return url_ref from relayObjectToBlock;
-        // if this branch is somehow hit, drop to a safe description with NO URL in LLM context
-        // (铁律 #1: signed URL must not appear in LLM input). (CR-003)
-        content.push({ type: "input_text", text: `[image] (preview unavailable for this runtime)` });
-        break;
       default:
         break;
     }

package/src-ext/runtime/openclaw/workspaceContext.mjs

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+function expandUserPath(value) {
+  const text = String(value || "").trim();
+  if (text === "~") return os.homedir();
+  if (text.startsWith("~/")) return path.join(os.homedir(), text.slice(2));
+  return text;
+}
+
+function configuredAgent(config, agentId) {
+  const entries = Array.isArray(config?.agents?.list) ? config.agents.list.filter(Boolean) : [];
+  const normalized = String(agentId || "main").trim().toLowerCase();
+  return entries.find((entry) => String(entry?.id || "").trim().toLowerCase() === normalized) || null;
+}
+
+function defaultAgentId(config) {
+  const entries = Array.isArray(config?.agents?.list) ? config.agents.list.filter(Boolean) : [];
+  return String(entries.find((entry) => entry?.default)?.id || entries[0]?.id || "main").trim().toLowerCase();
+}
+
+export function resolveConfiguredOpenClawWorkspace(config, agentId) {
+  const normalizedAgentId = String(agentId || "main").trim().toLowerCase() || "main";
+  const configured = configuredAgent(config, normalizedAgentId)?.workspace;
+  if (typeof configured === "string" && configured.trim()) {
+    return path.resolve(expandUserPath(configured));
+  }
+  const fallback = config?.agents?.defaults?.workspace;
+  if (typeof fallback === "string" && fallback.trim()) {
+    const root = path.resolve(expandUserPath(fallback));
+    return normalizedAgentId === defaultAgentId(config) ? root : path.join(root, normalizedAgentId);
+  }
+  if (normalizedAgentId === defaultAgentId(config)) {
+    return path.join(os.homedir(), ".openclaw", "workspace");
+  }
+  return path.join(os.homedir(), ".openclaw", `workspace-${normalizedAgentId}`);
+}
+
+/**
+ * OpenClaw /v1/responses has no request-level cwd field (strict request
+ * schema). Therefore a workspace run is safe only when the selected agent's
+ * configured workspace is exactly the requested directory.
+ */
+export function assertOpenClawWorkspaceContext({ config, agentId, workspacePath }) {
+  const requested = String(workspacePath || "").trim();
+  if (!requested) return;
+  let available = path.isAbsolute(requested);
+  if (available) {
+    try { available = fs.statSync(requested).isDirectory(); } catch { available = false; }
+  }
+  const configured = resolveConfiguredOpenClawWorkspace(config, agentId);
+  if (!available || path.resolve(requested) !== path.resolve(configured)) {
+    const error = new Error("openclaw: requested workspace context is unavailable");
+    error.code = "workspace_context_unavailable";
+    throw error;
+  }
+}

package/src-ext/runtime/opencode/index.mjs

@@ -0,0 +1,48 @@
+import { runHeadlessCliBridge } from "../_shared/headlessCliBridge.mjs";
+import { recordBridgedSession } from "../_shared/bridgedSessionLedger.mjs";
+import { probeBinary, runNdjsonProcess } from "../_shared/ndjsonProcess.mjs";
+import { resolveWorkspaceCwd } from "../_shared/resolveWorkspaceCwd.mjs";
+
+export function opencodePreflight() {
+  return probeBinary("opencode");
+}
+
+export function translateOpenCodeEvent(event) {
+  if (event?.type === "error") {
+    const message = event.error?.message || event.message || "OpenCode runtime error";
+    throw new Error(String(message));
+  }
+  if (event?.type === "text" && event.part?.text) {
+    return { event: "response.output_text.delta", delta: String(event.part.text) };
+  }
+  return null;
+}
+
+export function createOpenCodeInvoke({ fallbackWorkspace, log, runProcess = runNdjsonProcess }) {
+  const sessions = new Map();
+  return async ({ thread_id, input, workspace_path, resume_session_id, onChunk, onProcess }) => {
+    const { cwd } = resolveWorkspaceCwd({ workspacePath: workspace_path, fallbackWorkspace, runtime: "opencode", log });
+    const args = ["run", "--format", "json", "--dir", cwd];
+    const model = String(process.env.AGENTLINK_OPENCODE_MODEL || "").trim();
+    if (model) args.push("--model", model);
+    const prior = sessions.get(thread_id) || resume_session_id;
+    if (prior) args.push("--session", prior);
+    args.push(String(input || ""));
+    await runProcess({
+      binary: "opencode",
+      args,
+      cwd,
+      parseEvent: translateOpenCodeEvent,
+      onChunk,
+      onProcess,
+      onSession: (id) => {
+        sessions.set(thread_id, id);
+        recordBridgedSession("opencode", id); // 打标：桥接产生的 CLI 会话，导入时跳过
+      },
+    });
+  };
+}
+
+export async function runOpenCodeBridge({ options, log }) {
+  return runHeadlessCliBridge({ runtime: "opencode", options, log, preflight: opencodePreflight, createInvoke: createOpenCodeInvoke });
+}

package/src-ext/runtime/opencode/mcpConfigAdapter.mjs

@@ -0,0 +1,15 @@
+import os from "node:os";
+import path from "node:path";
+
+import { createJsonMcpConfigAdapter } from "../_shared/jsonMcpConfigAdapter.mjs";
+
+export const fileExtension = "json";
+
+const adapter = createJsonMcpConfigAdapter({
+  resolvePath: () => process.env.OPENCODE_CONFIG || path.join(os.homedir(), ".config", "opencode", "opencode.json"),
+  readServers: (config) => config.mcp || (config.mcp = {}),
+  writeServers: (config, servers) => { config.mcp = servers; },
+  desiredEntry: (args) => ({ type: "local", command: ["node", ...args], enabled: true }),
+});
+
+export const { read, register, deregister, status } = adapter;

package/src-ext/runtime/opencode/preflight.mjs

@@ -0,0 +1,72 @@
+// opencode 预检：
+//   - 二进制存在（PATH 上能 spawn 到 `opencode`）
+//   - 版本号 best-effort 解析（只作展示/日志，不参与 installed 判定）
+//
+// 🔴 刻意与 src-ext/runtime/codex/preflight.mjs **同构**（同返回形状、同 5s 超时、
+// 同 ENOENT 专属分支），不为 opencode 另造探测范式：本仓判「runtime 装没装」只有
+// 一套办法 —— 直接问它自己的二进制。
+//
+// ⚠️ 不得拿 `agentlink-agent` 的存在当作「opencode 已安装」信号：agentlink-agent
+// 是 @xyagent/cli 自带的桥进程，永远在位，用它判定会把没装 opencode 的机器误报成
+// 已安装（这个坑 detectInstalledRuntimes 的注释里对 hermes 已经踩过一次）。
+//
+// spawnImpl 可注入（沿用仓内 `consumePairCode({ fetchImpl })` 的注入范式），
+// 让单测无需真装 opencode 就能确定性覆盖四条分支。
+
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+const PREFLIGHT_TIMEOUT_MS = 5000;
+
+const INSTALL_HINT =
+  "未找到 `opencode` 命令。请先安装 opencode CLI（并确保它在当前 shell 的 PATH 里）。";
+
+/**
+ * @param {{ log?: object, spawnImpl?: Function }} [opts]
+ * @returns {{ ok: boolean, version?: string, error?: string, hint?: string }}
+ */
+export function opencodePreflight({ log, spawnImpl } = {}) {
+  const isWin = process.platform === "win32";
+  const pfLog = log ? log.child({ comp: "child", stage: "preflight" }) : null;
+  const spawn = spawnImpl || spawnSync;
+
+  let res;
+  try {
+    res = spawn("opencode", ["--version"], {
+      encoding: "utf8",
+      timeout: PREFLIGHT_TIMEOUT_MS,
+      shell: isWin ? true : false,
+    });
+  } catch (err) {
+    pfLog?.error("bridge.preflight.fail", "spawn threw", { err: err?.message || String(err) });
+    return { ok: false, error: err?.message || String(err), hint: INSTALL_HINT };
+  }
+  if (!res) {
+    return { ok: false, error: "opencode --version returned no result", hint: INSTALL_HINT };
+  }
+  if (res.error) {
+    const isENOENT = res.error.code === "ENOENT";
+    pfLog?.error("bridge.preflight.fail", "spawn errored", {
+      code: res.error.code, err: res.error.message,
+    });
+    return {
+      ok: false,
+      error: res.error.message,
+      hint: isENOENT ? INSTALL_HINT : `spawn opencode 失败（${res.error.code || "unknown"}）`,
+    };
+  }
+  if (res.status !== 0) {
+    const stderr = String(res.stderr ?? "").trim().split(/\r?\n/)[0] || "";
+    return {
+      ok: false,
+      error: `opencode --version exit ${res.status}${stderr ? `: ${stderr}` : ""}`,
+      hint: "opencode 启动报错，请先在终端手动跑一次 `opencode --version` 确认可用。",
+    };
+  }
+
+  // 版本只取首行做展示；解析不出来**不**影响 ok —— installed 由 exit 0 决定，
+  // 与 detectInstalledRuntimes 的两阶段探测保持同一口径。
+  const version = String(res.stdout ?? "").trim().split(/\r?\n/)[0] || "";
+  pfLog?.info("bridge.preflight.pass", "opencode binary ok", { version });
+  return { ok: true, version };
+}

package/src-ext/runtime/qwen/index.mjs

@@ -0,0 +1,42 @@
+
+import { runHeadlessCliBridge } from "../_shared/headlessCliBridge.mjs";
+import { recordBridgedSession } from "../_shared/bridgedSessionLedger.mjs";
+import { probeBinary, runNdjsonProcess } from "../_shared/ndjsonProcess.mjs";
+import { resolveWorkspaceCwd } from "../_shared/resolveWorkspaceCwd.mjs";
+import { translateClaudeSchemaEvent } from "../_shared/claudeSchemaEvent.mjs";
+
+export function qwenPreflight() {
+  const result = probeBinary("qwen");
+  if (!result.ok) result.hint = "请先安装 Qwen Code，并执行 qwen 登录完成认证。";
+  return result;
+}
+
+export function buildQwenArgs({ input, sessionId }) {
+  const args = ["--prompt", String(input || ""), "--output-format", "stream-json", "--yolo"];
+  if (sessionId) args.push("--resume", sessionId);
+  return args;
+}
+
+export function createQwenInvoke({ fallbackWorkspace, log, runProcess = runNdjsonProcess }) {
+  const sessions = new Map();
+  return async ({ thread_id, input, workspace_path, resume_session_id, onChunk, onProcess }) => {
+    const { cwd } = resolveWorkspaceCwd({ workspacePath: workspace_path, fallbackWorkspace, runtime: "qwen", log });
+    await runProcess({
+      binary: "qwen",
+      args: buildQwenArgs({ input, sessionId: sessions.get(thread_id) || resume_session_id || null }),
+      cwd,
+      env: { QWEN_CODE_SUPPRESS_YOLO_WARNING: "1" },
+      parseEvent: translateClaudeSchemaEvent,
+      onChunk,
+      onProcess,
+      onSession: (id) => {
+        sessions.set(thread_id, id);
+        recordBridgedSession("qwen", id); // 打标：桥接产生的 CLI 会话，导入时跳过
+      },
+    });
+  };
+}
+
+export async function runQwenBridge({ options, log }) {
+  return runHeadlessCliBridge({ runtime: "qwen", options, log, preflight: qwenPreflight, createInvoke: createQwenInvoke });
+}