@botcord/daemon 0.2.49 → 0.2.50

package/dist/gateway/runtimes/kimi.js

@@ -0,0 +1,204 @@
+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 '-')";
+}
+/** 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> --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",
+        ];
+        if (opts.extraArgs?.length)
+            args.push(...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.50",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

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();
+    }
+  });
+});

package/src/gateway/__tests__/dispatcher.test.ts

@@ -27,6 +27,7 @@ function silentLogger(): GatewayLogger {
 
 interface FakeChannelOptions {
   id?: string;
+  type?: string;
   withStream?: boolean;
   withTyping?: boolean;
   sendImpl?: (ctx: ChannelSendContext) => Promise<ChannelSendResult> | ChannelSendResult;
@@ -36,7 +37,7 @@ interface FakeChannelOptions {
 
 class FakeChannel implements ChannelAdapter {
   readonly id: string;
-  readonly type = "fake";
+  readonly type: string;
   readonly sends: ChannelSendContext[] = [];
   readonly streams: ChannelStreamBlockContext[] = [];
   readonly typings: ChannelTypingContext[] = [];
@@ -48,6 +49,7 @@ class FakeChannel implements ChannelAdapter {
 
   constructor(opts: FakeChannelOptions = {}) {
     this.id = opts.id ?? "botcord";
+    this.type = opts.type ?? "fake";
     this.sendImpl = opts.sendImpl;
     this.streamImpl = opts.streamImpl;
     this.typingImpl = opts.typingImpl;
@@ -659,8 +661,21 @@ describe("Dispatcher", () => {
     expect(channel.sends.length).toBe(1);
   });
 
-  it("typing: not fired when streamable is false", async () => {
-    const channel = new FakeChannel();
+  it("typing: fires for non-BotCord channels even when streamable is false", async () => {
+    const channel = new FakeChannel({ id: "gw_provider", type: "telegram" });
+    const { dispatcher } = await scaffold({
+      channel,
+      runtimeFactory: () => new FakeRuntime({ reply: "ok", newSessionId: "sid" }),
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({ channel: "gw_provider", trace: { id: "t1", streamable: false } }),
+    );
+    expect(channel.typings.length).toBe(1);
+  });
+
+  it("typing: not fired for BotCord rooms when streamable is false", async () => {
+    const channel = new FakeChannel({ type: "botcord" });
     const { dispatcher } = await scaffold({
       channel,
       runtimeFactory: () => new FakeRuntime({ reply: "ok", newSessionId: "sid" }),
@@ -672,6 +687,41 @@ describe("Dispatcher", () => {
     expect(channel.typings.length).toBe(0);
   });
 
+  it("typing: refreshes while a provider turn is still running", async () => {
+    vi.useFakeTimers();
+    try {
+      const channel = new FakeChannel({ id: "gw_tg", type: "telegram" });
+      const runtime = new FakeRuntime({ delayMs: 8500, reply: "ok", newSessionId: "sid" });
+      const { dispatcher } = await scaffold({ channel, runtimeFactory: () => runtime });
+
+      const pending = dispatcher.handle(
+        makeEnvelope({
+          channel: "gw_tg",
+          conversation: { id: "telegram:user:42", kind: "direct" },
+          trace: { id: "telegram:42:1", streamable: true },
+        }),
+      );
+
+      await vi.advanceTimersByTimeAsync(0);
+      expect(channel.typings.length).toBe(1);
+
+      await vi.advanceTimersByTimeAsync(4000);
+      expect(channel.typings.length).toBe(2);
+
+      await vi.advanceTimersByTimeAsync(4000);
+      expect(channel.typings.length).toBe(3);
+
+      await vi.advanceTimersByTimeAsync(500);
+      await pending;
+
+      await vi.advanceTimersByTimeAsync(4000);
+      expect(channel.typings.length).toBe(3);
+      expect(channel.sends.length).toBe(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("typing: not fired when channel has no typing capability", async () => {
     const channel = new FakeChannel({ withTyping: false });
     const { dispatcher } = await scaffold({