@botcord/daemon 0.2.49 → 0.2.51

package/dist/gateway/runtimes/kimi.js

@@ -0,0 +1,305 @@
+import { randomUUID } from "node:crypto";
+import { buildCliEnv } from "../cli-resolver.js";
+import { NdjsonStreamAdapter } from "./ndjson-stream.js";
+import { readCommandVersion, resolveCommandOnPath, } from "./probe.js";
+function isValidKimiSessionId(sessionId) {
+    if (sessionId.length === 0 || sessionId.length > 512)
+        return false;
+    if (sessionId.startsWith("-"))
+        return false;
+    for (const ch of sessionId) {
+        const code = ch.codePointAt(0);
+        if (code === undefined || code < 0x20 || code === 0x7f)
+            return false;
+    }
+    return true;
+}
+function invalidKimiSessionIdError() {
+    return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
+}
+const KIMI_EXTRA_FLAGS_WITH_VALUE = new Set([
+    "--add-dir",
+    "--agent",
+    "--agent-file",
+    "--config",
+    "--config-file",
+    "--max-ralph-iterations",
+    "--max-retries-per-step",
+    "--max-steps-per-turn",
+    "--mcp-config",
+    "--mcp-config-file",
+    "--model",
+    "--skills-dir",
+    "-m",
+]);
+const KIMI_EXTRA_BOOLEAN_FLAGS = new Set([
+    "--afk",
+    "--auto-approve",
+    "--debug",
+    "--no-thinking",
+    "--plan",
+    "--thinking",
+    "--verbose",
+    "--yes",
+    "--yolo",
+    "-y",
+]);
+// Flags owned by the adapter because BotCord depends on Kimi's non-interactive
+// stream-json contract, cwd isolation, prompt placement, and session routing.
+const KIMI_ADAPTER_OWNED_FLAGS = new Set([
+    "--acp",
+    "--command",
+    "--continue",
+    "--final-message-only",
+    "--help",
+    "--input-format",
+    "--output-format",
+    "--print",
+    "--prompt",
+    "--quiet",
+    "--resume",
+    "--session",
+    "--version",
+    "--wire",
+    "--work-dir",
+    "-C",
+    "-S",
+    "-V",
+    "-c",
+    "-h",
+    "-p",
+    "-r",
+    "-w",
+]);
+function flagName(arg) {
+    if (!arg.startsWith("-"))
+        return arg;
+    const eq = arg.indexOf("=");
+    return eq === -1 ? arg : arg.slice(0, eq);
+}
+function nextValue(args, index) {
+    const next = args[index + 1];
+    if (typeof next !== "string")
+        return undefined;
+    if (!next.startsWith("-"))
+        return next;
+    return /^-\d/.test(next) ? next : undefined;
+}
+function sanitizeKimiExtraArgs(extraArgs) {
+    if (!extraArgs?.length)
+        return [];
+    const out = [];
+    for (let i = 0; i < extraArgs.length; i += 1) {
+        const arg = extraArgs[i];
+        const name = flagName(arg);
+        if (KIMI_ADAPTER_OWNED_FLAGS.has(name)) {
+            if (!arg.includes("=") && nextValue(extraArgs, i) !== undefined)
+                i += 1;
+            continue;
+        }
+        if (KIMI_EXTRA_FLAGS_WITH_VALUE.has(name)) {
+            if (arg.includes("=")) {
+                out.push(arg);
+                continue;
+            }
+            const value = nextValue(extraArgs, i);
+            if (value !== undefined) {
+                out.push(arg, value);
+                i += 1;
+            }
+            continue;
+        }
+        if (KIMI_EXTRA_BOOLEAN_FLAGS.has(name)) {
+            out.push(arg);
+            continue;
+        }
+        if (arg.startsWith("-") && !arg.includes("=") && nextValue(extraArgs, i) !== undefined) {
+            i += 1;
+        }
+    }
+    return out;
+}
+/** Resolve the Kimi CLI executable on PATH. */
+export function resolveKimiCommand(deps = {}) {
+    return resolveCommandOnPath("kimi", deps);
+}
+/** Probe whether the Kimi CLI is installed and report its version. */
+export function probeKimi(deps = {}) {
+    const command = resolveKimiCommand(deps);
+    if (!command)
+        return { available: false };
+    return {
+        available: true,
+        path: command,
+        version: readCommandVersion(command, [], deps) ?? undefined,
+    };
+}
+/**
+ * Kimi CLI adapter — spawns:
+ *
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --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 class KimiAdapter extends NdjsonStreamAdapter {
+    id = "kimi-cli";
+    explicitBinary;
+    resolvedBinary = null;
+    constructor(opts) {
+        super();
+        this.explicitBinary = opts?.binary ?? process.env.BOTCORD_KIMI_CLI_BIN;
+    }
+    probe() {
+        return probeKimi();
+    }
+    async run(opts) {
+        if (opts.sessionId && !isValidKimiSessionId(opts.sessionId)) {
+            return { text: "", newSessionId: "", error: invalidKimiSessionIdError() };
+        }
+        const sessionId = opts.sessionId || randomUUID();
+        return super.run({ ...opts, sessionId });
+    }
+    resolveBinary() {
+        if (this.explicitBinary)
+            return this.explicitBinary;
+        if (this.resolvedBinary)
+            return this.resolvedBinary;
+        this.resolvedBinary = resolveKimiCommand() ?? "kimi";
+        return this.resolvedBinary;
+    }
+    buildArgs(opts) {
+        const sessionId = opts.sessionId || randomUUID();
+        if (!isValidKimiSessionId(sessionId))
+            throw new Error(invalidKimiSessionIdError());
+        const args = [
+            "--work-dir",
+            opts.cwd,
+            "--print",
+            "--output-format",
+            "stream-json",
+            "--session",
+            sessionId,
+            "--afk",
+        ];
+        args.push(...sanitizeKimiExtraArgs(opts.extraArgs));
+        args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
+        return args;
+    }
+    spawnEnv(opts) {
+        const cliEnv = buildCliEnv({
+            hubUrl: opts.hubUrl,
+            accountId: opts.accountId,
+            basePath: process.env.PATH,
+        });
+        return {
+            ...process.env,
+            ...cliEnv,
+            FORCE_COLOR: "0",
+            NO_COLOR: "1",
+        };
+    }
+    handleEvent(raw, ctx) {
+        const obj = raw;
+        const status = kimiStatusEvent(obj);
+        if (status)
+            ctx.emitStatus(status);
+        ctx.emitBlock(normalizeBlock(obj, ctx.seq));
+        const sessionId = kimiSessionId(obj);
+        if (sessionId)
+            ctx.state.newSessionId = sessionId;
+        if (obj.role === "assistant") {
+            const text = extractText(obj.content);
+            if (text) {
+                ctx.appendAssistantText(text);
+                ctx.state.finalText = text;
+            }
+            return;
+        }
+        const err = kimiErrorText(obj);
+        if (err)
+            ctx.state.errorText = err;
+    }
+}
+function promptWithSystemContext(text, systemContext) {
+    if (!systemContext)
+        return text;
+    return `<system-reminder>\n${systemContext}\n</system-reminder>\n\n${text}`;
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("");
+}
+function hasThinking(content) {
+    return Array.isArray(content)
+        ? content.some((part) => part?.type === "think" && typeof part.think === "string" && part.think)
+        : false;
+}
+function firstToolName(toolCalls) {
+    const name = toolCalls?.find((t) => typeof t.function?.name === "string")?.function?.name;
+    return name || "tool";
+}
+function kimiSessionId(obj) {
+    return typeof obj.session_id === "string" && obj.session_id ? obj.session_id : undefined;
+}
+function kimiErrorText(obj) {
+    if (typeof obj.error === "string" && obj.error)
+        return obj.error;
+    if (obj.error && typeof obj.error === "object") {
+        const message = obj.error.message;
+        if (typeof message === "string" && message)
+            return message;
+    }
+    if (obj.type === "error" && typeof obj.message === "string" && obj.message) {
+        return obj.message;
+    }
+    if (obj.severity === "error") {
+        return [obj.title, obj.body].filter(Boolean).join(": ") || "kimi-cli error";
+    }
+    return undefined;
+}
+function kimiStatusEvent(obj) {
+    if (obj.role === "assistant" && hasThinking(obj.content)) {
+        return { kind: "thinking", phase: "started", label: "Thinking" };
+    }
+    if (obj.role === "assistant" && obj.tool_calls?.length) {
+        return { kind: "thinking", phase: "updated", label: firstToolName(obj.tool_calls) };
+    }
+    if (obj.role === "assistant" && extractText(obj.content)) {
+        return { kind: "thinking", phase: "stopped" };
+    }
+    if (obj.role === "tool") {
+        return { kind: "thinking", phase: "updated", label: "Tool result" };
+    }
+    return undefined;
+}
+function normalizeBlock(obj, seq) {
+    let kind = "other";
+    if (obj.role === "assistant") {
+        if (obj.tool_calls?.length)
+            kind = "tool_use";
+        else if (extractText(obj.content))
+            kind = "assistant_text";
+        else if (hasThinking(obj.content))
+            kind = "other";
+    }
+    else if (obj.role === "tool") {
+        kind = "tool_result";
+    }
+    else if (obj.file_path && typeof obj.content === "string") {
+        kind = "other";
+    }
+    else if (obj.category || obj.severity) {
+        kind = "system";
+    }
+    return { raw: obj, kind, seq };
+}

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

@@ -33,6 +33,10 @@ export interface RuntimeModule {
 export declare const claudeCodeModule: RuntimeModule;
 /** Built-in runtime module entry for Codex. */
 export declare const codexModule: RuntimeModule;
