chatccc 0.2.259 → 0.2.261

package/dist/src/engines/engine-manager.js

@@ -0,0 +1,451 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, dirname, join, relative, resolve } from "node:path";
+const STEP_DEFINITIONS = [
+    ["preflight", "检查运行环境"],
+    ["prepare", "准备临时目录"],
+    ["download_install", "下载并安装依赖"],
+    ["verify_packages", "校验文件与版本"],
+    ["runtime_handshake", "启动并验证 Runtime"],
+    ["activate", "原子切换版本"],
+    ["cleanup", "清理旧版本"],
+];
+export const DEFAULT_ENGINE_ROOT = join(homedir(), ".chatccc", "engines");
+export function createCoalescedAsyncTask(task) {
+    let requested = false;
+    let active = null;
+    let failed = false;
+    let failure;
+    const start = () => {
+        if (active || failed)
+            return;
+        active = (async () => {
+            while (requested) {
+                requested = false;
+                await task();
+            }
+        })().catch((error) => {
+            failed = true;
+            failure = error;
+            requested = false;
+        }).finally(() => {
+            active = null;
+            if (requested)
+                start();
+        });
+    };
+    return {
+        schedule() {
+            requested = true;
+            start();
+        },
+        async flush() {
+            if (!failed) {
+                requested = true;
+                start();
+            }
+            while (active)
+                await active;
+            if (failed)
+                throw failure;
+        },
+    };
+}
+async function renameWithTransientRetry(source, destination) {
+    const retriable = new Set(["EPERM", "EBUSY", "EACCES"]);
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await rename(source, destination);
+            return;
+        }
+        catch (error) {
+            const code = error.code ?? "";
+            if (!retriable.has(code) || attempt >= 5)
+                throw error;
+            await new Promise((resolvePromise) => setTimeout(resolvePromise, 20 * (2 ** attempt)));
+        }
+    }
+}
+export function resolveNpmInvocation() {
+    const candidates = [
+        process.env.npm_execpath,
+        join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
+        ...(process.env.PATH ?? "").split(delimiter).filter(Boolean).map((pathDir) => join(pathDir, "node_modules", "npm", "bin", "npm-cli.js")),
+    ];
+    const npmCliPath = candidates.find((candidate) => Boolean(candidate && existsSync(candidate)));
+    if (!npmCliPath) {
+        throw new Error("找不到 npm-cli.js；请先安装 npm，并确保 npm 与当前 Node.js 位于同一环境。");
+    }
+    return { command: process.execPath, argsPrefix: [npmCliPath] };
+}
+export class EngineManager {
+    rootDir;
+    specs = new Map();
+    installPackages;
+    verifyRuntime;
+    nodeVersion;
+    activeInstalls = new Map();
+    persistTails = new Map();
+    constructor(options) {
+        this.rootDir = options.rootDir ?? DEFAULT_ENGINE_ROOT;
+        for (const spec of options.specs)
+            this.specs.set(spec.id, spec);
+        this.installPackages = options.installPackages ?? defaultInstallPackages;
+        this.verifyRuntime = options.verifyRuntime;
+        this.nodeVersion = options.nodeVersion ?? process.versions.node;
+    }
+    listSpecs() {
+        return [...this.specs.values()];
+    }
+    getSpec(engineId) {
+        const spec = this.specs.get(engineId);
+        if (!spec)
+            throw new Error(`Unknown engine: ${engineId}`);
+        return spec;
+    }
+    async getStatus(engineId) {
+        const spec = this.getSpec(engineId);
+        const pointer = await this.readPointer(spec);
+        const entryPath = pointer ? join(this.engineDir(spec), pointer.directory, spec.entryRelativePath) : null;
+        const installed = Boolean(entryPath && existsSync(entryPath));
+        return {
+            id: spec.id,
+            label: spec.label,
+            installed,
+            version: installed ? pointer?.version ?? null : null,
+            targetVersion: spec.version,
+            entryPath: installed ? entryPath : null,
+            running: this.activeInstalls.has(engineId),
+            job: await this.readJob(spec),
+        };
+    }
+    async getEntryPath(engineId) {
+        const status = await this.getStatus(engineId);
+        if (!status.installed || !status.entryPath) {
+            throw new Error(`${status.label} 尚未安装，请先在设置页安装引擎。`);
+        }
+        return status.entryPath;
+    }
+    async startInstall(engineId) {
+        const running = this.activeInstalls.get(engineId);
+        if (running)
+            return this.readJob(this.getSpec(engineId)).then((job) => job ?? this.newJob(this.getSpec(engineId)));
+        const spec = this.getSpec(engineId);
+        const job = this.newJob(spec);
+        await this.persistJob(spec, job);
+        const task = this.runInstall(spec, job).finally(() => this.activeInstalls.delete(engineId));
+        this.activeInstalls.set(engineId, task);
+        return cloneJob(job);
+    }
+    async install(engineId) {
+        await this.startInstall(engineId);
+        return this.waitForInstall(engineId);
+    }
+    async waitForInstall(engineId) {
+        const active = this.activeInstalls.get(engineId);
+        if (active)
+            return active;
+        const job = await this.readJob(this.getSpec(engineId));
+        if (!job)
+            throw new Error(`No install job for engine: ${engineId}`);
+        return job;
+    }
+    newJob(spec) {
+        const now = new Date().toISOString();
+        return {
+            schemaVersion: 1,
+            jobId: randomUUID(),
+            engineId: spec.id,
+            targetVersion: spec.version,
+            state: "running",
+            percent: 0,
+            startedAt: now,
+            updatedAt: now,
+            steps: STEP_DEFINITIONS.map(([id, label]) => ({ id, label, state: "pending", percent: 0, message: "等待中" })),
+        };
+    }
+    async runInstall(spec, job) {
+        const stagingDir = join(this.rootDir, ".staging", `${spec.id}-${job.jobId}`);
+        let publishedDir = null;
+        try {
+            await this.runStep(spec, job, "preflight", async (update) => {
+                await update(20, `Node.js ${this.nodeVersion}`);
+                if (compareVersions(this.nodeVersion, spec.minimumNodeVersion) < 0) {
+                    throw new Error(`${spec.label} 要求 Node.js >= ${spec.minimumNodeVersion}，当前为 ${this.nodeVersion}`);
+                }
+                await mkdir(this.rootDir, { recursive: true });
+                await update(100, "运行环境可用");
+            });
+            await this.runStep(spec, job, "prepare", async (update) => {
+                await rm(stagingDir, { recursive: true, force: true });
+                await mkdir(stagingDir, { recursive: true });
+                await writeFile(join(stagingDir, "package.json"), JSON.stringify({
+                    name: `chatccc-engine-${spec.id}`,
+                    private: true,
+                    type: "module",
+                    dependencies: spec.packages,
+                }, null, 2) + "\n", "utf8");
+                await spec.prepareInstallation?.(stagingDir);
+                await update(100, "临时安装目录已准备");
+            });
+            await this.runStep(spec, job, "download_install", async (update) => {
+                await this.installPackages(stagingDir, spec, update);
+                await update(100, "依赖安装完成");
+            });
+            await this.runStep(spec, job, "verify_packages", async (update) => {
+                const entries = Object.entries(spec.packages);
+                for (let index = 0; index < entries.length; index += 1) {
+                    const [packageName, expectedVersion] = entries[index];
+                    const packageJson = join(stagingDir, "node_modules", ...packageName.split("/"), "package.json");
+                    const parsed = JSON.parse(await readFile(packageJson, "utf8"));
+                    if (parsed.version !== expectedVersion) {
+                        throw new Error(`${packageName} 版本校验失败：期望 ${expectedVersion}，实际 ${String(parsed.version)}`);
+                    }
+                    await update(Math.round(((index + 1) / entries.length) * 90), `已校验 ${packageName}`);
+                }
+                const entry = join(stagingDir, spec.entryRelativePath);
+                if (!existsSync(entry))
+                    throw new Error(`引擎入口不存在：${entry}`);
+                await update(100, "文件和版本校验通过");
+            });
+            await this.runStep(spec, job, "runtime_handshake", async (update) => {
+                await update(10, "正在启动 Runtime");
+                if (this.verifyRuntime)
+                    await this.verifyRuntime(stagingDir, spec);
+                else
+                    await spec.verifyRuntime?.(stagingDir);
+                await update(100, "Runtime 握手成功");
+            });
+            await this.runStep(spec, job, "activate", async (update) => {
+                const directoryName = `${spec.version}-${job.jobId}`;
+                const versionsDir = join(this.engineDir(spec), "versions");
+                publishedDir = join(versionsDir, directoryName);
+                await mkdir(versionsDir, { recursive: true });
+                await rename(stagingDir, publishedDir);
+                const pointer = {
+                    schemaVersion: 1,
+                    version: spec.version,
+                    directory: relative(this.engineDir(spec), publishedDir).replaceAll("\\", "/"),
+                    activatedAt: new Date().toISOString(),
+                };
+                const pointerPath = join(this.engineDir(spec), "current.json");
+                const temporaryPointer = `${pointerPath}.${job.jobId}.tmp`;
+                await writeFile(temporaryPointer, JSON.stringify(pointer, null, 2) + "\n", "utf8");
+                await renameWithTransientRetry(temporaryPointer, pointerPath);
+                await update(100, `已切换到 v${spec.version}`);
+            });
+            await this.runStep(spec, job, "cleanup", async (update) => {
+                const versionsDir = join(this.engineDir(spec), "versions");
+                const keep = publishedDir ? resolve(publishedDir) : "";
+                const entries = await readdir(versionsDir, { withFileTypes: true });
+                const old = entries.filter((entry) => entry.isDirectory() && resolve(versionsDir, entry.name) !== keep);
+                for (let index = 0; index < old.length; index += 1) {
+                    await rm(join(versionsDir, old[index].name), { recursive: true, force: true });
+                    await update(Math.round(((index + 1) / Math.max(old.length, 1)) * 100), `已清理 ${old[index].name}`);
+                }
+                await update(100, old.length ? "旧版本已清理" : "无需清理旧版本");
+            });
+            job.state = "succeeded";
+            job.percent = 100;
+            job.updatedAt = new Date().toISOString();
+            await this.persistJob(spec, job);
+            return cloneJob(job);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            job.state = "failed";
+            job.error = message.slice(0, 1000);
+            job.updatedAt = new Date().toISOString();
+            await this.persistJob(spec, job);
+            await rm(stagingDir, { recursive: true, force: true }).catch(() => { });
+            return cloneJob(job);
+        }
+    }
+    async runStep(spec, job, stepId, operation) {
+        const step = job.steps.find((candidate) => candidate.id === stepId);
+        step.state = "running";
+        step.message = "进行中";
+        await this.recalculateAndPersist(spec, job);
+        const update = async (percent, message) => {
+            step.percent = Math.max(0, Math.min(100, Math.round(percent)));
+            step.message = message;
+            await this.recalculateAndPersist(spec, job);
+        };
+        try {
+            await operation(update);
+            step.state = "completed";
+            step.percent = 100;
+            await this.recalculateAndPersist(spec, job);
+        }
+        catch (error) {
+            step.state = "failed";
+            step.error = error instanceof Error ? error.message : String(error);
+            step.message = "失败";
+            await this.recalculateAndPersist(spec, job);
+            throw error;
+        }
+    }
+    async recalculateAndPersist(spec, job) {
+        job.percent = Math.round(job.steps.reduce((sum, step) => sum + step.percent, 0) / job.steps.length);
+        job.updatedAt = new Date().toISOString();
+        await this.persistJob(spec, job);
+    }
+    engineDir(spec) {
+        return join(this.rootDir, spec.id);
+    }
+    jobPath(spec) {
+        return join(this.rootDir, "engine-jobs", `${spec.id}.json`);
+    }
+    async persistJob(spec, job) {
+        const path = this.jobPath(spec);
+        const contents = JSON.stringify(job, null, 2) + "\n";
+        const previous = this.persistTails.get(spec.id) ?? Promise.resolve();
+        const operation = previous.catch(() => { }).then(async () => {
+            await mkdir(dirname(path), { recursive: true });
+            const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(temporary, contents, "utf8");
+                await renameWithTransientRetry(temporary, path);
+            }
+            finally {
+                await rm(temporary, { force: true }).catch(() => { });
+            }
+        });
+        this.persistTails.set(spec.id, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.persistTails.get(spec.id) === operation)
+                this.persistTails.delete(spec.id);
+        }
+    }
+    async readJob(spec) {
+        try {
+            const parsed = JSON.parse(await readFile(this.jobPath(spec), "utf8"));
+            if (parsed.state === "running" && !this.activeInstalls.has(spec.id)) {
+                parsed.state = "failed";
+                parsed.error = "上一次安装任务因进程退出而中断，请重试。";
+                const running = parsed.steps.find((step) => step.state === "running");
+                if (running) {
+                    running.state = "failed";
+                    running.message = "安装任务已中断";
+                    running.error = parsed.error;
+                }
+                parsed.updatedAt = new Date().toISOString();
+                await this.persistJob(spec, parsed);
+            }
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    async readPointer(spec) {
+        try {
+            const parsed = JSON.parse(await readFile(join(this.engineDir(spec), "current.json"), "utf8"));
+            if (typeof parsed.version !== "string" || typeof parsed.directory !== "string")
+                return null;
+            const resolved = resolve(this.engineDir(spec), parsed.directory);
+            const versionsDir = resolve(this.engineDir(spec), "versions");
+            if (resolved !== versionsDir && !resolved.startsWith(`${versionsDir}\\`) && !resolved.startsWith(`${versionsDir}/`))
+                return null;
+            return { version: parsed.version, directory: parsed.directory };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+async function defaultInstallPackages(installationDir, spec, onProgress) {
+    await new Promise((resolvePromise, reject) => {
+        let npmInvocation;
+        try {
+            npmInvocation = resolveNpmInvocation();
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const child = spawn(npmInvocation.command, [...npmInvocation.argsPrefix, "install", "--prefix", installationDir, "--no-audit", "--no-fund", "--save-exact", "--loglevel=http"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stderr = "";
+        let requests = 0;
+        const progressReporter = createCoalescedAsyncTask(async () => {
+            const bytes = await directorySize(installationDir);
+            const sizePercent = spec.expectedBytes > 0 ? Math.min(92, (bytes / spec.expectedBytes) * 92) : 0;
+            const requestPercent = Math.min(85, requests * 2);
+            const percent = Math.max(3, sizePercent, requestPercent);
+            await onProgress(percent, `已下载/写入 ${(bytes / 1048576).toFixed(1)} MB`);
+        });
+        const report = () => progressReporter.schedule();
+        child.stdout.on("data", (chunk) => {
+            requests += (chunk.toString().match(/http fetch GET|GET \d{3}/g) ?? []).length;
+            report();
+        });
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderr = (stderr + text).slice(-4000);
+            requests += (text.match(/http fetch GET|GET \d{3}/g) ?? []).length;
+            report();
+        });
+        const timer = setInterval(report, 1000);
+        timer.unref?.();
+        child.once("error", (error) => {
+            clearInterval(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            clearInterval(timer);
+            void progressReporter.flush().then(() => {
+                if (code === 0)
+                    resolvePromise();
+                else
+                    reject(new Error(`npm install 失败（退出码 ${String(code)}）：${stderr.trim().split(/\r?\n/).slice(-6).join(" | ").slice(0, 1000)}`));
+            }).catch(reject);
+        });
+    });
+}
+async function directorySize(root) {
+    let total = 0;
+    const pending = [root];
+    while (pending.length) {
+        const current = pending.pop();
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const path = join(current, entry.name);
+            if (entry.isDirectory())
+                pending.push(path);
+            else if (entry.isFile()) {
+                try {
+                    total += (await stat(path)).size;
+                }
+                catch { /* file changed during scan */ }
+            }
+        }
+    }
+    return total;
+}
+function compareVersions(left, right) {
+    const a = left.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    const b = right.split(".").map((part) => Number.parseInt(part, 10) || 0);
+    for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+        if ((a[index] ?? 0) !== (b[index] ?? 0))
+            return (a[index] ?? 0) > (b[index] ?? 0) ? 1 : -1;
+    }
+    return 0;
+}
+function cloneJob(job) {
+    return JSON.parse(JSON.stringify(job));
+}

package/dist/src/engines/engine-specs.js

@@ -0,0 +1,157 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { EngineManager } from "./engine-manager.js";
+export const CLAUDE_ENGINE_VERSION = "0.2.133";
+export const DSH_ENGINE_VERSION = "0.1.0-rc.6";
+const DSH_PACKAGES = {
+    "@deepseek-ai/dsh": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-sdk-client": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-sdk-jsonrpc-demo": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-sdk-jsonrpc-server": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-agent-spine-demo": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-llm-deepseek": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-session-persistence-jsonl": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-session-checkpoint-policy": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-subprocess-local": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-bash-local": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-fs-local": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-subagent": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-subagent-spawn-in-process": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-tool-subagent": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-tool-todo": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-fs-observation-policy": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-tool-fs": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-token-meter": DSH_ENGINE_VERSION,
+    "@deepseek-ai/dsh-compaction-basic": DSH_ENGINE_VERSION,
+};
+export const DSH_RUNTIME_CONFIG = `# Generated and owned by ChatCCC. Secrets are supplied through the child environment.
+- id: sdk-jsonrpc-server
+  name: '@deepseek-ai/dsh-sdk-jsonrpc-server'
+  config:
+    maxTokensAsSuccess: true
+- id: agent-core
+  name: '@deepseek-ai/dsh-agent-spine-demo'
+  config:
+    persona: !!js process.env.DSH_SYSTEM_PROMPT ?? 'You are a coding agent.'
+    workspaceContext: false
+    skills:
+      enabled: false
+    toolBash:
+      enableRunInBackground: false
+    toolJobs: false
+- id: llm-deepseek
+  name: '@deepseek-ai/dsh-llm-deepseek'
+  config:
+    thinking: enabled
+    reasoningEffort: max
+- id: sessions
+  name: '@deepseek-ai/dsh-session-persistence-jsonl'
+  config:
+    root: !!js process.env.DSH_SESSION_ROOT
+    compression: zstd
+- id: session-checkpoints
+  name: '@deepseek-ai/dsh-session-checkpoint-policy'
+- id: subprocess
+  name: '@deepseek-ai/dsh-subprocess-local'
+- id: bash
+  name: '@deepseek-ai/dsh-bash-local'
+  config:
+    cwd: !!js process.env.DSH_CWD
+    timeoutMs: 60000
+- id: fs-local
+  name: '@deepseek-ai/dsh-fs-local'
+  config:
+    cwd: !!js process.env.DSH_CWD
+- id: subagent
+  name: '@deepseek-ai/dsh-subagent'
+- id: subagent-spawn-in-process
+  name: '@deepseek-ai/dsh-subagent-spawn-in-process'
+  config:
+    providerName: spawn
+- id: tool-subagent
+  name: '@deepseek-ai/dsh-tool-subagent'
+  config:
+    provider: spawn
+    toolName: subagent
+    enableRunInBackground: false
+- id: tool-todo
+  name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+- id: fs-observation-policy
+  name: '@deepseek-ai/dsh-fs-observation-policy'
+- id: tool-fs
+  name: '@deepseek-ai/dsh-tool-fs'
+- id: token-meter
+  name: '@deepseek-ai/dsh-token-meter'
+- id: compaction-basic
+  name: '@deepseek-ai/dsh-compaction-basic'
+  config:
+    thresholdRatio: 0.8
+    retainRatio: 0.16
+    maxTokens: 8192
+    compactionRetries: 1
+`;
+export const ENGINE_SPECS = [
+    {
+        id: "claude",
+        label: "Claude Code",
+        version: CLAUDE_ENGINE_VERSION,
+        packages: { "@anthropic-ai/claude-agent-sdk": CLAUDE_ENGINE_VERSION },
+        entryRelativePath: join("node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs"),
+        expectedBytes: 240 * 1024 * 1024,
+        minimumNodeVersion: "20.0.0",
+        verifyRuntime: async (dir) => {
+            await import(__rewriteRelativeImportExtension(pathToFileURL(join(dir, "node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs")).href));
+        },
+    },
+    {
+        id: "dsh",
+        label: "DeepSeek Harness",
+        version: DSH_ENGINE_VERSION,
+        packages: DSH_PACKAGES,
+        entryRelativePath: join("node_modules", "@deepseek-ai", "dsh-sdk-client", "lib", "index.js"),
+        expectedBytes: 265 * 1024 * 1024,
+        minimumNodeVersion: "22.19.0",
+        prepareInstallation: async (dir) => {
+            await writeFile(join(dir, "dsh-runtime.cordis.yml"), DSH_RUNTIME_CONFIG, "utf8");
+            await mkdir(join(dir, "sessions"), { recursive: true });
+        },
+        verifyRuntime: async (dir) => {
+            const modulePath = join(dir, "node_modules", "@deepseek-ai", "dsh-sdk-client", "lib", "index.js");
+            const sdk = await import(__rewriteRelativeImportExtension(pathToFileURL(modulePath).href));
+            const runtime = new sdk.DeepSeekHarness({
+                launch: {
+                    command: process.execPath,
+                    args: [join(dir, "node_modules", "@deepseek-ai", "dsh-sdk-jsonrpc-demo", "lib", "bin.js"), join(dir, "dsh-runtime.cordis.yml")],
+                    cwd: dir,
+                    env: {
+                        ...process.env,
+                        DSH_CWD: dir,
+                        DSH_SESSION_ROOT: join(dir, "sessions"),
+                    },
+                    requestTimeoutMs: 30_000,
+                },
+                cwd: dir,
+                provider: "deepseek-official",
+                model: "deepseek-v4-flash",
+            });
+            try {
+                await runtime.start();
+            }
+            finally {
+                await runtime.close();
+            }
+        },
+    },
+];
+export const engineManager = new EngineManager({ specs: ENGINE_SPECS });

package/dist/src/feishu-api.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { extname, resolve as resolvePath } from "node:path";
 import { dirname, join } from "node:path";
 import sharp from "sharp";
-import { APP_ID, APP_SECRET, BASE_URL, CHAT_LOGS_DIR, PROJECT_ROOT, USER_DATA_DIR, CLAUDE_SESSION_PREFIX, CURSOR_SESSION_PREFIX, CODEX_SESSION_PREFIX, CCC_SESSION_PREFIX, ts, resolveDefaultAgentTool, toolDisplayName, config, } from "./config.js";
+import { APP_ID, APP_SECRET, BASE_URL, CHAT_LOGS_DIR, PROJECT_ROOT, USER_DATA_DIR, CLAUDE_SESSION_PREFIX, CURSOR_SESSION_PREFIX, CODEX_SESSION_PREFIX, CCC_SESSION_PREFIX, DSH_SESSION_PREFIX, ts, resolveDefaultAgentTool, toolDisplayName, config, } from "./config.js";
 import { getCursorUsageSummary } from "./cursor-usage.js";
 import { applyPrivacy } from "./privacy.js";
 import { buildHelpCard } from "./cards.js";
@@ -203,6 +203,7 @@ export function extractSessionInfo(description) {
         { prefix: CURSOR_SESSION_PREFIX, tool: "cursor" },
         { prefix: CODEX_SESSION_PREFIX, tool: "codex" },
         { prefix: CCC_SESSION_PREFIX, tool: "ccc" },
+        { prefix: DSH_SESSION_PREFIX, tool: "dsh" },
     ];
     for (const { prefix, tool } of PREFIXES) {
         const idx = description.indexOf(prefix);