dsh-plugin-bridge 0.2.10

package/lib/fold.js

@@ -0,0 +1,406 @@
+/** 上游 compaction 检查点的消息 provenance 标记（后端无关）。 */
+const COMPACT_CHECKPOINT_PLUGIN = 'compact';
+/** 上游 `frameSummary` 包裹摘要用的标签。 */
+const SUMMARY_OPEN_TAG = '<compacted-summary>';
+const SUMMARY_CLOSE_TAG = '</compacted-summary>';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function asNum(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function blockBody(block) {
+    if (typeof block.text === 'string' && block.text)
+        return block.text;
+    if (typeof block.thinking === 'string' && block.thinking)
+        return block.thinking;
+    if (typeof block.content === 'string' && block.content)
+        return block.content;
+    return '';
+}
+function isReasoningBlock(block) {
+    return block.type === 'reasoning' || block.type === 'thinking';
+}
+function peelThinkTags(text) {
+    // 线性扫描替代懒惰量词正则（CodeQL js/polynomial-redos）：
+    // /<think>([\s\S]*?)<\/think>/ 在大量未闭合 <think> 的输入上会回溯成多项式时间。
+    const parts = [];
+    const visibleParts = [];
+    const lower = text.toLowerCase();
+    let cursor = 0;
+    while (cursor <= text.length) {
+        const open = lower.indexOf('<think>', cursor);
+        if (open === -1) {
+            visibleParts.push(text.slice(cursor));
+            break;
+        }
+        visibleParts.push(text.slice(cursor, open));
+        const close = lower.indexOf('</think>', open + 7);
+        if (close === -1) {
+            // 未闭合的标签按原文保留（与原正则不匹配时的行为一致）
+            visibleParts.push(text.slice(open));
+            break;
+        }
+        const trimmed = text.slice(open + 7, close).trim();
+        if (trimmed)
+            parts.push(trimmed);
+        cursor = close + 8;
+    }
+    return { text: visibleParts.join('').trim(), thinking: parts.join('\n\n') };
+}
+const IMAGE_MEDIA_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
+function imageAttachmentFromBlock(block) {
+    const attachment = asRecord(block.attachment);
+    if (!attachment)
+        return undefined;
+    const { attachmentId, mediaType, bytes, width, height, name } = attachment;
+    if (typeof attachmentId !== 'string' || !attachmentId)
+        return undefined;
+    if (typeof mediaType !== 'string' || !IMAGE_MEDIA_TYPES.has(mediaType))
+        return undefined;
+    if (typeof bytes !== 'number' || typeof width !== 'number' || typeof height !== 'number')
+        return undefined;
+    return {
+        attachmentId,
+        mediaType: mediaType,
+        bytes,
+        width,
+        height,
+        ...(typeof name === 'string' && name ? { name } : {}),
+    };
+}
+function splitContentBlocks(blocks) {
+    if (!Array.isArray(blocks))
+        return { text: '', thinking: '', imageCount: 0, imageAttachments: [] };
+    let text = '';
+    let thinking = '';
+    let imageCount = 0;
+    const imageAttachments = [];
+    for (const item of blocks) {
+        const block = asRecord(item);
+        if (!block)
+            continue;
+        if (block.type === 'image') {
+            imageCount += 1;
+            const attachment = imageAttachmentFromBlock(block);
+            if (attachment)
+                imageAttachments.push(attachment);
+            continue;
+        }
+        const body = blockBody(block);
+        if (!body)
+            continue;
+        if (isReasoningBlock(block))
+            thinking += body;
+        else if (block.type === 'text' || block.type == null)
+            text += body;
+    }
+    const peeled = peelThinkTags(text);
+    return { text: peeled.text, thinking: thinking || peeled.thinking, imageCount, imageAttachments };
+}
+function textFromBlocks(blocks) {
+    return splitContentBlocks(blocks).text;
+}
+function formatTime(ms) {
+    if (!ms)
+        return '';
+    const d = new Date(ms);
+    if (Number.isNaN(d.getTime()))
+        return '';
+    return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+/** host 注入的运行时上下文块：对交接摘要没有价值，且体量不小。 */
+function isNoiseUserText(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith('<system-reminder>') || trimmed.startsWith('<system-notification>'))
+        return true;
+    if (/^<\/?runtime-context\b/i.test(trimmed) || /<\/runtime-context>/i.test(trimmed))
+        return true;
+    if (/^Current runtime context\b/i.test(trimmed))
+        return true;
+    if (trimmed.includes('supersedes earlier runtime-context'))
+        return true;
+    if (/^Current DSH file policy:/im.test(trimmed) && /Approval policy:/i.test(trimmed))
+        return true;
+    return false;
+}
+function compactJson(value, limit = 240) {
+    if (value == null)
+        return '';
+    try {
+        const json = JSON.stringify(value);
+        if (!json || json === '{}' || json === '[]' || json === 'null')
+            return '';
+        return json.length > limit ? `${json.slice(0, limit)}…` : json;
+    }
+    catch {
+        return '';
+    }
+}
+function firstString(values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+/** 工具调用的入参摘要：命令 / 路径 / 查询串，取第一个有值的。 */
+export function toolDetail(data) {
+    if (!data)
+        return '';
+    const call = asRecord(data.call);
+    const input = asRecord(data.input) ?? asRecord(data.arguments) ?? asRecord(data.args)
+        ?? asRecord(call?.arguments) ?? asRecord(call?.input);
+    return firstString([
+        data.command,
+        data.path,
+        data.file,
+        data.query,
+        input?.command,
+        input?.path,
+        input?.file_path,
+        input?.file,
+        input?.query,
+        input?.pattern,
+    ]) || compactJson(input);
+}
+/** 工具输出（折叠保留，取材不使用）。 */
+export function toolOutput(data) {
+    if (!data)
+        return '';
+    const pieces = [data.output, data.result, data.text, data.content];
+    for (const piece of pieces) {
+        if (typeof piece === 'string' && piece.trim())
+            return piece.trim();
+        if (Array.isArray(piece)) {
+            const text = piece
+                .map((item) => (typeof item === 'string' ? item : blockBody(asRecord(item) ?? {})))
+                .join('')
+                .trim();
+            if (text)
+                return text;
+        }
+    }
+    const error = asRecord(data.error);
+    if (typeof error?.message === 'string' && error.message)
+        return error.message;
+    if (typeof data.error === 'string' && data.error)
+        return data.error;
+    return compactJson(data.output ?? data.result, 400);
+}
+/**
+ * 是否是 compaction 检查点消息。
+ *
+ * 上游把这个判据专门导出成 `isCompactCheckpointSource`
+ * （`@deepseek-ai/dsh-compaction/checkpoint`，一个不依赖 cordis 的纯谓词出口，
+ * 就是给客户端/wire 程序用的）。这里保持同一语义：认 provenance 标记，
+ * 文本标签只作为兜底。
+ */
+export function isCompactCheckpoint(data, text = '') {
+    const source = asRecord(data?.source);
+    if (source?.kind === 'plugin' && source.plugin === COMPACT_CHECKPOINT_PLUGIN)
+        return true;
+    return text.includes(SUMMARY_OPEN_TAG);
+}
+/**
+ * 取出检查点里真正的摘要正文。
+ *
+ * 上游 `frameSummary()` 拼出的形状是
+ * `CHECKPOINT_PREAMBLE + "\n\n<compacted-summary>" + 摘要 + "</compacted-summary>"`，
+ * 而 preamble 是一句面向模型的指令（"把它当既有背景，别提这个 checkpoint，
+ * 直接继续"）。只去标签会把这句指令一起喂给压缩工人，所以这里连 preamble 一起剥掉；
+ * 找不到标签时退回原文。
+ */
+export function stripCompactTags(text) {
+    const open = text.indexOf(SUMMARY_OPEN_TAG);
+    const close = text.lastIndexOf(SUMMARY_CLOSE_TAG);
+    if (open >= 0) {
+        const start = open + SUMMARY_OPEN_TAG.length;
+        const end = close > start ? close : text.length;
+        return text.slice(start, end).trim();
+    }
+    return text.replace(/<\/?compacted-summary>/g, '').trim();
+}
+/** `turn:step`，两者都在 payload 上时才有值。 */
+export function stepKey(event) {
+    const turn = asNum(event.data?.turn);
+    const step = asNum(event.data?.step);
+    if (turn == null || step == null)
+        return null;
+    return `${turn}:${step}`;
+}
+export function toolName(data) {
+    if (!data)
+        return 'tool';
+    const name = data.tool ?? data.name ?? data.toolName;
+    if (typeof name === 'string' && name)
+        return name;
+    const call = asRecord(data.call);
+    if (typeof call?.name === 'string' && call.name)
+        return call.name;
+    return 'tool';
+}
+function callIdOf(data) {
+    if (!data)
+        return undefined;
+    if (typeof data.callId === 'string' && data.callId)
+        return data.callId;
+    const message = asRecord(data.message);
+    if (typeof message?.callId === 'string' && message.callId)
+        return message.callId;
+    return undefined;
+}
+/** 已被 `assistant/message` 终结的 step：其 text chunk 不再重复累加。 */
+function finalizedSteps(events) {
+    const keys = new Set();
+    for (const event of events) {
+        if (event.type !== 'assistant/message')
+            continue;
+        const key = stepKey(event);
+        if (key)
+            keys.add(key);
+    }
+    return keys;
+}
+function keepAssistant(message) {
+    return Boolean(message.content || message.thinking || message.toolNodes?.length);
+}
+function newAssistant(event) {
+    return {
+        id: `e-${event.seq ?? 0}`,
+        role: 'assistant',
+        latestEventSeq: event.seq ?? 0,
+        content: '',
+        timestamp: formatTime(event.time),
+    };
+}
+function stampThinkingMs(assistant, startedAt, endedAt) {
+    if (assistant.thinkingMs != null || !assistant.thinking || startedAt == null || endedAt == null)
+        return;
+    const delta = endedAt - startedAt;
+    if (delta >= 0)
+        assistant.thinkingMs = delta;
+}
+function applyAssistantBlocks(assistant, blocks) {
+    const split = splitContentBlocks(blocks);
+    if (split.text)
+        assistant.content = split.text;
+    if (split.thinking)
+        assistant.thinking = split.thinking;
+}
+/** 把一页 history（或实时 mux 事件）折叠成会话消息，按时间正序。 */
+export function foldSessionEvents(events) {
+    const skipChunks = finalizedSteps(events);
+    const out = [];
+    let assistant = null;
+    let thinkingStartedAt;
+    const flush = (endedAt) => {
+        if (assistant && keepAssistant(assistant)) {
+            stampThinkingMs(assistant, thinkingStartedAt, endedAt);
+            out.push(assistant);
+        }
+        assistant = null;
+        thinkingStartedAt = undefined;
+    };
+    for (const event of events) {
+        const data = event.data;
+        if (event.type === 'user/message') {
+            flush(event.time);
+            const split = splitContentBlocks(data?.content);
+            const { text, imageCount, imageAttachments } = split;
+            if (isCompactCheckpoint(data, text)) {
+                out.push({
+                    id: `e-${event.seq ?? 0}`,
+                    role: 'system',
+                    kind: 'compaction',
+                    content: stripCompactTags(text),
+                    timestamp: formatTime(event.time),
+                });
+                continue;
+            }
+            if (isNoiseUserText(text))
+                continue;
+            if (!text && imageCount === 0)
+                continue;
+            out.push({
+                id: `e-${event.seq ?? 0}`,
+                role: 'user',
+                content: text,
+                imageCount,
+                ...(imageAttachments.length ? { imageAttachments } : {}),
+                timestamp: formatTime(event.time),
+            });
+            continue;
+        }
+        if (event.type === 'assistant/message') {
+            if (!assistant)
+                assistant = newAssistant(event);
+            assistant.latestEventSeq = event.seq ?? assistant.latestEventSeq;
+            const message = asRecord(data?.message);
+            applyAssistantBlocks(assistant, message?.content ?? data?.content);
+            stampThinkingMs(assistant, thinkingStartedAt, event.time);
+            if (assistant.content)
+                flush(event.time);
+            continue;
+        }
+        if (event.type === 'assistant/chunk') {
+            const key = stepKey(event);
+            const chunk = asRecord(data?.chunk);
+            const skipText = Boolean(key && skipChunks.has(key));
+            if (skipText && chunk?.type !== 'reasoning-delta')
+                continue;
+            if (!assistant)
+                assistant = newAssistant(event);
+            assistant.latestEventSeq = event.seq ?? assistant.latestEventSeq;
+            const text = typeof chunk?.text === 'string' ? chunk.text
+                : typeof chunk?.delta === 'string' ? chunk.delta
+                    : blockBody(asRecord(chunk?.block) ?? {});
+            if (chunk?.type === 'text-delta' && text && !skipText)
+                assistant.content += text;
+            if (chunk?.type === 'reasoning-delta' && text) {
+                if (thinkingStartedAt == null)
+                    thinkingStartedAt = event.time;
+                assistant.thinkingStartedAt = thinkingStartedAt;
+                assistant.thinking = (assistant.thinking ?? '') + text;
+            }
+            continue;
+        }
+        if (event.type === 'tool/call') {
+            if (!assistant)
+                assistant = newAssistant(event);
+            assistant.latestEventSeq = event.seq ?? assistant.latestEventSeq;
+            const node = {
+                type: 'bash',
+                title: toolName(data),
+                status: 'running',
+                callId: callIdOf(data),
+                eventSeq: event.seq ?? 0,
+                detail: toolDetail(data),
+            };
+            assistant.toolNodes = [...(assistant.toolNodes ?? []), node];
+            continue;
+        }
+        if (event.type === 'tool/result') {
+            if (!assistant?.toolNodes?.length)
+                continue;
+            assistant.latestEventSeq = event.seq ?? assistant.latestEventSeq;
+            const id = callIdOf(data);
+            const output = toolOutput(data);
+            let marked = false;
+            assistant.toolNodes = assistant.toolNodes.map((node) => {
+                if (id && node.callId === id)
+                    return { ...node, status: 'done', output: output || node.output };
+                if (!id && !marked && node.status === 'running') {
+                    marked = true;
+                    return { ...node, status: 'done', output: output || node.output };
+                }
+                return node;
+            });
+            continue;
+        }
+        if (event.type === 'turn/end')
+            flush(event.time);
+    }
+    flush(events[events.length - 1]?.time);
+    return out;
+}

package/lib/index.d.ts

@@ -0,0 +1,55 @@
+import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+export declare const name = "dsh-plugin-bridge";
+/**
+ * `commands` 是入口，`apiProxy` 是引擎——两个都是硬依赖：
+ * 缺哪个这个插件都无事可做，与其静默半挂，不如让 cordis 挂起等待。
+ * 两者在官方 `web` profile 里都在（base 挂 commands，web-app 挂 api-gateway）。
+ */
+export declare const inject: string[];
+export interface Config {
+    /** 压缩工人模型档位：flash 省 / current 跟随 / pro 准（实验：pro 几乎不加价，且没有全灭尾部风险）。 */
+    modelTier?: 'flash' | 'current' | 'pro';
+    /** 压缩取材总字符预算（≈30K tokens）。 */
+    sourceCharBudget?: number;
+    /** 交接摘要正文字符预算（≈900 tokens）。 */
+    summaryCharBudget?: number;
+    /**
+     * 迁移后目标会话的 goal 自主轮次上限。
+     *
+     * 上游 `goal.create` 的部署默认是 256，且 `dsh-goal-round-driver` 会在 agent
+     * 空闲时把目标渲染成 `<goal_round>` 提示反复跑——不显式设值，一次迁移等于给新
+     * 会话开了最多 256 轮自主循环。交接只需要一轮，之后交回用户。
+     */
+    goalRounds?: number;
+    /** 摘要注入方式：prompt 不挂目标；goal / both 会挂目标。只要发 kickoff，摘要始终随 prompt 注入以防失忆。 */
+    inject?: 'goal' | 'prompt' | 'both';
+    /** 摘要语言，auto 表示跟着会话内容走。 */
+    lang?: 'zh' | 'en' | 'auto';
+    /** 直接指定压缩模型，跳过档位推断（换 provider 的部署用）。 */
+    workerProvider?: string;
+    workerModel?: string;
+    /** `/bridge <preset>` 等压缩工人的上限（毫秒）。 */
+    previewTimeoutMs?: number;
+}
+export declare const Config: Schema<Config>;
+/** 把 Config 解析成命令层要的形状（Schema 已经填过默认值，这里只兜底）。 */
+export declare function commandConfigOf(config?: Config): {
+    readonly modelTier: "current" | "flash" | "pro";
+    readonly sourceCharBudget: number;
+    readonly summaryCharBudget: number;
+    readonly goalRounds: number;
+    readonly inject: "both" | "goal" | "prompt";
+    readonly lang: "auto" | "en" | "zh";
+    readonly previewTimeoutMs: number;
+    readonly workerProvider?: string | undefined;
+    readonly workerModel?: string | undefined;
+};
+export declare function apply(ctx: Context, config?: Config): void;
+declare const _default: {
+    name: string;
+    inject: string[];
+    Config: Schema<Config>;
+    apply: typeof apply;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,76 @@
+/**
+ * dsh-plugin-bridge：跨 preset 会话迁移。
+ *
+ * 形态是一个**普通的 dsh 插件**——`dsh plugin add` 装上、重启，输入框里就有
+ * `/bridge`；`dsh plugin remove` 卸掉，命令随 fiber 一起消失。不注册技能、
+ * 不依赖模型主动做什么、不需要 bash 或环境变量。
+ *
+ * 入口形状对齐上游 `dsh-plan-mode`（`/plan` 命令 + 工具）：命令由 UI 直接派发，
+ * 不经过模型，结果也不进模型历史。执行引擎是进程内的 `ctx.apiProxy`
+ * （web bundle 的 `api-gateway` 行提供），所以整条链路不出进程。
+ */
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import Schema from '@deepseek-ai/schemastery';
+import { createApiProxyRpc, probeApiProxy } from './api-rpc.js';
+import { createBridgeCommand } from './command.js';
+import { SOURCE_CHAR_BUDGET, SUMMARY_CHAR_BUDGET } from './compression.js';
+export const name = 'dsh-plugin-bridge';
+/**
+ * `commands` 是入口，`apiProxy` 是引擎——两个都是硬依赖：
+ * 缺哪个这个插件都无事可做，与其静默半挂，不如让 cordis 挂起等待。
+ * 两者在官方 `web` profile 里都在（base 挂 commands，web-app 挂 api-gateway）。
+ */
+export const inject = ['commands', 'apiProxy'];
+/** 命令是同步返回的，等压缩工人不能等太久。 */
+const DEFAULT_PREVIEW_TIMEOUT_MS = 180_000;
+export const Config = Schema.object({
+    modelTier: Schema.union(['flash', 'current', 'pro']).default('pro'),
+    sourceCharBudget: Schema.number().default(SOURCE_CHAR_BUDGET),
+    summaryCharBudget: Schema.number().default(SUMMARY_CHAR_BUDGET),
+    goalRounds: Schema.number().default(1),
+    inject: Schema.union(['goal', 'prompt', 'both']).default('both'),
+    lang: Schema.union(['zh', 'en', 'auto']).default('auto'),
+    workerProvider: Schema.string(),
+    workerModel: Schema.string(),
+    previewTimeoutMs: Schema.number().default(DEFAULT_PREVIEW_TIMEOUT_MS),
+});
+/** 摘要落盘，供「改完再执行」那条路用。失败不该让迁移失败，所以吞掉异常。 */
+function writeSummaryFile(sessionId, summary) {
+    try {
+        const dir = mkdtempSync(join(tmpdir(), 'dsh-bridge-'));
+        const file = join(dir, `summary-${sessionId.slice(0, 12)}.md`);
+        writeFileSync(file, summary, 'utf8');
+        return file;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 把 Config 解析成命令层要的形状（Schema 已经填过默认值，这里只兜底）。 */
+export function commandConfigOf(config = {}) {
+    return {
+        modelTier: config.modelTier ?? 'pro',
+        sourceCharBudget: config.sourceCharBudget ?? SOURCE_CHAR_BUDGET,
+        summaryCharBudget: config.summaryCharBudget ?? SUMMARY_CHAR_BUDGET,
+        goalRounds: config.goalRounds ?? 1,
+        inject: config.inject ?? 'both',
+        lang: config.lang ?? 'auto',
+        previewTimeoutMs: config.previewTimeoutMs ?? DEFAULT_PREVIEW_TIMEOUT_MS,
+        ...(config.workerProvider ? { workerProvider: config.workerProvider } : {}),
+        ...(config.workerModel ? { workerModel: config.workerModel } : {}),
+    };
+}
+export function apply(ctx, config = {}) {
+    const apiProxyOf = () => ctx.apiProxy;
+    const command = createBridgeCommand({
+        rpcFor: (signal) => createApiProxyRpc(apiProxyOf(), signal),
+        probe: () => probeApiProxy(apiProxyOf()),
+        config: commandConfigOf(config),
+        writeSummary: writeSummaryFile,
+        readSummary: (path) => readFileSync(path, 'utf8'),
+    });
+    ctx.commands.register(command);
+}
+export default { name, inject, Config, apply };