dsh-plugin-lrc 0.2.0

package/src/runtime.ts

@@ -0,0 +1,305 @@
+/**
+ * LRC 运行时管理：让插件自带 LRC，用户不需要先装桌面端。
+ *
+ * ## 启动顺序
+ *
+ * ```
+ * ① 探测已有 LRC（LRC_BASE / 3099 端口）→ 有就用（external）
+ * ② 检查缓存里的二进制 → 没有就下载（镜像 + SHA256 校验）
+ * ③ 启动隔离实例（独立数据目录 + 随机空闲端口）→ managed
+ * ④ 任一步失败 → degraded（纯客户端模式，卸载静默跳过）
+ * ```
+ *
+ * ## 数据隔离
+ *
+ * 插件自己的实例用 `$DSH_HOME/cache/lrc-plugin/data`，
+ * **绝不**写进用户的 `~/.loong-recall/global/data`。
+ */
+import { createHash } from 'node:crypto';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { createServer } from 'node:net';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, platform, arch } from 'node:os';
+import { join } from 'node:path';
+
+export type RuntimeMode = 'external' | 'managed' | 'degraded';
+
+export interface RuntimeResult {
+  mode: RuntimeMode;
+  baseUrl: string;
+  /** degraded 时给出可读原因 */
+  reason?: string;
+}
+
+/**
+ * 二进制清单：`<platform>-<arch>` → `{ file, sha256 }`。
+ *
+ * 文件名带版本号（`lrc-v0.10.0-...`），配合 `BINARY_RELEASE` 拼出**固定 URL**：
+ * `releases/download/v0.10.0/<file>`。这样不会因为 `latest` 漂移而拿到未校验的版本。
+ *
+ * **每次 LRC 发版都要更新这里**（文件名 + SHA256 + BINARY_RELEASE）。
+ * 后续可加一个 Action 自动回写，见 docs/PLAN.md §2.3。
+ */
+export const BINARY_RELEASE = 'v0.10.0';
+
+export const BINARY_MANIFEST: Record<string, { file: string; sha256: string }> = {
+  'win32-x64': {
+    file: 'lrc-v0.10.0-windows-x86_64.exe',
+    sha256: '005fcad2e4e61e77b8efd15d43d37a7c39d73d4e4eff1fdbf8107b8bd30951d4',
+  },
+  'darwin-arm64': {
+    file: 'lrc-v0.10.0-macos-arm64',
+    sha256: 'd1fcfbb52f02a24d9cd277981b43884fd16e71ed8d5c7f1c8f2b918e4a8bce62',
+  },
+  'linux-x64': {
+    file: 'lrc-v0.10.0-linux-x86_64',
+    sha256: '2e6fd027c2f0c76a98f4970278e321fa39543860d3e446fc303df5950a3f15e0',
+  },
+};
+
+const DEFAULT_MIRRORS = [
+  `https://github.com/zhibaiYingChuan/LRC/releases/download/${BINARY_RELEASE}`,
+  `https://ghproxy.net/https://github.com/zhibaiYingChuan/LRC/releases/download/${BINARY_RELEASE}`,
+];
+
+export interface RuntimeOptions {
+  /**
+   * 显式指定已有 LRC 实例（优先于 `LRC_BASE` 环境变量与本地探测）。
+   *
+   * 来自插件配置 `baseUrl`。此前只认环境变量，导致 `cordis.patch.yml`
+   * 里写 `baseUrl: http://127.0.0.1:3111` 不生效，永远打到 3099。
+   */
+  baseUrl?: string;
+  /** 缓存根目录，默认 `$DSH_HOME/cache/lrc-plugin` */
+  cacheDir?: string;
+  /** 额外镜像前缀（优先于内置镜像） */
+  mirror?: string;
+  /** 日志回调 */
+  log?: (message: string) => void;
+  /** 健康检查超时（毫秒） */
+  healthTimeoutMs?: number;
+  /** 覆盖二进制清单（测试用：可注入错误哈希验证降级） */
+  manifest?: Record<string, { file: string; sha256: string }>;
+  /** 覆盖 Release 版本（测试用） */
+  release?: string;
+  /** 是否探测本地 3099 端口（测试用：置 false 可强制走下载路径） */
+  probeLocal?: boolean;
+}
+
+function defaultCacheDir(): string {
+  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh');
+  return join(dshHome, 'cache', 'lrc-plugin');
+}
+
+function platformKey(): string {
+  return `${platform()}-${arch()}`;
+}
+
+function binaryName(): string {
+  return platform() === 'win32' ? 'lrc-sidecar.exe' : 'lrc-sidecar';
+}
+
+/** 找一个空闲端口。 */
+function findFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      if (address === null || typeof address === 'string') {
+        server.close();
+        reject(new Error('无法获取空闲端口'));
+        return;
+      }
+      const { port } = address;
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+async function isHealthy(baseUrl: string, timeoutMs = 3000): Promise<boolean> {
+  try {
+    const response = await fetch(`${baseUrl}/health`, {
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export class LrcRuntime {
+  private readonly cacheDir: string;
+  private readonly mirror?: string;
+  private readonly log: (message: string) => void;
+  private readonly healthTimeoutMs: number;
+  private readonly manifest: Record<string, { file: string; sha256: string }>;
+  private readonly mirrors: string[];
+  private readonly probeLocal: boolean;
+  /** 显式实例地址：配置 `baseUrl` 优先，其次 `LRC_BASE` 环境变量。 */
+  private readonly explicitBase?: string;
+  private child: ChildProcess | null = null;
+  private result: RuntimeResult | null = null;
+
+  constructor(options: RuntimeOptions = {}) {
+    this.explicitBase = options.baseUrl?.trim() || process.env.LRC_BASE;
+    this.cacheDir = options.cacheDir ?? defaultCacheDir();
+    this.mirror = options.mirror ?? process.env.LRC_MIRROR;
+    this.log = options.log ?? (() => {});
+    this.healthTimeoutMs = options.healthTimeoutMs ?? 15_000;
+    this.manifest = options.manifest ?? BINARY_MANIFEST;
+    this.probeLocal = options.probeLocal ?? true;
+    const release = options.release ?? BINARY_RELEASE;
+    this.mirrors = [
+      `https://github.com/zhibaiYingChuan/LRC/releases/download/${release}`,
+      `https://ghproxy.net/https://github.com/zhibaiYingChuan/LRC/releases/download/${release}`,
+    ];
+  }
+
+  /** 幂等：多次调用只启动一次。 */
+  async ensure(): Promise<RuntimeResult> {
+    if (this.result !== null) return this.result;
+
+    // ① 已有实例（配置 baseUrl > LRC_BASE 环境变量）
+    const explicit = this.explicitBase;
+    if (explicit) {
+      if (await isHealthy(explicit)) {
+        this.result = { mode: 'external', baseUrl: explicit.replace(/\/+$/, '') };
+        this.log(`[lrc] 复用已有实例：${this.result.baseUrl}`);
+        return this.result;
+      }
+      // 显式指定了却连不上：**直接降级，不回落 3099**。
+      // 回落会让"配了 3111 却打到 3099"，违反端口纪律，且用户无从察觉。
+      this.result = {
+        mode: 'degraded',
+        baseUrl: explicit.replace(/\/+$/, ''),
+        reason: `配置的实例不可用：${explicit}`,
+      };
+      this.log(`[lrc] 降级：${this.result.reason}`);
+      return this.result;
+    }
+    const local = 'http://127.0.0.1:3099';
+    if (this.probeLocal && (await isHealthy(local))) {
+      this.result = { mode: 'external', baseUrl: local };
+      this.log(`[lrc] 复用本地实例：${local}`);
+      return this.result;
+    }
+
+    // ② 准备二进制
+    let binary: string;
+    try {
+      binary = await this.ensureBinary();
+    } catch (error) {
+      this.result = {
+        mode: 'degraded',
+        baseUrl: explicit ?? local,
+        reason: `LRC 二进制不可用：${error instanceof Error ? error.message : String(error)}`,
+      };
+      this.log(`[lrc] 降级：${this.result.reason}`);
+      return this.result;
+    }
+
+    // ③ 启动隔离实例
+    try {
+      const port = await findFreePort();
+      const dataDir = join(this.cacheDir, 'data');
+      mkdirSync(dataDir, { recursive: true });
+      this.child = spawn(binary, ['--port', String(port), '--data-dir', dataDir], {
+        stdio: 'ignore',
+        detached: false,
+      });
+      this.child.on('error', (error) => this.log(`[lrc] 子进程错误：${error.message}`));
+
+      const baseUrl = `http://127.0.0.1:${port}`;
+      const deadline = Date.now() + this.healthTimeoutMs;
+      while (Date.now() < deadline) {
+        if (await isHealthy(baseUrl, 1000)) {
+          this.result = { mode: 'managed', baseUrl };
+          this.log(`[lrc] 已启动隔离实例：${baseUrl}（数据目录 ${dataDir}）`);
+          return this.result;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 300));
+      }
+      throw new Error(`健康检查超时（${this.healthTimeoutMs}ms）`);
+    } catch (error) {
+      this.stop();
+      this.result = {
+        mode: 'degraded',
+        baseUrl: explicit ?? local,
+        reason: `LRC 启动失败：${error instanceof Error ? error.message : String(error)}`,
+      };
+      this.log(`[lrc] 降级：${this.result.reason}`);
+      return this.result;
+    }
+  }
+
+  /** 确保二进制存在且校验通过。 */
+  private async ensureBinary(): Promise<string> {
+    const key = platformKey();
+    const entry = this.manifest[key];
+    if (entry === undefined) {
+      throw new Error(
+        `没有 ${key} 的二进制清单。请手动安装 LRC 桌面端，或设置 LRC_BASE 指向已有实例。`,
+      );
+    }
+
+    const binDir = join(this.cacheDir, 'bin');
+    const target = join(binDir, binaryName());
+    mkdirSync(binDir, { recursive: true });
+
+    if (existsSync(target) && this.verify(target, entry.sha256)) {
+      return target;
+    }
+
+    const mirrors = this.mirror ? [this.mirror, ...this.mirrors] : this.mirrors;
+    let lastError: unknown = null;
+    let hashMismatch = false;
+    for (const mirror of mirrors) {
+      const url = `${mirror.replace(/\/+$/, '')}/${entry.file}`;
+      try {
+        this.log(`[lrc] 下载 ${url}`);
+        const response = await fetch(url, { signal: AbortSignal.timeout(120_000) });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        writeFileSync(target, buffer);
+        if (!this.verify(target, entry.sha256)) {
+          rmSync(target, { force: true });
+          hashMismatch = true;
+          throw new Error('SHA256 校验失败');
+        }
+        if (platform() !== 'win32') chmodSync(target, 0o755);
+        return target;
+      } catch (error) {
+        lastError = error;
+        this.log(`[lrc] 镜像失败（${mirror}）：${error instanceof Error ? error.message : error}`);
+      }
+    }
+    // 哈希不符是**安全信号**，优先级高于网络错误：必须让用户看到真正的原因
+    if (hashMismatch) {
+      throw new Error(
+        `SHA256 校验失败（期望 ${entry.sha256.slice(0, 12)}…）。` +
+          '文件可能被篡改或清单过期，已删除下载内容。',
+      );
+    }
+    throw new Error(
+      `所有镜像均失败：${lastError instanceof Error ? lastError.message : String(lastError)}`,
+    );
+  }
+
+  private verify(file: string, expected: string): boolean {
+    try {
+      const actual = createHash('sha256').update(readFileSync(file)).digest('hex');
+      return actual === expected.toLowerCase();
+    } catch {
+      return false;
+    }
+  }
+
+  /** 停止托管实例（插件卸载时调用）。 */
+  stop(): void {
+    if (this.child !== null && !this.child.killed) {
+      this.child.kill();
+      this.child = null;
+    }
+  }
+}

package/src/session-text.ts

@@ -0,0 +1,188 @@
+/**
+ * 从 DSH 会话事件里抽文本。
+ *
+ * 单独成模块的原因：这里全是纯函数，不依赖 `@deepseek-ai/*`，
+ * 因此可以在没有 DSH 运行时的环境下直接单测（见 `scripts/e2e-host-payload.ts`）。
+ *
+ * ## 真实结构（来自 app.asar 内 `@deepseek-ai/dsh-session`）
+ *
+ * ```
+ * Session      = { id, log: SessionEvent[], surface, header, requestHeader() }
+ * SessionEvent = { type, seq, time, data, surfaceOp }
+ * assistant/message → data.message.content
+ * user/message      → data.content
+ * ```
+ *
+ * 注意 `Session` **没有 `lines` 字段** —— 早期实现读 `agent.session.lines`
+ * 恒为 `[]`，导致自动沉淀静默空转。
+ */
+import { hasConstraintMarker } from './memory-filter.ts';
+import { classifyEvent, isRealUserEvent } from './event-classify.ts';
+
+/** 取 assistant 消息的 content（兼容 `data.message` 与旧版 `message`）。 */
+export function messageContent(event: unknown): unknown {
+  const candidate = event as {
+    type?: string;
+    data?: { message?: { content?: unknown } };
+    message?: { content?: unknown };
+  };
+  if (candidate?.type !== 'assistant/message') return undefined;
+  return candidate.data?.message?.content ?? candidate.message?.content;
+}
+
+/**
+ * 从消息内容里抽纯文本：正文块优先，没有正文时退回推理块。
+ *
+ * DSH 里大量 assistant 消息只有 `reasoning` + `tool-call`，没有 `text` 块，
+ * 只认 `text` 会让沉淀计数器几乎不增长，8 轮阈值永远到不了。
+ */
+export function textFromContent(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const texts: string[] = [];
+  const fallbacks: string[] = [];
+  for (const block of content) {
+    const b = block as { type?: string; text?: unknown; reasoning?: unknown };
+    const value =
+      typeof b?.text === 'string' ? b.text : typeof b?.reasoning === 'string' ? b.reasoning : '';
+    if (value.length === 0) continue;
+    if (b?.type === 'text') texts.push(value);
+    else fallbacks.push(value);
+  }
+  return (texts.length > 0 ? texts : fallbacks).join('\n');
+}
+
+/**
+ * 只取正文块（`type === 'text'`），**不含推理**。
+ *
+ * 沉淀源必须用这个：推理流是模型的内部思考，写进长期记忆就是噪声。
+ * 实测一个会话因此写进 92 条垃圾，去重率约 1%。
+ */
+export function textBlocksOnly(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  const texts: string[] = [];
+  for (const block of content) {
+    const b = block as { type?: string; text?: unknown };
+    if (b?.type === 'text' && typeof b.text === 'string' && b.text.length > 0) texts.push(b.text);
+  }
+  return texts.join('\n');
+}
+
+/**
+ * 只取推理块（`type === 'reasoning'`）。
+ *
+ * 工具密集型轮次里 assistant 往往只有 reasoning + tool-call，没有正文。
+ * 这类轮次无法靠 `<lrc_memory>` 标签沉淀，只能在轮末从推理里抽结论句兜底。
+ * 注意：**不能整段入库** —— 实测整段推理会写进 92 条垃圾，去重率约 1%。
+ */
+export function reasoningBlocksOnly(content: unknown): string {
+  if (!Array.isArray(content)) return '';
+  const texts: string[] = [];
+  for (const block of content) {
+    const b = block as { type?: string; text?: unknown };
+    if (b?.type === 'reasoning' && typeof b.text === 'string' && b.text.length > 0) {
+      texts.push(b.text);
+    }
+  }
+  return texts.join('\n');
+}
+
+/**
+ * 是否存在**结构异常**的文本块：声明了 `text` / `reasoning` 但 `text` 不是字符串。
+ *
+ * 纯 tool-call 消息本来就没有这两类块，不该报警 —— 之前的告警条件
+ * 「有内容块却既无 text 又无 reasoning」把 39 条纯工具调用消息全算成异常。
+ */
+export function hasMalformedTextBlock(content: unknown): boolean {
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => {
+    const b = block as { type?: string; text?: unknown };
+    return (b?.type === 'text' || b?.type === 'reasoning') && typeof b.text !== 'string';
+  });
+}
+
+/** 从单条事件里取 assistant 文本（正文优先，其次推理）；仅用于计数与诊断。 */
+export function extractAssistantText(event: unknown): string {
+  return textFromContent(messageContent(event));
+}
+
+/**
+ * 消息里是否有**可提取**的内容块。
+ *
+ * 只认 `text` / `reasoning`：纯 `tool-call` 消息本来就没有正文，
+ * 把它算作"有内容块"会让告警在每次工具调用时误报。
+ */
+export function hasContentBlocks(event: unknown): boolean {
+  const content = messageContent(event);
+  if (typeof content === 'string') return content.length > 0;
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => {
+    const b = block as { type?: string };
+    return b?.type === 'text' || b?.type === 'reasoning';
+  });
+}
+
+/**
+ * 是否是用户真正说的话。
+ *
+ * DSH 的 `user/message` 事件里 `data.source.kind` 有多种取值：
+ * `user` / `skill-catalog` / `runtime-context` / `time-context` / `model-selection`。
+ * 只有 `user` 是用户输入，其余都是宿主注入的上下文 —— 实测一份技能目录
+ * 就有 12K 字符，混进沉淀源会直接写满 `maxItems`。
+ *
+ * 没有 `source` 字段时按用户消息处理（兼容旧格式）。
+ */
+export function isRealUserMessage(event: unknown): boolean {
+  // 判定统一走 event-classify.ts，避免各模块各写一套
+  return isRealUserEvent(event);
+}
+
+/**
+ * 用户消息里的**强约束词**。
+ *
+ * 用户消息是指令，不是结论。只有带约束信号的发言才值得进沉淀源 ——
+ * 否则「根据这个文档配色」这类任务描述会被 distill 当成约束入库
+ * （实测：文件名里的「规范」二字命中约定词表，整条指令被存成 `[约束]`）。
+ *
+ * 词表与路径预处理统一在 `memory-filter.ts`（`CONSTRAINT_WORDS` /
+ * `hasConstraintMarker`）：先挖掉路径 token 再匹配，避免 `docs/禁止事项.md`
+ * 里的「禁止」把纯任务指令放进门槛。
+ */
+export function hasUserConstraint(text: string): boolean {
+  return hasConstraintMarker(text);
+}
+
+/**
+ * 从 `agent.session.log` 投影出对话文本行。
+ *
+ * `log` 是 append-only 的事件数组，正好满足游标"按行号推进"的前提。
+ */
+export function linesFromSession(session: unknown): string[] {
+  const log = (session as { log?: unknown })?.log;
+  if (!Array.isArray(log)) return [];
+  const lines: string[] = [];
+  for (const raw of log) {
+    const event = raw as {
+      type?: string;
+      data?: { message?: { content?: unknown }; content?: unknown };
+    };
+    const category = classifyEvent(event);
+    if (category === 'assistant') {
+      // 只取正文块：推理流不进沉淀源（否则会把内部思考写成长期记忆）
+      const text = textBlocksOnly(event.data?.message?.content);
+      if (text.length > 0) lines.push(text);
+    } else if (category === 'user') {
+      // `user/message` 不只装用户说的话：DSH 会把技能目录、运行时上下文、
+      // 时间上下文、模型切换通知都塞进同一个事件类型，靠 `data.source.kind` 区分。
+      // 不过滤的话，一份 12K 字符的技能目录会被当成用户发言送进 distill。
+      if (!isRealUserMessage(event)) continue;
+      const text = textBlocksOnly(event.data?.content);
+      if (text.length === 0) continue;
+      // 用户消息是指令，不是结论：只有含强约束词才进沉淀源。
+      if (!hasUserConstraint(text)) continue;
+      lines.push(text);
+    }
+  }
+  return lines;
+}