dsh-code-server-app 0.3.58 → 0.3.63

package/assets/extensions/dshcs-editor-bridge/lib/fim-completion.js

@@ -0,0 +1,264 @@
+// dshcs-editor-bridge / lib/fim-completion.js —— 纯逻辑:FIM 补全的请求决策与载荷构造
+//
+// 来源与许可:本文件**为独立实现,不含 continuedev/continue 的源码**;其门控/窗口/缓存的设计与
+// 设置项划分**参考**了该项目(Apache License 2.0, Copyright 2023 Continue)。详见 `THIRD_PARTY_NOTICES.md`。
+//
+// **不 require('vscode')**:入参都是纯文本/数字,所以能在没有 VS Code 的环境里单测
+// (scripts/test-fim.mjs 就是这么用的)。与编辑器交互的部分在 extension.js(glue)里。
+//
+// 这个文件回答三个问题(顺序就是补全一次要过的三关):
+//   1. **该不该问**(`shouldRequest`)—— 模型在被问到"不该补的地方"时会硬凑(实测 2/2),
+//      所以"不值得问"必须在**发请求之前**判掉,而不是拿到回答再丢;
+//   2. **问什么**(`buildPayload`)—— 只送光标附近的窗口,不是整份文件;
+//   3. **问过没有**(`createCompletionCache`)—— 同样的前后文重复问是纯浪费(实测 temperature=0
+//      下两次回答逐字相同 ⇒ 缓存命中率会很高)。
+//
+// 窗口常量与宿主侧 `lib/fim-adapter.mjs` **同名同值**:扩展是随包分发的静态文件、不能 import
+// 宿主代码,所以一致性靠 scripts/test-fim.mjs 的断言钉住(与 bridge-client.js 的桥常量同一套做法)。
+
+'use strict';
+
+/** 与宿主 lib/fim-adapter.mjs 保持一致(改一边就要改另一边,测试会拦)。 */
+const FIM_MAX_PREFIX_CHARS = 6000;
+const FIM_MAX_SUFFIX_CHARS = 2000;
+const FIM_MAX_PREFIX_LINES = 120;
+const FIM_MAX_SUFFIX_LINES = 40;
+
+/** 停顿多久才真的发请求(毫秒)。打字过程中的请求全是浪费,而且会被宿主的速率闸挡掉。 */
+const FIM_DEBOUNCE_MS = 250;
+
+/** 超过这个行数的文档不参与补全(大文件里补全的收益低;用行数而不是字符数是为了避免
+ *  每次击键都 `document.getText()` 把整份文档摸一遍)。 */
+const FIM_MAX_DOCUMENT_LINES = 20000;
+
+/** 缓存条目上限与有效期(键 = 前后文指纹;命中直接给结果,不再问模型)。 */
+const FIM_CACHE_MAX = 24;
+const FIM_CACHE_TTL_MS = 120000;
+
+/** 把文本裁到窗口内(与宿主侧 `trimWindow` 同语义:字符与行数取先到者)。 */
+function trimWindow(text, maxChars, maxLines, fromEnd) {
+  if (typeof text !== 'string' || text === '') return '';
+  let out = text;
+  if (maxLines > 0) {
+    const split = out.split('\n');
+    if (split.length > maxLines) out = (fromEnd ? split.slice(split.length - maxLines) : split.slice(0, maxLines)).join('\n');
+  }
+  if (maxChars > 0 && out.length > maxChars) out = fromEnd ? out.slice(out.length - maxChars) : out.slice(0, maxChars);
+  return out;
+}
+
+/**
+ * 该不该为这次光标位置请求补全。
+ *
+ * 判据都是"**便宜且不会错判**"的那些 —— 宁可不补,也不要补错(补错一次,用户就关掉它)。
+ *
+ * @param {{selectionEmpty: boolean, scheme: string, lineCount: number,
+ *          prefixText: string, suffixText: string, lineTextBefore: string}} input
+ * @returns {{ask: boolean, reason: string}}
+ */
+function shouldRequest(input) {
+  const value = input === null || input === undefined ? {} : input;
+  if (value.selectionEmpty !== true) return { ask: false, reason: '有选区(用户在选中内容,不是在打字)' };
+  if (value.scheme !== 'file') return { ask: false, reason: `非文件文档(${value.scheme ?? '未知'})` };
+  if (!(Number.isFinite(value.lineCount) && value.lineCount > 0)) return { ask: false, reason: '空文档' };
+  if (value.lineCount > FIM_MAX_DOCUMENT_LINES) return { ask: false, reason: '文档过大' };
+  if (typeof value.prefixText !== 'string' || typeof value.suffixText !== 'string') return { ask: false, reason: '拿不到前后文' };
+  // 光标前整行都是空白、且前面也没有内容 ⇒ 没什么可续的(新建的空文件、文件开头按回车)。
+  if (typeof value.lineTextBefore === 'string' && value.lineTextBefore.trim() === '') {
+    if (value.prefixText.trim() === '' && value.suffixText.trim() === '') return { ask: false, reason: '空上下文' };
+  }
+  return { ask: true, reason: 'ok' };
+}
+
+/** 前后文的指纹(缓存键):只看窗口内的内容,与路径/语言一起构成键。 */
+function fingerprint(prefix, suffix, language) {
+  const text = `${language ?? ''}\u0000${prefix ?? ''}\u0000${suffix ?? ''}`;
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${text.length}:${(hash >>> 0).toString(36)}`;
+}
+
+/**
+ * 构造发往宿主的载荷(只含窗口内的前后文)。
+ * @returns {{prompt: string, suffix: string, language: string, path: string}}
+ */
+function buildPayload({ prefixText, suffixText, language, path }) {
+  return {
+    prompt: trimWindow(prefixText ?? '', FIM_MAX_PREFIX_CHARS, FIM_MAX_PREFIX_LINES, true),
+    suffix: trimWindow(suffixText ?? '', FIM_MAX_SUFFIX_CHARS, FIM_MAX_SUFFIX_LINES, false),
+    language: typeof language === 'string' ? language : '',
+    path: typeof path === 'string' ? path : '',
+  };
+}
+
+/** 有界 + 带 TTL 的结果缓存。 */
+function createCompletionCache({ max = FIM_CACHE_MAX, ttlMs = FIM_CACHE_TTL_MS, now = () => Date.now() } = {}) {
+  const store = new Map();
+  return {
+    get(key) {
+      const hit = store.get(key);
+      if (hit === undefined) return null;
+      if (now() - hit.at > ttlMs) {
+        store.delete(key);
+        return null;
+      }
+      store.delete(key);
+      store.set(key, hit);
+      return hit.text;
+    },
+    set(key, text) {
+      if (typeof key !== 'string' || key === '' || typeof text !== 'string') return false;
+      store.delete(key);
+      store.set(key, { text, at: now() });
+      while (store.size > max) {
+        const oldest = store.keys().next();
+        if (oldest.done === true) break;
+        store.delete(oldest.value);
+      }
+      return true;
+    },
+    size() {
+      return store.size;
+    },
+    clear() {
+      store.clear();
+    },
+  };
+}
+
+/** 数字 → 状态栏用短串(1.2k / 12k / 1.2M)。 */
+function formatTokens(n) {
+  if (!Number.isFinite(n) || n <= 0) return '0';
+  if (n < 1000) return String(Math.round(n));
+  if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1000000) return `${Math.round(n / 1000)}k`;
+  return `${(n / 1000000).toFixed(1)}M`;
+}
+
+/** 状态栏 tooltip 里那段 FIM 说明(纯字符串组装,便于单测)。 */
+function describeFimUsage(fim) {
+  if (fim === null || typeof fim !== 'object') return [];
+  if (fim.enabled !== true) return ['FIM 补全:已关闭(设置里可开,实验性)'];
+  const lines = [
+    `FIM 补全(实验性):已开启${fim.available === false ? ` —— 不可用:${fim.reason ?? '原因未知'}` : ''}`,
+    `调用 ${fim.calls ?? 0} 次(成功 ${fim.ok ?? 0}/失败 ${fim.failed ?? 0})`,
+    `输入 ${formatTokens(fim.inputTokens)} tok · 输出 ${formatTokens(fim.outputTokens)} tok · 缓存命中 ${formatTokens(fim.cacheReadTokens)} tok`,
+    `停顿 ${Number.isFinite(fim.debounceMs) ? Math.round(fim.debounceMs) : FIM_DEBOUNCE_DEFAULT_MS}ms · `
+      + `${fim.multiline === false ? '仅单行' : '允许多行'}`
+      + `${Array.isArray(fim.disableGlobs) && fim.disableGlobs.length > 0 ? ` · 禁用 ${fim.disableGlobs.length} 条 glob` : ''}`,
+  ];
+  if (Number.isFinite(fim.lastMs)) lines.push(`最近一次 ${Math.round(fim.lastMs)}ms`);
+  if (typeof fim.lastError === 'string' && fim.lastError !== '') lines.push(`最近错误:${fim.lastError}`);
+  return lines;
+}
+
+// ---------------------------------------------------------------- 与宿主同语义的两件小事
+//
+// 为什么在这里**再实现一遍**:扩展是随包分发的静态文件,不能 import 宿主代码(ESM/CJS + 树内外),
+// 而这两个判据必须在"发请求之前/收响应之后"本地生效 —— 一致性由 scripts/test-fim.mjs 用同一组
+// 语料对两边做等价断言(与桥常量、窗口常量同一套做法)。
+
+/** 与宿主 lib/fim-adapter.mjs 的 FIM_DEBOUNCE_DEFAULT_MS 同值(宿主会在 /sync 里给实际值)。 */
+const FIM_DEBOUNCE_DEFAULT_MS = 250;
+
+/** 解析 glob 清单(与宿主 compileGlobList 同语义)。 */
+function compileGlobList(text) {
+  if (typeof text !== 'string' || text.trim() === '') return [];
+  const seen = new Set();
+  const out = [];
+  for (const raw of text.split(/[;,\s]+/)) {
+    const item = raw.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    if (item === '' || seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+
+/** glob → 正则(与宿主 globToRegExp 同语义:`*` 不跨目录、`**` 跨目录、不含 `/` 只匹配文件名)。 */
+function globToRegExp(glob) {
+  let g = typeof glob === 'string' ? glob.trim().replace(/\\/g, '/').replace(/^\.\//, '') : '';
+  if (g === '') return null;
+  if (g.endsWith('/')) g += '**';
+  const anchored = g.includes('/');
+  let out = '';
+  for (let i = 0; i < g.length; i += 1) {
+    const ch = g[i];
+    if (ch === '*') {
+      if (g[i + 1] === '*') {
+        if (g[i + 2] === '/') {
+          out += '(?:.*/)?';
+          i += 2;
+        } else {
+          out += '.*';
+          i += 1;
+        }
+      } else {
+        out += '[^/]*';
+      }
+    } else if (ch === '?') {
+      out += '[^/]';
+    } else {
+      out += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+  }
+  return { re: new RegExp(`^${out}$`), anchored };
+}
+
+/** 路径是否命中禁用清单(返回命中的模式或 null)。
+ *  含 `/` 的模式按**完整路径与各层尾段**各试一次(与宿主 lib/fim-adapter.mjs 同语义:
+ *  用户写 `vendor/**` 的直觉是"任何层级下的 vendor",而绝对路径永远以 `/` 或盘符开头)。 */
+function matchDisabledGlob(filePath, globs) {
+  if (typeof filePath !== 'string' || filePath === '') return null;
+  const list = Array.isArray(globs) ? globs : compileGlobList(globs);
+  if (list.length === 0) return null;
+  const full = filePath.replace(/\\/g, '/');
+  const slash = full.lastIndexOf('/');
+  const base = slash === -1 ? full : full.slice(slash + 1);
+  for (const glob of list) {
+    const parsed = globToRegExp(glob);
+    if (parsed === null) continue;
+    if (!parsed.anchored) {
+      if (parsed.re.test(base)) return glob;
+      continue;
+    }
+    if (parsed.re.test(full)) return glob;
+    for (let i = full.indexOf('/'); i !== -1; i = full.indexOf('/', i + 1)) {
+      if (parsed.re.test(full.slice(i + 1))) return glob;
+    }
+  }
+  return null;
+}
+
+/** 只保留第一行(宿主在关掉多行时也会做;这里是第二道)。 */
+function toSingleLine(text) {
+  if (typeof text !== 'string' || text === '') return '';
+  const first = text.split('\n')[0];
+  return first.trim() === '' ? '' : first;
+}
+
+module.exports = {
+  FIM_MAX_PREFIX_CHARS,
+  FIM_MAX_SUFFIX_CHARS,
+  FIM_MAX_PREFIX_LINES,
+  FIM_MAX_SUFFIX_LINES,
+  FIM_DEBOUNCE_MS,
+  FIM_DEBOUNCE_DEFAULT_MS,
+  FIM_MAX_DOCUMENT_LINES,
+  FIM_CACHE_MAX,
+  FIM_CACHE_TTL_MS,
+  trimWindow,
+  shouldRequest,
+  fingerprint,
+  buildPayload,
+  createCompletionCache,
+  formatTokens,
+  describeFimUsage,
+  compileGlobList,
+  globToRegExp,
+  matchDisabledGlob,
+  toSingleLine,
+};

package/assets/extensions/dshcs-editor-bridge/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dshcs-editor-bridge",
   "displayName": "DSH Editor Bridge",
-  "description": "只读地把编辑器状态(未保存缓冲区、诊断、活动选区)提供给 DSH;右键提问打开 DSH 页面里的悬浮对话对话框(0.2.5;老宿主退回编辑器面板),正文/思考/上下文都用 DSH 官方渲染器,并可就地回答授权请求。由 dsh-code-server-app 插件安装,可禁用。",
-  "version": "0.2.17",
+  "description": "对工作区只读地把编辑器状态(未保存缓冲区、诊断、活动选区)提供给 DSH(不写文件、不执行命令);右键提问打开 DSH 页面里的悬浮对话对话框(0.3.59 起是唯一路径:面板在插件客户端半部,正文/思考/上下文都用页面模块表里的官方渲染器,并可就地回答授权请求;拿不到对话框心跳时只给一条提示)。由 dsh-code-server-app 插件安装,可禁用。另有**实验性**的 FIM 内联补全(灰字续写):默认关闭,在插件设置卡里开启;关闭时本扩展连 provider 都不注册,不会发出任何补全请求。",
+  "version": "0.2.20",
   "publisher": "dsh-code-server-app",
   "license": "MIT",
   "private": true,

package/lib/bridge-session.mjs

@@ -140,6 +140,37 @@ export function pickAgent(ctx) {
   return null;
 }
 
+/**
+ * 忙碌时按 Enter 的投递方式 —— **跟着 DSH 自己的设置走**。
+ *
+ * DSH 的对话插件把这个偏好放在 `ui-conversation` 命名空间的 `busyEnter` 字段
+ * (`dsh-client-ui-conversation` 契约:`BUSY_ENTER_BEHAVIORS = ['queue','steer']`,默认 `'queue'`),
+ * 用户在 设置 → 对话 里改的就是它。面板里按 Enter 与主界面按 Enter 是同一个手势,所以这里读同一个值:
+ *   - `'steer'` ⇒ `agent.steer(msg)`(DSH 契约:"an idle driver starts a turn; a running driver
+ *     consumes it at its **next step boundary**")—— 正在跑的那一轮就能看到你的追问;
+ *   - `'queue'` ⇒ `agent.followup(msg)`(契约:"becomes the sole ordinary message of **its own turn**")
+ *     —— 排到下一轮,不打扰当前轮。
+ *
+ * 读法走官方 API `ctx.settings.get(ns)`(宿主侧 `@deepseek-ai/dsh-settings` 的契约:
+ * "Read one registered namespace's resolved value")。读不到(命名空间没注册 / 极简组合 / 老版本 DSH)
+ * 一律回默认 `'queue'`,并且**逐项特性探测** `agent.steer` 是否存在 —— 探测失败绝不抛。
+ *
+ * @param {object} ctx cordis 上下文
+ * @returns {'queue'|'steer'}
+ */
+export function pickBusyEnter(ctx) {
+  const settings = getService(ctx, 'settings');
+  if (settings === undefined || settings === null || typeof settings.get !== 'function') return 'queue';
+  try {
+    const section = settings.get('ui-conversation');
+    const value = section !== null && typeof section === 'object' ? section.busyEnter : undefined;
+    return value === 'steer' ? 'steer' : 'queue';
+  } catch {
+    // 未注册的命名空间在多数实现里是 undefined,但契约允许实现抛 —— 一律当默认值
+    return 'queue';
+  }
+}
+
 /**
  * 投递一条编辑器消息。
  *
@@ -148,9 +179,10 @@ export function pickAgent(ctx) {
  *
  * @param {object} ctx cordis 上下文
  * @param {object} input `composeEditorPrompt` 的输入
- * @returns {Promise<{ok: boolean, code?: string, error?: string, sessionId?: string, text?: string}>}
+ * @param {{delivery?: 'queue'|'steer'}} [options] 投递方式(缺省按 DSH 设置推导,见 pickBusyEnter)
+ * @returns {Promise<{ok: boolean, code?: string, error?: string, sessionId?: string, text?: string, delivery?: string}>}
  */
-export async function deliverEditorPrompt(ctx, input) {
+export async function deliverEditorPrompt(ctx, input, options = {}) {
   const createUserMessage = await loadDshExport('@deepseek-ai/dsh-llm', 'createUserMessage');
   if (typeof createUserMessage !== 'function') {
     return { ok: false, code: 'NO_LLM', error: '解析不到 @deepseek-ai/dsh-llm 的 createUserMessage(DSH 部署不完整?)' };
@@ -174,9 +206,24 @@ export async function deliverEditorPrompt(ctx, input) {
   } catch (err) {
     return { ok: false, code: 'BAD_MESSAGE', error: `构造消息失败:${err && err.message ? err.message : String(err)}` };
   }
+  // 请求方可以显式指定(queue/steer);没指定就跟着 DSH 的 `ui-conversation.busyEnter` 走。
+  const requested = options.delivery === 'steer' || options.delivery === 'queue' ? options.delivery : null;
+  const busy = agent.status === 'running';
+  let delivery = requested ?? pickBusyEnter(ctx);
+  // 空闲时两者等价(DSH 契约:steer 在空闲驱动上同样"starts a turn"),但**空闲一律走 followup** ——
+  // 语义最直白,也不依赖 steer 存在。
+  if (!busy) delivery = 'queue';
+  // steer 是 0.3.59 才用到的 API:老宿主没有它时静默退回 queue,绝不因为"设置里写了 steer"就投不出去。
+  if (delivery === 'steer' && typeof agent.steer !== 'function') delivery = 'queue';
   try {
-    // followup = 下一轮 + 唤醒:agent 空闲就立刻开一轮,在跑就排队,两种情况用户都能看到。
-    agent.followup(message);
+    if (delivery === 'steer') {
+      // steer = "Submit steering for the nearest step":正在跑的那一轮会在下一个 step 边界领取它,
+      // 所以追问能当轮被看到(而不是等下一轮)。
+      agent.steer(message);
+    } else {
+      // followup = 下一轮 + 唤醒:agent 空闲就立刻开一轮,在跑就排队,两种情况用户都能看到。
+      agent.followup(message);
+    }
   } catch (err) {
     return { ok: false, code: 'DELIVER_FAILED', error: `投递失败:${err && err.message ? err.message : String(err)}` };
   }
@@ -185,5 +232,8 @@ export async function deliverEditorPrompt(ctx, input) {
     : (agent.id ?? null);
   // `agent` 是给调用方用的**内部句柄**(授权拦截要拿 `agent.ctx` 注册 agent 作用域监听),
   // 路由返回前必须剥掉:它不可 JSON 序列化,也不该泄漏进编辑器。
-  return { ok: true, sessionId, text, agent };
+  // `delivery` + `busy` 一并回去:面板据此说清这条追问会怎么被处理 ——
+  // 只看 delivery 会把**空闲**时的 followup 误报成"排到下一轮"(实测踩到:空闲时发一条,
+  // 面板却写"当前轮结束后…",而当时根本没有当前轮,消息是立刻开的新一轮)。
+  return { ok: true, sessionId, text, delivery, busy, agent };
 }

package/lib/bridge.mjs

@@ -29,18 +29,25 @@
  * 挂 `webServer` 前缀(0.3.9–0.3.12)则只有 web profile 有 webServer,desktop 根本没有 HTTP 面。
  * 桥两端本来就是同一台机器上的两个进程,所以传输用本机 IPC,鉴权仍走独立令牌:
  *
- * ## 安全不变量(改这个文件之前先读这四条)
+ * ## 安全不变量(改这个文件之前先读这几条)
  *
- * 1. **`BRIDGE_BASE`(`/code-server-bridge`)命名空间只读**,只有一个写例外:`POST /approve`
- *    (0.3.22,见下)。其余一律不允许出现写文件、改文档、执行命令、拉起进程的路由 ——
- *    `bridge.json` 里那个令牌对本机同用户进程可读,爆炸半径必须封在"泄露编辑器里的信息",
- *    绝不能变成任意文件写 / 任意命令执行。
- * 2. **`/approve` 的四条约束(缺一条就等于开了任意命令执行的后门,不许放宽)**:
+ * 1. **`BRIDGE_BASE`(`/code-server-bridge`)命名空间**是**四条只读路由 + 一条有界的模型调用**:
+ *    `/health`(无鉴权探活)、`/sync`(上报编辑器状态 + 取事件)、`/old`(取写前原文快照)、
+ *    `/event`(上报意图,如"请宿主打开对话框"),以及 **`/complete`**(0.3.61,**实验性 FIM 补全**):
+ *    它把光标前后的两段文本交给模型换回一段补全文本 —— **仍然不写文件、不执行命令**,
+ *    而且默认关(设置里开启前一律 403),有速率/并发/长度/超时上限(见 lib/index.js 的
+ *    handleBridgeComplete 与 lib/fim-adapter.mjs)。这里**不允许**出现写文件、改文档、执行命令、
+ *    拉起进程的路由 —— `bridge.json` 里那个令牌对本机同用户进程可读,爆炸半径必须封在
+ *    "泄露编辑器里的信息 + 替用户花一点补全 token",绝不能变成任意文件写 / 任意命令执行。
+ *    提问与授权答复不走这里:它们在 DSH 同源的 `/api/code-server/ask/*` 上,调用方是 DSH 页面里的
+ *    插件客户端(吃 DSH 自己的 cookie/Origin 校验)。
+ * 2. **授权答复的四条约束**(在 `/api/code-server/ask/approve` 上,缺一条就等于开了任意命令执行的后门,
+ *    不许放宽):
  *    (a) 它只能**回答**已经存在的授权请求,不能发起任何动作 —— 请求体只有 `{id, outcome}`,
  *        不接受自由文本 / 路径 / 命令参数;
  *    (b) `id` 必须是本进程自己发起、且**仍未决**的请求(用后即废,单次使用);
  *    (c) `outcome` 只接受 `allowed-once` / `rejected` 两个白名单值,没有"永久允许";
- *    (d) 没有面板在看 / 窗口超时(默认 8s)→ **交回官方链路**,绝不自动放行(DSH 的
+ *    (d) 对话框没在看 / 窗口超时(默认 5 分钟)→ **交回官方链路**,绝不自动放行(DSH 的
  *        `approval/request` 本身 fail closed,这里只能把"没人答"保持成"没人答")。
  * 3. **带 `Origin` 的请求一律 403。** 浏览器发起的请求必带 Origin,扩展宿主进程不带。
  *    这条只排除浏览器,不误伤扩展(也顺带挡住 CSRF / DNS rebinding 这类"用你的浏览器打本机端口")。