dsh-plugin-agentflow 0.0.0-stage → 0.2.0

package/runtime/bridge.mjs

@@ -0,0 +1,230 @@
+// bridge.mjs —— AgentFlow 与 DSH 内核里 llm bridge 的通信层。
+//
+// 契约见 docs/bridge-contract.md。要点：
+//   - 不保留直连退路：bridge 连不上就是「DSH 内核未连接」，调用方必须失败
+//   - 发现文件由插件写、我们只读；按 mtime 缓存 2 秒
+//   - 流事件只有 delta / tool / usage / done / error 五种
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const DSH_HOME = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+const DEFAULT_DIR = path.join(DSH_HOME, 'agent-flow');
+
+const INFO_TTL_MS = 2000;
+const HEALTH_TIMEOUT_MS = 300;
+const CATALOG_TIMEOUT_MS = 3000;
+
+/** 发现文件位置：<agentflowDir>/data/dsh-bridge.json */
+export function bridgeInfoPath(dir = DEFAULT_DIR) {
+  return path.join(dir, 'data', 'dsh-bridge.json');
+}
+
+let infoCache = { key: '', mtimeMs: 0, at: 0, info: null };
+
+/**
+ * 读发现文件。失效的情况全部返回 null，由 bridgeUnavailableReason 给原因。
+ * @returns {Promise<{version:number,pid:number,port:number,token:string,startedAt:number}|null>}
+ */
+export async function readBridgeInfo(dir = DEFAULT_DIR) {
+  const file = bridgeInfoPath(dir);
+  let stat;
+  try {
+    stat = await fs.stat(file);
+  } catch {
+    infoCache = { key: file, mtimeMs: 0, at: Date.now(), info: null };
+    return null;
+  }
+  const key = file;
+  const now = Date.now();
+  if (infoCache.info && infoCache.key === key && infoCache.mtimeMs === stat.mtimeMs && now - infoCache.at < INFO_TTL_MS) {
+    return infoCache.info;
+  }
+  let info = null;
+  try {
+    const raw = await fs.readFile(file, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && Number.isInteger(parsed.pid) && Number.isInteger(parsed.port) && typeof parsed.token === 'string' && parsed.token) {
+      info = {
+        version: Number(parsed.version) || 1,
+        pid: parsed.pid,
+        port: parsed.port,
+        token: parsed.token,
+        startedAt: Number(parsed.startedAt) || 0,
+      };
+    }
+  } catch {
+    info = null;
+  }
+  infoCache = { key, mtimeMs: stat.mtimeMs, at: now, info };
+  return info;
+}
+
+/** 进程是否活着；EPERM 也算活着（存在但没权限发信号） */
+export function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return Boolean(err && err.code === 'EPERM');
+  }
+}
+
+function urlOf(info, suffix) {
+  return `http://127.0.0.1:${info.port}${suffix}`;
+}
+
+function authHeaders(info) {
+  return { authorization: `Bearer ${info.token}`, accept: 'application/json' };
+}
+
+/**
+ * bridge 不可用的原因；可用时返回 null。
+ * 文案直接给用户看，必须说清楚是哪一环断了。
+ */
+export async function bridgeUnavailableReason(dir = DEFAULT_DIR) {
+  const info = await readBridgeInfo(dir);
+  if (!info) return 'bridge 发现文件不存在（DSH 未运行或插件未加载）';
+  if (!pidAlive(info.pid)) return `bridge 进程已退出（pid ${info.pid}）`;
+  try {
+    const res = await fetch(urlOf(info, '/health'), {
+      headers: authHeaders(info),
+      signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+    });
+    if (res.status === 401) return 'bridge token 校验失败（401）';
+    if (!res.ok) return `bridge 健康检查返回 HTTP ${res.status}`;
+    const body = await res.json().catch(() => null);
+    if (!body || body.ok !== true) return 'bridge 健康检查返回异常内容';
+    return null;
+  } catch (err) {
+    const msg = String((err && err.message) || err);
+    if (/timeout|aborted/i.test(msg)) return `bridge 健康检查超时（${HEALTH_TIMEOUT_MS}ms）`;
+    return `bridge 健康检查失败：${msg}`;
+  }
+}
+
+/** 健康检查；不可用时抛错（由调用方决定怎么展示） */
+export async function bridgeHealth(dir = DEFAULT_DIR) {
+  const reason = await bridgeUnavailableReason(dir);
+  if (reason) throw new Error(reason);
+  const info = await readBridgeInfo(dir);
+  const res = await fetch(urlOf(info, '/health'), {
+    headers: authHeaders(info),
+    signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS),
+  });
+  return res.json();
+}
+
+/** 读模型目录；失败抛错（错误信息含原因） */
+export async function bridgeCatalog(dir = DEFAULT_DIR) {
+  const info = await readBridgeInfo(dir);
+  if (!info) throw new Error('bridge 发现文件不存在（DSH 未运行或插件未加载）');
+  if (!pidAlive(info.pid)) throw new Error(`bridge 进程已退出（pid ${info.pid}）`);
+  let res;
+  try {
+    res = await fetch(urlOf(info, '/catalog'), {
+      headers: authHeaders(info),
+      signal: AbortSignal.timeout(CATALOG_TIMEOUT_MS),
+    });
+  } catch (err) {
+    throw new Error(`bridge /catalog 请求失败：${String((err && err.message) || err)}`);
+  }
+  if (res.status === 401) throw new Error('bridge token 校验失败（401）');
+  if (!res.ok) throw new Error(`bridge /catalog 返回 HTTP ${res.status}`);
+  const body = await res.json().catch(() => null);
+  if (!body || !Array.isArray(body.providers)) throw new Error('bridge /catalog 返回结构不对');
+  return body;
+}
+
+/**
+ * 发起一次流式模型调用。
+ * @param {object} request 见契约：provider/model/reasoningEffort/system/messages/tools
+ * @param {{dir?:string, signal?:AbortSignal}} [opts]
+ * @returns {Promise<{events: AsyncIterable<object>, abort: () => void}>}
+ */
+export async function bridgeStream(request, opts = {}) {
+  const dir = opts.dir || DEFAULT_DIR;
+  const info = await readBridgeInfo(dir);
+  if (!info) throw new Error('DSH 内核未连接（bridge 发现文件不存在）');
+  if (!pidAlive(info.pid)) throw new Error(`DSH 内核未连接（bridge 进程已退出，pid ${info.pid}）`);
+
+  const controller = new AbortController();
+  const onOuterAbort = () => controller.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) controller.abort();
+    else opts.signal.addEventListener('abort', onOuterAbort, { once: true });
+  }
+
+  let res;
+  try {
+    res = await fetch(urlOf(info, '/stream'), {
+      method: 'POST',
+      headers: { ...authHeaders(info), 'content-type': 'application/json' },
+      body: JSON.stringify(request),
+      signal: controller.signal,
+    });
+  } catch (err) {
+    if (opts.signal) opts.signal.removeEventListener('abort', onOuterAbort);
+    throw new Error(`DSH 内核未连接（bridge /stream 请求失败：${String((err && err.message) || err)}）`);
+  }
+
+  if (res.status === 401) throw new Error('DSH 内核未连接（bridge token 校验失败）');
+  if (res.status === 429) throw new Error('bridge 忙（并发超限）');
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`bridge /stream 返回 HTTP ${res.status}${text ? '：' + text.slice(0, 200) : ''}`);
+  }
+  if (!res.body) throw new Error('bridge /stream 没有响应体');
+
+  return {
+    events: readSseEvents(res.body),
+    abort: () => controller.abort(),
+  };
+}
+
+/**
+ * 把 SSE 字节流解析成事件对象。只认 `data: ` 行；注释行（`: ping`）忽略。
+ * 结束时若没收到 done/error，抛错，避免调用方把截断当成功。
+ */
+async function* readSseEvents(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let finished = false;
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let idx;
+      while ((idx = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, idx).replace(/\r$/, '');
+        buffer = buffer.slice(idx + 1);
+        if (!line || line.startsWith(':')) continue;
+        if (!line.startsWith('data:')) continue;
+        const payload = line.slice(5).trim();
+        if (!payload) continue;
+        let evt;
+        try {
+          evt = JSON.parse(payload);
+        } catch {
+          continue; // 坏行跳过，别把整次调用打断
+        }
+        if (evt && evt.type === 'error') {
+          finished = true;
+          throw new Error(String(evt.message || 'bridge 调用失败'));
+        }
+        if (evt && evt.type === 'done') finished = true;
+        yield evt;
+      }
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {}
+    if (!finished) throw new Error('bridge 流提前结束（没有收到 done/error）');
+  }
+}