+/** Built-in runtime module entry for DeepSeek TUI. */
+export declare const deepseekTuiModule: RuntimeModule;
+/** Built-in runtime module entry for Kimi CLI. */
+export declare const kimiModule: RuntimeModule;
 /** Built-in runtime module entry for Hermes Agent (ACP stdio). */
 export declare const hermesAgentModule: RuntimeModule;
 /** Built-in runtime module entry for Gemini (probe-only stub). */

package/dist/gateway/runtimes/registry.js

@@ -1,7 +1,9 @@
 import { ClaudeCodeAdapter, probeClaude } from "./claude-code.js";
 import { CodexAdapter, probeCodex } from "./codex.js";
+import { DeepseekTuiAdapter, probeDeepseekTui } from "./deepseek-tui.js";
 import { GeminiAdapter, probeGemini } from "./gemini.js";
 import { HermesAgentAdapter, probeHermesAgent } from "./hermes-agent.js";
+import { KimiAdapter, probeKimi } from "./kimi.js";
 import { OpenclawAcpAdapter, probeOpenclaw } from "./openclaw-acp.js";
 /** Built-in runtime module entry for Claude Code. */
 export const claudeCodeModule = {
@@ -20,6 +22,25 @@ export const codexModule = {
     probe: () => probeCodex(),
     create: () => new CodexAdapter(),
 };
+/** Built-in runtime module entry for DeepSeek TUI. */
+export const deepseekTuiModule = {
+    id: "deepseek-tui",
+    displayName: "DeepSeek TUI",
+    binary: "deepseek",
+    envVar: "BOTCORD_DEEPSEEK_TUI_BIN",
+    probe: () => probeDeepseekTui(),
+    create: () => new DeepseekTuiAdapter(),
+    installHint: "Install DeepSeek TUI and ensure the `deepseek` dispatcher is on PATH, or set BOTCORD_DEEPSEEK_TUI_BIN.",
+};
+/** Built-in runtime module entry for Kimi CLI. */
+export const kimiModule = {
+    id: "kimi-cli",
+    displayName: "Kimi CLI",
+    binary: "kimi",
+    envVar: "BOTCORD_KIMI_CLI_BIN",
+    probe: () => probeKimi(),
+    create: () => new KimiAdapter(),
+};
 /** Built-in runtime module entry for Hermes Agent (ACP stdio). */
 export const hermesAgentModule = {
     id: "hermes-agent",
@@ -57,6 +78,8 @@ export const openclawAcpModule = {
 export const RUNTIME_MODULES = [
     claudeCodeModule,
     codexModule,
+    deepseekTuiModule,
+    kimiModule,
     hermesAgentModule,
     geminiModule,
     openclawAcpModule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -618,6 +618,92 @@ describe("createBotCordChannel — streamBlock()", () => {
     }
   });
 
+  it("normalizes DeepSeek message.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 4,
+          raw: {
+            event: "message.delta",
+            payload: { thread_id: "thr_1", turn_id: "turn_1", content: "hello " },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 4,
+        payload: { text: "hello " },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
+  it("normalizes DeepSeek item.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 5,
+          raw: {
+            event: "item.delta",
+            payload: {
+              thread_id: "thr_1",
+              turn_id: "turn_1",
+              payload: { kind: "agent_message", delta: "deepseek" },
+            },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 5,
+        payload: { text: "deepseek" },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
   it("normalizes a thinking block with phase/label/source payload", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;

package/src/gateway/__tests__/deepseek-tui-adapter.test.ts

@@ -0,0 +1,212 @@
+import { afterAll, describe, expect, it } from "vitest";
+import http, { type ServerResponse } from "node:http";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DeepseekTuiAdapter } from "../runtimes/deepseek-tui.js";
+
+const tmpRoot = mkdtempSync(path.join(os.tmpdir(), "gateway-deepseek-tui-"));
+
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function sse(event: string, data: unknown): string {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+async function startMockDeepseekServer(opts?: {
+  token?: string;
+  threadId?: string;
+  turnId?: string;
+  events?: Array<{ event: string; data: unknown }>;
+}) {
+  const token = opts?.token ?? "test-token";
+  const threadId = opts?.threadId ?? "thr_test";
+  const turnId = opts?.turnId ?? "turn_test";
+  const events =
+    opts?.events ??
+    [
+      { event: "turn.started", data: { thread_id: threadId, turn_id: turnId } },
+      { event: "tool.started", data: { id: "tool_1", name: "shell", input: { command: "pwd" } } },
+      { event: "tool.completed", data: { id: "tool_1", success: true, output: "/tmp" } },
+      { event: "message.delta", data: { thread_id: threadId, turn_id: turnId, content: "hello " } },
+      { event: "message.delta", data: { thread_id: threadId, turn_id: turnId, content: "deepseek" } },
+      { event: "turn.completed", data: { thread_id: threadId, turn_id: turnId, usage: {} } },
+    ];
+
+  const calls: Array<{ method: string; url: string; body?: any; auth?: string }> = [];
+  let eventRes: ServerResponse | null = null;
+
+  const server = http.createServer((req, res) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    req.on("end", () => {
+      const rawBody = Buffer.concat(chunks).toString("utf8");
+      const body = rawBody ? JSON.parse(rawBody) : undefined;
+      calls.push({
+        method: req.method ?? "",
+        url: req.url ?? "",
+        body,
+        auth: req.headers.authorization,
+      });
+
+      if (req.url === "/health") {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+        return;
+      }
+      if (req.headers.authorization !== `Bearer ${token}`) {
+        res.writeHead(401, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "unauthorized" }));
+        return;
+      }
+      if (req.method === "POST" && req.url === "/v1/threads") {
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ id: threadId }));
+        return;
+      }
+      if (req.method === "PATCH" && req.url === `/v1/threads/${threadId}`) {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ id: threadId }));
+        return;
+      }
+      if (req.method === "GET" && req.url === `/v1/threads/${threadId}/events?since_seq=0`) {
+        res.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache",
+          connection: "keep-alive",
+        });
+        eventRes = res;
+        return;
+      }
+      if (req.method === "POST" && req.url === `/v1/threads/${threadId}/turns`) {
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ thread: { id: threadId }, turn: { id: turnId } }));
+        setTimeout(() => {
+          for (const ev of events) eventRes?.write(sse(ev.event, ev.data));
+          eventRes?.end();
+        }, 5);
+        return;
+      }
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "not found" }));
+    });
+  });
+
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const addr = server.address();
+  if (!addr || typeof addr !== "object") throw new Error("server did not bind");
+  return {
+    baseUrl: `http://127.0.0.1:${addr.port}`,
+    token,
+    threadId,
+    calls,
+    close: () => new Promise<void>((resolve) => server.close(() => resolve())),
+  };
+}
+
+function runAdapter(serverUrl: string, authToken: string, sessionId: string | null = null) {
+  const adapter = new DeepseekTuiAdapter({ serverUrl, authToken });
+  const ctrl = new AbortController();
+  const blocks: string[] = [];
+  const status: Array<{ phase: string; label?: string }> = [];
+  const result = adapter.run({
+    text: "hi",
+    sessionId,
+    accountId: "ag_deepseek",
+    cwd: tmpRoot,
+    signal: ctrl.signal,
+    trustLevel: "owner",
+    systemContext: "runtime memory",
+    onBlock: (b) => blocks.push(b.kind),
+    onStatus: (e) => {
+      if (e.kind === "thinking") status.push({ phase: e.phase, label: e.label });
+    },
+  });
+  return { result, blocks, status };
+}
+
+describe("DeepseekTuiAdapter", () => {
+  it("creates a thread, starts a turn, parses SSE assistant text, and emits tool blocks", async () => {
+    const server = await startMockDeepseekServer();
+    try {
+      const { result, blocks, status } = runAdapter(server.baseUrl, server.token);
+      const res = await result;
+      expect(res).toEqual({ text: "hello deepseek", newSessionId: server.threadId });
+      expect(blocks).toContain("tool_use");
+      expect(blocks).toContain("tool_result");
+      expect(blocks).toContain("assistant_text");
+      expect(status).toContainEqual({ phase: "started", label: "Thinking" });
+      expect(status).toContainEqual({ phase: "updated", label: "shell" });
+      expect(status.at(-1)).toEqual({ phase: "stopped", label: undefined });
+      expect(server.calls.find((c) => c.method === "POST" && c.url === "/v1/threads")?.body).toMatchObject({
+        workspace: tmpRoot,
+        system_prompt: "runtime memory",
+        auto_approve: true,
+      });
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("reuses an existing DeepSeek thread id and patches per-turn system context", async () => {
+    const server = await startMockDeepseekServer({ threadId: "thr_existing" });
+    try {
+      const { result } = runAdapter(server.baseUrl, server.token, "thr_existing");
+      const res = await result;
+      expect(res.newSessionId).toBe("thr_existing");
+      expect(server.calls.some((c) => c.method === "POST" && c.url === "/v1/threads")).toBe(false);
+      const patch = server.calls.find((c) => c.method === "PATCH");
+      expect(patch?.url).toBe("/v1/threads/thr_existing");
+      expect(patch?.body).toEqual({ system_prompt: "runtime memory" });
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("clears stale session ids when DeepSeek reports the thread missing", async () => {
+    const server = await startMockDeepseekServer({ threadId: "thr_other" });
+    try {
+      const adapter = new DeepseekTuiAdapter({ serverUrl: server.baseUrl, authToken: server.token });
+      const ctrl = new AbortController();
+      const res = await adapter.run({
+        text: "hi",
+        sessionId: "thr_missing",
+        accountId: "ag_deepseek",
+        cwd: tmpRoot,
+        signal: ctrl.signal,
+        trustLevel: "owner",
+      });
+      expect(res.newSessionId).toBe("");
+      expect(res.error).toMatch(/HTTP 404/);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("returns a runtime error when DeepSeek completes the turn as failed", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        { event: "turn.started", data: { thread_id: "thr_test", turn_id: "turn_test" } },
+        {
+          event: "turn.completed",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            payload: { turn: { status: "failed", error: "missing api key" } },
+          },
+        },
+      ],
+    });
+    try {
+      const { result } = runAdapter(server.baseUrl, server.token);
+      const res = await result;
+      expect(res.text).toBe("");
+      expect(res.newSessionId).toBe("thr_test");
+      expect(res.error).toBe("missing api key");
+    } finally {
+      await server.close();
+    }
+  });
+});