@botcord/daemon 0.2.49 → 0.2.50

package/dist/gateway/runtimes/deepseek-tui.js

@@ -0,0 +1,560 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import net from "node:net";
+import { buildCliEnv } from "../cli-resolver.js";
+import { consoleLogger } from "../log.js";
+import { readCommandVersion, resolveCommandOnPath, } from "./probe.js";
+const log = consoleLogger;
+const DEEPSEEK_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const STARTUP_TIMEOUT_MS = 30_000;
+const STARTUP_POLL_MS = 250;
+const SSE_TEXT_CAP = 1 * 1024 * 1024;
+const PROCESS_POOL = new Map();
+/** Resolve the `deepseek` dispatcher CLI on PATH. */
+export function resolveDeepseekCommand(deps = {}) {
+    const explicit = (deps.env ?? process.env).BOTCORD_DEEPSEEK_TUI_BIN;
+    if (explicit && explicit.length > 0)
+        return explicit;
+    const onPath = resolveCommandOnPath("deepseek", deps);
+    if (!onPath)
+        return null;
+    return resolveDownloadedDeepseekBinary(onPath, deps) ?? onPath;
+}
+/** Probe whether DeepSeek TUI is installed and report its version. */
+export function probeDeepseekTui(deps = {}) {
+    const command = resolveDeepseekCommand(deps);
+    if (!command)
+        return { available: false };
+    return {
+        available: true,
+        path: command,
+        version: readCommandVersion(command, [], deps) ?? undefined,
+    };
+}
+/**
+ * DeepSeek TUI adapter.
+ *
+ * Drives the headless runtime API exposed by `deepseek serve --http`, not the
+ * interactive TUI and not ACP. The HTTP/SSE API is the documented complete
+ * runtime surface; ACP is currently a conservative editor baseline.
+ */
+export class DeepseekTuiAdapter {
+    id = "deepseek-tui";
+    explicitBinary;
+    explicitServerUrl;
+    explicitAuthToken;
+    fetchFn;
+    spawnFn;
+    resolvedBinary = null;
+    constructor(deps = {}) {
+        this.explicitBinary = deps.binary ?? process.env.BOTCORD_DEEPSEEK_TUI_BIN;
+        this.explicitServerUrl = deps.serverUrl ?? process.env.BOTCORD_DEEPSEEK_TUI_URL;
+        this.explicitAuthToken = deps.authToken ?? process.env.BOTCORD_DEEPSEEK_TUI_TOKEN;
+        this.fetchFn = deps.fetchFn ?? fetch;
+        this.spawnFn = deps.spawnFn ?? spawn;
+    }
+    probe() {
+        return probeDeepseekTui();
+    }
+    async run(opts) {
+        if (opts.signal.aborted) {
+            return {
+                text: "",
+                newSessionId: opts.sessionId ?? "",
+                error: "deepseek-tui aborted before start",
+            };
+        }
+        const handle = await this.acquireHandle(opts);
+        handle.inFlight += 1;
+        if (handle.idleTimer)
+            clearTimeout(handle.idleTimer);
+        const turnAbort = new AbortController();
+        const onAbort = () => turnAbort.abort();
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+        try {
+            const headers = authHeaders(handle.token);
+            let threadId = opts.sessionId?.trim() || "";
+            if (threadId && !isValidThreadId(threadId)) {
+                return {
+                    text: "",
+                    newSessionId: "",
+                    error: "deepseek-tui: invalid sessionId",
+                };
+            }
+            if (!threadId) {
+                threadId = await this.createThread(handle.baseUrl, headers, opts, turnAbort.signal);
+            }
+            else if (opts.systemContext !== undefined) {
+                await this.patchThreadSystemContext(handle.baseUrl, headers, threadId, opts.systemContext, turnAbort.signal);
+            }
+            const runResult = await this.startTurnAndReadEvents({
+                baseUrl: handle.baseUrl,
+                headers,
+                threadId,
+                opts,
+                signal: turnAbort.signal,
+            });
+            const text = runResult.text;
+            return {
+                text,
+                newSessionId: threadId,
+                ...(runResult.error ? { error: runResult.error } : {}),
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const staleSession = opts.sessionId && /404|not found|missing/i.test(message);
+            return {
+                text: "",
+                newSessionId: staleSession ? "" : opts.sessionId ?? "",
+                error: `deepseek-tui: ${message}`,
+            };
+        }
+        finally {
+            opts.signal.removeEventListener("abort", onAbort);
+            handle.inFlight -= 1;
+            if (!this.explicitServerUrl)
+                resetIdle(handle, poolKey(opts));
+        }
+    }
+    resolveBinary() {
+        if (this.explicitBinary)
+            return this.explicitBinary;
+        if (this.resolvedBinary)
+            return this.resolvedBinary;
+        this.resolvedBinary = resolveDeepseekCommand() ?? "deepseek";
+        return this.resolvedBinary;
+    }
+    async acquireHandle(opts) {
+        if (this.explicitServerUrl) {
+            return {
+                child: nullChild(),
+                baseUrl: trimTrailingSlash(this.explicitServerUrl),
+                token: this.explicitAuthToken ?? "",
+                closed: false,
+                inFlight: 0,
+                stderrTail: "",
+            };
+        }
+        const key = poolKey(opts);
+        const existing = PROCESS_POOL.get(key);
+        if (existing && !existing.closed)
+            return existing;
+        const port = await findFreePort();
+        const token = randomToken();
+        const baseUrl = `http://127.0.0.1:${port}`;
+        const child = this.spawnFn(this.resolveBinary(), ["serve", "--http", "--host", "127.0.0.1", "--port", String(port), "--auth-token", token], {
+            cwd: opts.cwd,
+            env: this.spawnEnv(opts),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const handle = {
+            child,
+            baseUrl,
+            token,
+            closed: false,
+            inFlight: 0,
+            stderrTail: "",
+        };
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            handle.stderrTail = (handle.stderrTail + chunk).slice(-4096);
+        });
+        child.on("close", () => {
+            handle.closed = true;
+            PROCESS_POOL.delete(key);
+        });
+        child.on("error", () => {
+            handle.closed = true;
+            PROCESS_POOL.delete(key);
+        });
+        await waitForHealth(baseUrl, this.fetchFn, child, STARTUP_TIMEOUT_MS);
+        PROCESS_POOL.set(key, handle);
+        resetIdle(handle, key);
+        return handle;
+    }
+    spawnEnv(opts) {
+        const env = {
+            ...process.env,
+            ...buildCliEnv({
+                hubUrl: opts.hubUrl,
+                accountId: opts.accountId,
+                basePath: process.env.PATH,
+            }),
+            FORCE_COLOR: "0",
+            NO_COLOR: "1",
+        };
+        if (opts.accountId) {
+            const runtimeDir = path.join(agentDeepseekHomeDir(opts.accountId), "runtime");
+            mkdirSync(runtimeDir, { recursive: true });
+            env.DEEPSEEK_RUNTIME_DIR = runtimeDir;
+        }
+        return env;
+    }
+    async createThread(baseUrl, headers, opts, signal) {
+        const body = {
+            workspace: opts.cwd,
+            mode: "agent",
+            allow_shell: opts.trustLevel !== "public",
+            trust_mode: opts.trustLevel !== "public",
+            auto_approve: opts.trustLevel !== "public",
+            archived: false,
+        };
+        if (opts.systemContext)
+            body.system_prompt = opts.systemContext;
+        const res = await this.requestJson(`${baseUrl}/v1/threads`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        const id = stringField(res, "id") ?? stringField(res, "thread_id");
+        if (!id)
+            throw new Error("create thread response missing id");
+        return id;
+    }
+    async patchThreadSystemContext(baseUrl, headers, threadId, systemContext, signal) {
+        await this.requestJson(`${baseUrl}/v1/threads/${encodeURIComponent(threadId)}`, {
+            method: "PATCH",
+            headers,
+            body: JSON.stringify({ system_prompt: systemContext ?? "" }),
+            signal,
+        });
+    }
+    async startTurnAndReadEvents(args) {
+        const { baseUrl, headers, threadId, opts, signal } = args;
+        const eventsUrl = `${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/events?since_seq=0`;
+        const eventsAbort = new AbortController();
+        const onAbort = () => eventsAbort.abort();
+        signal.addEventListener("abort", onAbort, { once: true });
+        let eventsError;
+        const eventsReaderPromise = this.readEvents(eventsUrl, headers, opts, eventsAbort.signal).catch((err) => {
+            eventsError = err;
+            return null;
+        });
+        let turnId = "";
+        try {
+            const started = await this.requestJson(`${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/turns`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    prompt: opts.text,
+                    mode: "agent",
+                    allow_shell: opts.trustLevel !== "public",
+                    trust_mode: opts.trustLevel !== "public",
+                    auto_approve: opts.trustLevel !== "public",
+                }),
+                signal,
+            });
+            turnId = stringField(started?.turn, "id") ?? stringField(started, "turn_id") ?? "";
+            const eventsReader = await eventsReaderPromise;
+            if (!eventsReader)
+                throw eventsError ?? new Error("events stream failed");
+            return await eventsReader(turnId);
+        }
+        catch (err) {
+            throw err;
+        }
+        finally {
+            eventsAbort.abort();
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+    async readEvents(url, headers, opts, signal) {
+        const res = await this.fetchFn(url, { method: "GET", headers, signal });
+        if (!res.ok)
+            throw new Error(`events stream failed HTTP ${res.status}`);
+        if (!res.body)
+            throw new Error("events stream response missing body");
+        const reader = res.body.getReader();
+        return async (turnId) => {
+            const decoder = new TextDecoder();
+            let buf = "";
+            let seq = 0;
+            let text = "";
+            let errorText = "";
+            let capped = false;
+            const append = (chunk) => {
+                if (!chunk || capped)
+                    return;
+                const budget = SSE_TEXT_CAP - Buffer.byteLength(text, "utf8");
+                if (budget <= 0) {
+                    capped = true;
+                    return;
+                }
+                if (Buffer.byteLength(chunk, "utf8") > budget) {
+                    text += chunk.slice(0, budget);
+                    capped = true;
+                    return;
+                }
+                text += chunk;
+            };
+            const emit = (eventName, payload) => {
+                const eventTurnId = stringField(payload, "turn_id") ?? stringField(payload?.payload, "turn_id");
+                if (turnId && eventTurnId && eventTurnId !== turnId)
+                    return false;
+                seq += 1;
+                const block = normalizeDeepseekEvent(eventName, payload, seq);
+                if (block)
+                    opts.onBlock?.(block);
+                const extractedError = extractDeepseekError(eventName, payload);
+                if (extractedError)
+                    errorText = extractedError;
+                if (eventName === "message.delta") {
+                    append(stringField(payload, "content") ?? "");
+                }
+                else if (eventName === "item.delta" && payload?.payload?.kind === "agent_message") {
+                    append(stringField(payload.payload, "delta") ?? "");
+                }
+                if (eventName === "turn.started") {
+                    opts.onStatus?.({ kind: "thinking", phase: "started", label: "Thinking" });
+                }
+                else if (eventName === "tool.started" || isToolStarted(payload)) {
+                    const label = stringField(payload, "name") ?? stringField(payload?.payload?.tool, "name") ?? "tool";
+                    opts.onStatus?.({ kind: "thinking", phase: "updated", label });
+                }
+                else if (eventName === "turn.completed" || eventName === "done") {
+                    opts.onStatus?.({ kind: "thinking", phase: "stopped" });
+                    return true;
+                }
+                return false;
+            };
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf("\n\n")) !== -1) {
+                    const frame = parseSseFrame(buf.slice(0, idx));
+                    buf = buf.slice(idx + 2);
+                    if (!frame)
+                        continue;
+                    if (emit(frame.event, frame.data)) {
+                        await reader.cancel().catch(() => undefined);
+                        return { text: text.trim(), ...(errorText ? { error: errorText } : {}) };
+                    }
+                }
+            }
+            if (buf.trim()) {
+                const frame = parseSseFrame(buf);
+                if (frame)
+                    emit(frame.event, frame.data);
+            }
+            return { text: text.trim(), ...(errorText ? { error: errorText } : {}) };
+        };
+    }
+    async requestJson(url, init) {
+        const headers = new Headers(init.headers);
+        if (!headers.has("content-type") && init.body)
+            headers.set("content-type", "application/json");
+        const res = await this.fetchFn(url, { ...init, headers });
+        if (!res.ok) {
+            let detail = "";
+            try {
+                detail = await res.text();
+            }
+            catch {
+                // ignore
+            }
+            throw new Error(`HTTP ${res.status}${detail ? `: ${detail.slice(0, 300)}` : ""}`);
+        }
+        return (await res.json());
+    }
+}
+export function __resetDeepseekTuiPoolForTests() {
+    for (const [key, handle] of PROCESS_POOL.entries()) {
+        shutdownHandle(handle, "test-reset");
+        PROCESS_POOL.delete(key);
+    }
+}
+function normalizeDeepseekEvent(eventName, payload, seq) {
+    if (eventName === "message.delta") {
+        return { raw: { event: eventName, payload }, kind: "assistant_text", seq };
+    }
+    if (eventName === "tool.started" || isToolStarted(payload)) {
+        return { raw: { event: eventName, payload }, kind: "tool_use", seq };
+    }
+    if (eventName === "tool.completed" || isToolCompleted(payload)) {
+        return { raw: { event: eventName, payload }, kind: "tool_result", seq };
+    }
+    if (eventName === "item.delta" && payload?.payload?.kind === "agent_message") {
+        return { raw: { event: eventName, payload }, kind: "assistant_text", seq };
+    }
+    if (eventName === "turn.started" || eventName === "status") {
+        return { raw: { event: eventName, payload }, kind: "system", seq };
+    }
+    if (eventName === "error" || eventName === "turn.completed" || eventName === "done") {
+        return { raw: { event: eventName, payload }, kind: "other", seq };
+    }
+    return null;
+}
+function isToolStarted(payload) {
+    return payload?.event === "item.started" && !!payload?.payload?.tool;
+}
+function isToolCompleted(payload) {
+    const kind = payload?.payload?.item?.kind;
+    return ((payload?.event === "item.completed" || payload?.event === "item.failed") &&
+        (kind === "tool_call" || kind === "file_change" || kind === "command_execution"));
+}
+function extractDeepseekError(eventName, payload) {
+    if (eventName === "error") {
+        return (stringField(payload, "message") ??
+            stringField(payload, "error") ??
+            stringField(payload?.payload, "message") ??
+            stringField(payload?.payload, "error"));
+    }
+    if (eventName === "item.failed") {
+        return (stringField(payload?.payload?.item, "detail") ??
+            stringField(payload?.payload?.item, "summary") ??
+            stringField(payload?.payload, "error"));
+    }
+    if (eventName === "turn.completed") {
+        const turn = payload?.payload?.turn ?? payload?.turn;
+        const status = stringField(turn, "status");
+        const err = stringField(turn, "error");
+        if (err)
+            return err;
+        if (status && status !== "completed")
+            return `DeepSeek turn ${status}`;
+    }
+    return undefined;
+}
+function parseSseFrame(raw) {
+    let event = "message";
+    const dataLines = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (line.startsWith("event:"))
+            event = line.slice("event:".length).trim();
+        else if (line.startsWith("data:"))
+            dataLines.push(line.slice("data:".length).trimStart());
+    }
+    if (dataLines.length === 0)
+        return null;
+    try {
+        return { event, data: JSON.parse(dataLines.join("\n")) };
+    }
+    catch {
+        return { event, data: { content: dataLines.join("\n") } };
+    }
+}
+function authHeaders(token) {
+    return token ? { authorization: `Bearer ${token}` } : {};
+}
+function poolKey(opts) {
+    return opts.accountId || "default";
+}
+function resetIdle(handle, key) {
+    if (handle.idleTimer)
+        clearTimeout(handle.idleTimer);
+    if (handle.inFlight > 0 || handle.closed)
+        return;
+    handle.idleTimer = setTimeout(() => {
+        if (handle.inFlight === 0 && !handle.closed) {
+            log.info("deepseek-tui.idle-timeout", { key });
+            shutdownHandle(handle, "idle-timeout");
+            PROCESS_POOL.delete(key);
+        }
+    }, DEEPSEEK_IDLE_TIMEOUT_MS);
+    handle.idleTimer.unref?.();
+}
+function shutdownHandle(handle, reason) {
+    if (handle.closed)
+        return;
+    handle.closed = true;
+    if (handle.idleTimer)
+        clearTimeout(handle.idleTimer);
+    try {
+        handle.child.kill("SIGTERM");
+    }
+    catch {
+        // no-op
+    }
+    try {
+        handle.child.stdout?.destroy();
+        handle.child.stderr?.destroy();
+        handle.child.stdin?.destroy();
+        handle.child.unref();
+    }
+    catch {
+        // no-op
+    }
+    log.debug("deepseek-tui.shutdown", { reason });
+}
+async function waitForHealth(baseUrl, fetchFn, child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError = "";
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`deepseek serve exited with code ${child.exitCode}`);
+        }
+        try {
+            const res = await fetchFn(`${baseUrl}/health`, { method: "GET" });
+            if (res.ok)
+                return;
+            lastError = `HTTP ${res.status}`;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err.message : String(err);
+        }
+        await sleep(STARTUP_POLL_MS);
+    }
+    throw new Error(`deepseek serve did not become healthy: ${lastError}`);
+}
+async function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.on("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            srv.close(() => {
+                if (typeof addr === "object" && addr?.port)
+                    resolve(addr.port);
+                else
+                    reject(new Error("failed to allocate port"));
+            });
+        });
+    });
+}
+function randomToken() {
+    return `bc_ds_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stringField(obj, key) {
+    const v = obj?.[key];
+    return typeof v === "string" ? v : undefined;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function isValidThreadId(id) {
+    return id.length > 0 && id.length <= 256 && !/[\u0000-\u001f\u007f]/.test(id);
+}
+function resolveDownloadedDeepseekBinary(onPath, deps = {}) {
+    const exists = deps.existsSyncFn ?? existsSync;
+    try {
+        const resolved = realpathSync(onPath);
+        const candidate = path.join(path.dirname(resolved), "downloads", "deepseek");
+        return exists(candidate) ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
+function agentDeepseekHomeDir(accountId) {
+    return path.join(homedir(), ".botcord", "agents", accountId, "deepseek-tui");
+}
+function nullChild() {
+    return {
+        kill: () => true,
+        on: () => nullChild(),
+        stderr: { setEncoding: () => undefined, on: () => undefined },
+        stdout: { setEncoding: () => undefined, on: () => undefined },
+        stdin: { write: () => true },
+        exitCode: null,
+    };
+}

package/dist/gateway/runtimes/kimi.d.ts

@@ -0,0 +1,32 @@
+import { NdjsonStreamAdapter, type NdjsonEventCtx } from "./ndjson-stream.js";
+import { type ProbeDeps } from "./probe.js";
+import type { RuntimeProbeResult, RuntimeRunOptions } from "../types.js";
+/** Resolve the Kimi CLI executable on PATH. */
+export declare function resolveKimiCommand(deps?: ProbeDeps): string | null;
+/** Probe whether the Kimi CLI is installed and report its version. */
+export declare function probeKimi(deps?: ProbeDeps): RuntimeProbeResult;
+/**
+ * Kimi CLI adapter — spawns:
+ *
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *
+ * `--session <sid>` resumes an existing session or creates a new session with
+ * that id, so the adapter generates a UUID on first turn and persists it for
+ * later turns. Kimi does not expose a Codex-style per-invocation AGENTS.md
+ * carrier, so dynamic `systemContext` is sent as a system-reminder prefix on
+ * the user prompt.
+ */
+export declare class KimiAdapter extends NdjsonStreamAdapter {
+    readonly id: "kimi-cli";
+    private readonly explicitBinary;
+    private resolvedBinary;
+    constructor(opts?: {
+        binary?: string;
+    });
+    probe(): RuntimeProbeResult;
+    run(opts: RuntimeRunOptions): Promise<import("../types.js").RuntimeRunResult>;
+    protected resolveBinary(): string;
+    protected buildArgs(opts: RuntimeRunOptions): string[];
+    protected spawnEnv(opts: RuntimeRunOptions): NodeJS.ProcessEnv;
+    protected handleEvent(raw: unknown, ctx: NdjsonEventCtx): void;
+}