package/runtime/dsh-source.mjs

@@ -0,0 +1,289 @@
+// dsh-source.mjs —— AgentFlow 的「DSH 版」配置来源。
+//
+// 原则：模型、MCP、技能**一律取自 DSH 自己的配置**，AgentFlow 不再自带一套。
+//   - 模型：DSH 内核的 llm bridge（GET /catalog），不读凭据、不直连 /models
+//   - MCP ：cordis.patch.yml 里所有 dsh-mcp-client 行
+//   - 技能：~/.dsh/skills
+//
+// 这样做的代价是：DSH 里没配的东西，AgentFlow 里也用不了。这是有意的。
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { bridgeCatalog } from './bridge.mjs';
+
+const DSH_HOME = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+const PROFILE_DIR = path.join(DSH_HOME, 'profiles', 'desktop');
+const PATCH_FILE = path.join(PROFILE_DIR, 'cordis.patch.yml');
+const SKILL_DIR = path.join(DSH_HOME, 'skills');
+/** bridge 发现文件所在目录：<dir>/data/dsh-bridge.json */
+const DEFAULT_BRIDGE_DIR = path.join(DSH_HOME, 'agent-flow');
+
+// ---------------------------------------------------------------------------
+// 极简 YAML：够读 cordis.patch.yml 的「数组项 → 缩进映射/列表」这一种形状。
+// 不追求通用，只求把 loader patch 的结构读出来。注释、`!!js` 标签都跳过。
+// ---------------------------------------------------------------------------
+
+function parseScalar(raw) {
+  let v = raw.trim();
+  if (v === '') return '';
+  // 去掉行尾注释（引号外的 #）
+  let inQuote = null;
+  for (let i = 0; i < v.length; i++) {
+    const c = v[i];
+    if (inQuote) {
+      if (c === inQuote) inQuote = null;
+    } else if (c === '"' || c === "'") {
+      inQuote = c;
+    } else if (c === '#' && (i === 0 || v[i - 1] === ' ')) {
+      v = v.slice(0, i).trim();
+      break;
+    }
+  }
+  if (v === '') return '';
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+    return v.slice(1, -1);
+  }
+  if (v === 'true') return true;
+  if (v === 'false') return false;
+  if (v === 'null' || v === '~') return null;
+  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
+  return v;
+}
+
+/** 把 YAML 文本拆成 {indent, content, raw} 行数组，丢掉空行与整行注释 */
+function meaningfulLines(text) {
+  const out = [];
+  for (const raw of text.split(/\r?\n/)) {
+    const trimmed = raw.trimStart();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const indent = raw.length - trimmed.length;
+    out.push({ indent, content: trimmed.replace(/\s+$/, ''), raw });
+  }
+  return out;
+}
+
+/**
+ * 解析一小段 YAML（从 start 行开始的连续块），返回 {value, next}。
+ * 只处理三种形状：映射 `k: v`、数组 `- v`、数组里的映射 `- k: v`。
+ */
+function parseBlock(lines, start, indent) {
+  if (start >= lines.length) return { value: null, next: start };
+  const isArray = lines[start].indent === indent && lines[start].content.startsWith('-');
+  const container = isArray ? [] : {};
+  let i = start;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.indent < indent) break;
+    if (line.indent > indent) { i++; continue; } // 不该出现，跳过
+    if (isArray && !line.content.startsWith('-')) break;
+    if (!isArray && line.content.startsWith('-')) break;
+
+    if (isArray) {
+      const body = line.content.slice(1).trim();
+      if (body === '') {
+        // 「- 」后面换行接子块
+        const sub = parseBlock(lines, i + 1, lines[i + 1]?.indent ?? indent + 2);
+        container.push(sub.value);
+        i = sub.next;
+        continue;
+      }
+      const kv = /^([\w$.\-@/]+)\s*:\s*(.*)$/.exec(body);
+      if (kv) {
+        // 「- key: value」开始一个映射，后续同缩进的键并入
+        const itemIndent = line.indent + 2;
+        const item = {};
+        const headKey = kv[1];
+        const headVal = kv[2];
+        if (headVal !== '') {
+          item[headKey] = parseScalar(headVal);
+          i++;
+        } else {
+          const sub = parseBlock(lines, i + 1, lines[i + 1]?.indent ?? itemIndent + 2);
+          item[headKey] = sub.value;
+          i = sub.next;
+        }
+        // 继续吃同一项的其它键
+        while (i < lines.length && lines[i].indent === itemIndent && !lines[i].content.startsWith('-')) {
+          const k2 = /^([\w$.\-@/]+)\s*:\s*(.*)$/.exec(lines[i].content);
+          if (!k2) { i++; continue; }
+          if (k2[2] !== '') {
+            item[k2[1]] = parseScalar(k2[2]);
+            i++;
+          } else {
+            const sub2 = parseBlock(lines, i + 1, lines[i + 1]?.indent ?? itemIndent + 2);
+            item[k2[1]] = sub2.value;
+            i = sub2.next;
+          }
+        }
+        container.push(item);
+        continue;
+      }
+      container.push(parseScalar(body));
+      i++;
+      continue;
+    }
+
+    const kv = /^([\w$.\-@/]+)\s*:\s*(.*)$/.exec(line.content);
+    if (!kv) { i++; continue; }
+    if (kv[2] !== '') {
+      container[kv[1]] = parseScalar(kv[2]);
+      i++;
+    } else {
+      const sub = parseBlock(lines, i + 1, lines[i + 1]?.indent ?? indent + 2);
+      container[kv[1]] = sub.value;
+      i = sub.next;
+    }
+  }
+  return { value: container, next: i };
+}
+
+/** 读 patch 文件 → 顶层数组 */
+async function readPatch() {
+  const text = await fs.readFile(PATCH_FILE, 'utf8').catch(() => '');
+  if (!text.trim()) return [];
+  const lines = meaningfulLines(text);
+  if (!lines.length) return [];
+  const { value } = parseBlock(lines, 0, lines[0].indent);
+  return Array.isArray(value) ? value : [];
+}
+
+/** 把 patch 里的每一行摊平（insert 进来的行也摊平） */
+function flattenRows(patch) {
+  const rows = [];
+  for (const entry of patch) {
+    if (!entry || typeof entry !== 'object') continue;
+    if (Array.isArray(entry.insert)) {
+      for (const row of entry.insert) if (row && typeof row === 'object') rows.push(row);
+    } else if (entry.id || entry.name) {
+      rows.push(entry);
+    }
+  }
+  return rows;
+}
+
+/**
+ * 读 DSH 配的 MCP 服务器。
+ * @returns {Promise<Record<string, object>>} serverName → spec
+ */
+export async function readDshMcpServers() {
+  const rows = flattenRows(await readPatch());
+  const servers = {};
+  for (const row of rows) {
+    const pkg = String(row.name || '');
+    if (!pkg.includes('dsh-mcp-client')) continue;
+    const cfg = row.config || {};
+    const name = cfg.serverName;
+    if (!name) continue;
+    // 转成 AgentFlow mcp.mjs 认的 spec 形状
+    if (cfg.transport === 'stdio') {
+      servers[name] = {
+        command: cfg.command,
+        args: cfg.args || [],
+        env: cfg.env || {},
+        cwd: cfg.cwd,
+        source: 'dsh',
+      };
+    } else {
+      servers[name] = {
+        url: cfg.url,
+        headers: cfg.headers || {},
+        source: 'dsh',
+      };
+    }
+  }
+  return servers;
+}
+
+/** DSH 的技能目录 */
+export function readDshSkillDirs() {
+  return [SKILL_DIR];
+}
+
+// ---------------------------------------------------------------------------
+// 模型目录：只从 bridge 的 GET /catalog 取。
+//
+// 不再读 .credentials.yaml、不再直连各家的 /models、也不再判断「是不是 OpenAI 兼容」——
+// DSH 里能用什么模型，由内核说了算；bridge 侧缓存 ≤10 秒，这里不再加自己的长缓存。
+// ---------------------------------------------------------------------------
+
+/** 最近一次成功读到目录的时间；/api/bridge 用它算 catalogAgeMs */
+let lastCatalogOkAt = 0;
+
+/** 最近一次成功拿到目录距今多久（ms）；从未成功返回 null */
+export function dshCatalogAgeMs() {
+  return lastCatalogOkAt ? Date.now() - lastCatalogOkAt : null;
+}
+
+/** 把 bridge 的 model 条目归一成 AgentFlow 前端认的形状；字段缺了就留空，不编默认值 */
+function normalizeCatalogModel(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const id = typeof raw.id === 'string' ? raw.id : '';
+  if (!id) return null;
+  const levels = Array.isArray(raw.levels) ? raw.levels.filter((x) => typeof x === 'string' && x) : [];
+  return {
+    id,
+    name: typeof raw.name === 'string' && raw.name ? raw.name : id,
+    levels,
+    defaultLevel: typeof raw.defaultLevel === 'string' ? raw.defaultLevel : levels[0] || '',
+  };
+}
+
+/** 把 bridge 的 providers 归一：单条缺 id 的丢掉，models 过滤坏项 */
+export function normalizeCatalogProviders(rawProviders) {
+  if (!Array.isArray(rawProviders)) return [];
+  const out = [];
+  for (const p of rawProviders) {
+    if (!p || typeof p !== 'object') continue;
+    const id = typeof p.id === 'string' ? p.id : '';
+    if (!id) continue;
+    const models = Array.isArray(p.models)
+      ? p.models.map(normalizeCatalogModel).filter(Boolean)
+      : [];
+    out.push({
+      id,
+      label: typeof p.label === 'string' && p.label ? p.label : id,
+      models,
+      error: p.error == null ? null : String(p.error),
+    });
+  }
+  return out;
+}
+
+/**
+ * 读 DSH 实际可用的模型目录（只走 bridge）。
+ * bridge 不可用时返回空 providers + error，不抛错 —— 页面照常能开，只是选不到模型。
+ * @param {string} [dir] bridge 发现文件所在目录
+ * @returns {Promise<{providers: Array, fetchedAt: number, cached: boolean, error?: string}>}
+ */
+export async function readDshModelCatalog(dir = DEFAULT_BRIDGE_DIR) {
+  let body;
+  try {
+    body = await bridgeCatalog(dir);
+  } catch (err) {
+    return {
+      providers: [],
+      fetchedAt: Date.now(),
+      cached: false,
+      error: String((err && err.message) || err),
+    };
+  }
+  lastCatalogOkAt = Date.now();
+  return {
+    providers: normalizeCatalogProviders(body.providers),
+    fetchedAt: lastCatalogOkAt,
+    cached: false,
+  };
+}
+
+/** 一次性读除模型外的 DSH 配置（模型目录由 readDshModelCatalog 单独取，走 bridge） */
+export async function readDshSource() {
+  const mcpServers = await readDshMcpServers();
+  return {
+    mcpServers,
+    skillDirs: readDshSkillDirs(),
+    paths: { patch: PATCH_FILE, skills: SKILL_DIR },
+  };
+}