@botcord/daemon 0.2.84 → 0.2.86

package/dist/skill-index.d.ts

@@ -5,6 +5,17 @@ export interface SoftSkillEntry {
     description?: string;
     mtimeMs: number;
 }
+export interface AgentSkillSnapshotEntry {
+    name: string;
+    source: string;
+    description?: string;
+    mtimeMs: number;
+}
+export interface AgentSkillSnapshot {
+    agentId: string;
+    skills: AgentSkillSnapshotEntry[];
+    probedAt: number;
+}
 export interface SkillIndexOptions {
     extraDirs?: string[];
     includeGlobal?: boolean;
@@ -14,4 +25,5 @@ export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptio
     source: string;
 }>;
 export declare function scanSoftSkills(agentId: string, opts?: SkillIndexOptions): SoftSkillEntry[];
+export declare function collectAgentSkillSnapshot(agentId: string, opts?: SkillIndexOptions): AgentSkillSnapshot;
 export declare function buildSoftSkillIndexPrompt(agentId: string, opts?: SkillIndexOptions): string | null;

package/dist/skill-index.js

@@ -34,7 +34,7 @@ export function scanSoftSkills(agentId, opts = {}) {
             continue;
         let children;
         try {
-            children = readdirSync(root.dir);
+            children = readdirSync(root.dir).sort((a, b) => a.localeCompare(b));
         }
         catch {
             continue;
@@ -69,11 +69,22 @@ export function scanSoftSkills(agentId, opts = {}) {
         }
     }
     return Array.from(byName.values())
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .slice(0, MAX_SKILLS);
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function collectAgentSkillSnapshot(agentId, opts = {}) {
+    return {
+        agentId,
+        skills: scanSoftSkills(agentId, opts).map((skill) => ({
+            name: skill.name,
+            source: skill.source.startsWith("agent-") ? "workspace" : "runtime-global",
+            ...(skill.description ? { description: skill.description } : {}),
+            mtimeMs: skill.mtimeMs,
+        })),
+        probedAt: Date.now(),
+    };
 }
 export function buildSoftSkillIndexPrompt(agentId, opts = {}) {
-    const skills = scanSoftSkills(agentId, opts);
+    const skills = scanSoftSkills(agentId, opts).slice(0, MAX_SKILLS);
     if (skills.length === 0)
         return null;
     const lines = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.84",
+  "version": "0.2.86",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -8,12 +8,6 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "tsc -p tsconfig.build.json",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "files": [
     "dist/",
     "src/",
@@ -27,10 +21,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@botcord/cli": "^0.1.7",
-    "@botcord/protocol-core": "^0.2.12",
     "@larksuiteoapi/node-sdk": "^1.63.1",
-    "ws": "^8.20.1"
+    "ws": "^8.20.1",
+    "@botcord/cli": "^0.1.18",
+    "@botcord/protocol-core": "^0.2.13"
   },
   "overrides": {
     "axios": "^1.15.2"
@@ -40,5 +34,10 @@
     "@types/ws": "^8.5.0",
     "typescript": "^5.4.0",
     "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/src/__tests__/cloud-daemon.test.ts

@@ -20,6 +20,7 @@ import type { CloudModeConfig } from "../cloud-mode.js";
 import { ControlChannel } from "../control-channel.js";
 import type { DaemonConfig } from "../config.js";
 import type { Gateway, GatewayChannelConfig } from "../gateway/index.js";
+import type { OnAgentInstalledHook } from "../provision.js";
 
 class FakeWebSocket extends EventEmitter {
   public readyState = 0;
@@ -75,6 +76,10 @@ function makeDaemonCfg(): DaemonConfig {
   };
 }
 
+function sentFrames(ws: FakeWebSocket): Array<{ type?: string; params?: any }> {
+  return ws.sent.map((raw) => JSON.parse(raw));
+}
+
 describe("startCloudDaemon", () => {
   let tmpDir: string;
 
@@ -173,6 +178,80 @@ describe("startCloudDaemon", () => {
     }
   });
 
+  it("pushes skill snapshots for agents installed before control-channel startup completes", async () => {
+    const ctor = makeFakeCtor();
+    class TestControlChannel extends ControlChannel {
+      constructor(opts: ConstructorParameters<typeof ControlChannel>[0]) {
+        super({ ...opts, webSocketCtor: ctor, hubPublicKey: null });
+      }
+    }
+    const handle = await startCloudDaemon({
+      cloudConfig: makeCfg(),
+      config: makeDaemonCfg(),
+      configPath: "(cloud-mode)",
+      controlChannelFactory: TestControlChannel as unknown as typeof ControlChannel,
+      provisionerFactory: ((args: { onAgentInstalled: OnAgentInstalledHook }) => {
+        args.onAgentInstalled({
+          agentId: "ag_preinstalled",
+          credentialsFile: path.join(tmpDir, "ag_preinstalled.json"),
+          hubUrl: "http://localhost:9000",
+        });
+        return vi.fn();
+      }) as unknown as typeof import("../provision.js").createProvisioner,
+      sessionStorePath: path.join(tmpDir, "sessions.json"),
+      snapshotPath: path.join(tmpDir, "snapshot.json"),
+      snapshotIntervalMs: 60_000,
+    });
+    try {
+      await new Promise((r) => setImmediate(r));
+      const ws = FakeWebSocket.instances[0]!;
+      const skillFrames = sentFrames(ws).filter((frame) => frame.type === "agent_skill_snapshot");
+      expect(skillFrames).toHaveLength(1);
+      expect(skillFrames[0]!.params.agentId).toBe("ag_preinstalled");
+      expect(Array.isArray(skillFrames[0]!.params.skills)).toBe(true);
+    } finally {
+      await handle.stop("test");
+    }
+  });
+
+  it("pushes a skill snapshot when a cloud agent is installed after startup", async () => {
+    let onAgentInstalled: OnAgentInstalledHook | undefined;
+    const ctor = makeFakeCtor();
+    class TestControlChannel extends ControlChannel {
+      constructor(opts: ConstructorParameters<typeof ControlChannel>[0]) {
+        super({ ...opts, webSocketCtor: ctor, hubPublicKey: null });
+      }
+    }
+    const handle = await startCloudDaemon({
+      cloudConfig: makeCfg(),
+      config: makeDaemonCfg(),
+      configPath: "(cloud-mode)",
+      controlChannelFactory: TestControlChannel as unknown as typeof ControlChannel,
+      provisionerFactory: ((args: { onAgentInstalled: OnAgentInstalledHook }) => {
+        onAgentInstalled = args.onAgentInstalled;
+        return vi.fn();
+      }) as unknown as typeof import("../provision.js").createProvisioner,
+      sessionStorePath: path.join(tmpDir, "sessions.json"),
+      snapshotPath: path.join(tmpDir, "snapshot.json"),
+      snapshotIntervalMs: 60_000,
+    });
+    try {
+      await new Promise((r) => setImmediate(r));
+      onAgentInstalled!({
+        agentId: "ag_hot_installed",
+        credentialsFile: path.join(tmpDir, "ag_hot_installed.json"),
+        hubUrl: "http://localhost:9000",
+      });
+      const ws = FakeWebSocket.instances[0]!;
+      const skillFrames = sentFrames(ws).filter((frame) => frame.type === "agent_skill_snapshot");
+      expect(skillFrames).toHaveLength(1);
+      expect(skillFrames[0]!.params.agentId).toBe("ag_hot_installed");
+      expect(Array.isArray(skillFrames[0]!.params.skills)).toBe(true);
+    } finally {
+      await handle.stop("test");
+    }
+  });
+
   it.each(["telegram", "wechat", "feishu"] as const)(
     "allows %s gateway channels to be hot-plugged in cloud mode",
     async (type) => {

package/src/__tests__/daemon-singleton.test.ts

@@ -1,9 +1,10 @@
 import { spawn, type ChildProcess } from "node:child_process";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
+  acquireDaemonSingletonLock,
   ensureNoOtherDaemonFromPidFile,
   isBotCordDaemonStartCommand,
   parseDaemonProcesses,
@@ -79,6 +80,63 @@ describe("daemon singleton pid helpers", () => {
     expect(child.exitCode === null && child.signalCode === null).toBe(false);
   });
 
+  it("holds an atomic singleton lock until release", async () => {
+    const pidPath = path.join(tmpDir, "daemon.pid");
+    const lockPath = `${pidPath}.lock`;
+
+    const lock = await acquireDaemonSingletonLock({
+      pidPath,
+      lockPath,
+      currentPid: process.pid,
+    });
+
+    expect(existsSync(lockPath)).toBe(true);
+    expect(readPid(path.join(lockPath, "owner.pid"))).toBe(process.pid);
+
+    lock.release();
+
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  it("removes stale singleton locks", async () => {
+    const pidPath = path.join(tmpDir, "daemon.pid");
+    const lockPath = `${pidPath}.lock`;
+    mkdirSync(lockPath, { recursive: true });
+    writeCurrentPid({ pidPath: path.join(lockPath, "owner.pid"), currentPid: 99999999 });
+
+    const lock = await acquireDaemonSingletonLock({
+      pidPath,
+      lockPath,
+      currentPid: process.pid,
+    });
+
+    expect(readPid(path.join(lockPath, "owner.pid"))).toBe(process.pid);
+    lock.release();
+  });
+
+  it("terminates a live singleton lock owner before acquiring", async () => {
+    const pidPath = path.join(tmpDir, "daemon.pid");
+    const lockPath = `${pidPath}.lock`;
+    const child = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {
+      stdio: "ignore",
+    });
+    children.push(child);
+    await waitForPid(child);
+    mkdirSync(lockPath, { recursive: true });
+    writeCurrentPid({ pidPath: path.join(lockPath, "owner.pid"), currentPid: child.pid! });
+
+    const lock = await acquireDaemonSingletonLock({
+      pidPath,
+      lockPath,
+      currentPid: process.pid,
+    });
+
+    await waitForExit(child);
+    expect(child.exitCode === null && child.signalCode === null).toBe(false);
+    expect(readPid(path.join(lockPath, "owner.pid"))).toBe(process.pid);
+    lock.release();
+  });
+
   it("removes stale pid files", () => {
     const pidPath = path.join(tmpDir, "daemon.pid");
     writeCurrentPid({ pidPath, currentPid: 99999999 });

package/src/__tests__/provision.test.ts

@@ -719,6 +719,48 @@ describe("provision_agent handler writes runtime + cwd", () => {
     }
   });
 
+  it("normalizes Hub-supplied millisecond tokenExpiresAt before writing credentials", async () => {
+    const os = await import("node:os");
+    const fs = await import("node:fs");
+    const nodePath = await import("node:path");
+
+    const tmp = fs.mkdtempSync(nodePath.join(os.tmpdir(), "daemon-provision-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = tmp;
+    try {
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+      const privateKey = Buffer.alloc(32, 9).toString("base64");
+
+      const ack = await provisioner({
+        id: "req_token_expiry",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "codex",
+          credentials: {
+            agentId: "ag_token_expiry",
+            keyId: "k_token_expiry",
+            privateKey,
+            hubUrl: "https://hub.example",
+            token: "agent-token",
+            tokenExpiresAt: 1_779_856_985_546,
+          },
+        },
+      });
+
+      expect(ack.ok).toBe(true);
+      const credFile = nodePath.join(tmp, ".botcord", "credentials", "ag_token_expiry.json");
+      const saved = JSON.parse(fs.readFileSync(credFile, "utf8")) as Record<string, unknown>;
+      expect(saved.tokenExpiresAt).toBe(1_779_856_985);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
   it("rejects unknown runtime ids before touching disk", async () => {
     const gw = makeFakeGateway();
     const provisioner = createProvisioner({

package/src/__tests__/runtime-discovery.test.ts

@@ -40,7 +40,7 @@ beforeEach(() => {
   // mocked runtime list between cases, so reset before each.
   clearRuntimeProbeCache();
 });
-const { pushRuntimeSnapshot } = await import("../daemon.js");
+const { pushAgentSkillSnapshot, pushRuntimeSnapshot } = await import("../daemon.js");
 const { CONTROL_FRAME_TYPES } = await import("@botcord/protocol-core");
 import type { GatewayChannelConfig, GatewayRuntimeSnapshot } from "../gateway/index.js";
 
@@ -474,6 +474,22 @@ describe("pushRuntimeSnapshot (first-connect push)", () => {
   });
 });
 
+describe("pushAgentSkillSnapshot", () => {
+  it("sends an agent_skill_snapshot frame", () => {
+    const frames: any[] = [];
+    const ok = pushAgentSkillSnapshot(
+      { send: (frame) => { frames.push(frame); return true; } },
+      "ag_skills",
+    );
+    expect(ok).toBe(true);
+    expect(frames).toHaveLength(1);
+    expect(frames[0].type).toBe("agent_skill_snapshot");
+    expect(frames[0].params.agentId).toBe("ag_skills");
+    expect(Array.isArray(frames[0].params.skills)).toBe(true);
+    expect(typeof frames[0].params.probedAt).toBe("number");
+  });
+});
+
 describe("attachRuntimeHealth", () => {
   it("groups live circuit breakers onto matching runtime entries", () => {
     const snap = {

package/src/__tests__/runtime-models.test.ts

@@ -199,6 +199,56 @@ describe("runtime model discovery parsers", () => {
     ]);
   });
 
+  it("reads DeepSeek reasoning effort choices from the installed runtime template", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "daemon-deepseek-catalog-"));
+    const prevHome = process.env.HOME;
+    const prevCacheDir = process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+    try {
+      const home = path.join(tmp, "home");
+      mkdirSync(path.join(home, ".deepseek"), { recursive: true });
+      process.env.HOME = home;
+      process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = path.join(tmp, "catalog-cache");
+      writeFileSync(
+        path.join(home, ".deepseek", "config.toml"),
+        'default_text_model = "deepseek-v4-pro"\nreasoning_effort = "turbo"\n',
+      );
+      const fakeDeepseek = path.join(tmp, "deepseek");
+      writeFileSync(
+        fakeDeepseek,
+        [
+          "binary prefix",
+          "# Thinking mode (DeepSeek V4 reasoning effort):",
+          '# "adaptive" | "disabled" | "turbo"',
+          'reasoning_effort = "adaptive"',
+        ].join("\n"),
+      );
+
+      const catalog = discoverRuntimeModelCatalog({
+        id: "deepseek-tui",
+        displayName: "DeepSeek TUI",
+        binary: "deepseek",
+        supportsRun: true,
+        result: { available: true, path: fakeDeepseek },
+      });
+
+      expect(catalog.parameters).toContainEqual({
+        id: "reasoning_effort",
+        displayName: "Reasoning effort",
+        type: "enum",
+        flag: "--reasoning-effort",
+        values: ["adaptive", "disabled", "turbo"],
+        defaultValue: "turbo",
+        source: "config",
+      });
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      if (prevCacheDir === undefined) delete process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+      else process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = prevCacheDir;
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
   it("parses Kimi models from config.toml", () => {
     expect(
       parseKimiConfigModels(

package/src/__tests__/skill-index.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  agentCodexHomeDir,
+  agentWorkspaceDir,
+} from "../agent-workspace.js";
+import {
+  buildSoftSkillIndexPrompt,
+  collectAgentSkillSnapshot,
+  scanSoftSkills,
+} from "../skill-index.js";
+
+let tmpDir = "";
+let prevHome: string | undefined;
+
+function writeSkill(dir: string, name: string, description: string): void {
+  const skillDir = path.join(dir, name);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    path.join(skillDir, "SKILL.md"),
+    `---\nname: ${name}\ndescription: "${description}"\n---\n\n# ${name}\n`,
+  );
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(path.join(tmpdir(), "skill-index-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = tmpDir;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("skill snapshots", () => {
+  it("scans agent workspace/runtime-global skills and maps UI source buckets", () => {
+    const agentId = "ag_skilltest";
+    writeSkill(path.join(agentWorkspaceDir(agentId), ".claude", "skills"), "workspace-skill", "Workspace skill");
+    writeSkill(path.join(agentCodexHomeDir(agentId), "skills"), "codex-skill", "Codex skill");
+    writeSkill(path.join(tmpDir, ".codex", "skills"), "global-skill", "Global skill");
+
+    const scanned = scanSoftSkills(agentId);
+    expect(scanned.map((s) => s.name).sort()).toEqual([
+      "codex-skill",
+      "global-skill",
+      "workspace-skill",
+    ]);
+
+    const snapshot = collectAgentSkillSnapshot(agentId);
+    expect(snapshot.agentId).toBe(agentId);
+    expect(snapshot.skills).toHaveLength(3);
+    expect(snapshot.skills.find((s) => s.name === "workspace-skill")?.source)
+      .toBe("workspace");
+    expect(snapshot.skills.find((s) => s.name === "codex-skill")?.source)
+      .toBe("workspace");
+    expect(snapshot.skills.find((s) => s.name === "global-skill")?.source)
+      .toBe("runtime-global");
+    expect(snapshot.probedAt).toBeGreaterThan(0);
+  });
+
+  it("returns complete snapshots while keeping the prompt soft index capped", () => {
+    const agentId = "ag_manyskills";
+    const workspaceSkills = path.join(agentWorkspaceDir(agentId), ".claude", "skills");
+    for (let i = 0; i < 30; i += 1) {
+      const name = `skill-${String(i).padStart(2, "0")}`;
+      writeSkill(workspaceSkills, name, `Skill ${i}`);
+    }
+
+    const scanned = scanSoftSkills(agentId);
+    expect(scanned).toHaveLength(30);
+    expect(scanned.map((s) => s.name)).toEqual(
+      Array.from({ length: 30 }, (_, i) => `skill-${String(i).padStart(2, "0")}`),
+    );
+
+    const snapshot = collectAgentSkillSnapshot(agentId);
+    expect(snapshot.skills).toHaveLength(30);
+
+    const prompt = buildSoftSkillIndexPrompt(agentId);
+    expect(prompt).not.toBeNull();
+    const skillLines = prompt
+      ?.split("\n")
+      .filter((line) => line.startsWith("- skill-"));
+    expect(skillLines).toHaveLength(24);
+    expect(skillLines?.at(0)).toContain("skill-00");
+    expect(skillLines?.at(-1)).toContain("skill-23");
+  });
+});

package/src/cloud-daemon.ts

@@ -27,7 +27,7 @@ import { ControlChannel } from "./control-channel.js";
 import { toGatewayConfig } from "./daemon-config-map.js";
 import { log as daemonLog } from "./log.js";
 import { createProvisioner } from "./provision.js";
-import { createDaemonChannel, pushRuntimeSnapshot } from "./daemon.js";
+import { createDaemonChannel, pushAgentSkillSnapshot, pushRuntimeSnapshot } from "./daemon.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { readWorkingMemorySnapshot } from "./working-memory.js";
@@ -234,7 +234,20 @@ export async function startCloudDaemon(
     });
   };
 
+  const installedAgentIds = new Set<string>();
+  let controlChannel: ControlChannel | null = null;
+  const pushInstalledAgentSkillSnapshot = (agentId: string, reason: string): void => {
+    if (!controlChannel) return;
+    const pushed = pushAgentSkillSnapshot(controlChannel, agentId);
+    logger.info("cloud control-channel: agent_skill_snapshot pushed", {
+      agentId,
+      reason,
+      ok: pushed,
+    });
+  };
+
   const onAgentInstalled: OnAgentInstalledHook = (info: InstalledAgentInfo) => {
+    installedAgentIds.add(info.agentId);
     credentialPathByAgentId.set(info.agentId, info.credentialsFile);
     if (info.hubUrl) hubUrlByAgentId.set(info.agentId, info.hubUrl);
     if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
@@ -251,6 +264,7 @@ export async function startCloudDaemon(
         }),
       );
     }
+    pushInstalledAgentSkillSnapshot(info.agentId, "agent_installed");
   };
 
   const gateway = new Gateway({
@@ -281,7 +295,6 @@ export async function startCloudDaemon(
   await gateway.start();
   logger.info("cloud daemon gateway started (zero agents at boot)");
 
-  let controlChannel: ControlChannel | null = null;
   if (!opts.disableControlChannel) {
     const auth = asUserAuthManager(new CloudAuthManager(cloudCfg));
     const provisionerFactory = opts.provisionerFactory ?? createProvisioner;
@@ -330,6 +343,9 @@ export async function startCloudDaemon(
       logger.info("cloud control-channel started; runtime_snapshot pushed", {
         ok: pushed,
       });
+      for (const agentId of installedAgentIds) {
+        pushInstalledAgentSkillSnapshot(agentId, "control_channel_started");
+      }
     } catch (err) {
       logger.warn("cloud control-channel start failed; daemon will retry", {
         error: err instanceof Error ? err.message : String(err),