@botcord/daemon 0.2.85 → 0.2.87

package/dist/skill-index.d.ts

@@ -5,13 +5,26 @@ 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;
+    runtime?: string;
 }
 export declare function defaultSkillDirs(agentId: string, opts?: SkillIndexOptions): Array<{
     dir: string;
     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

@@ -7,24 +7,29 @@ const MAX_DESCRIPTION_CHARS = 260;
 const MAX_SKILL_MD_READ_CHARS = 8192;
 export function defaultSkillDirs(agentId, opts = {}) {
     const includeGlobal = opts.includeGlobal !== false;
-    const dirs = [
-        {
-            dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
-            source: "agent-claude",
-        },
-        {
-            dir: path.join(agentCodexHomeDir(agentId), "skills"),
-            source: "agent-codex",
-        },
-    ];
+    const agentClaude = {
+        dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
+        source: "agent-claude",
+    };
+    const agentCodex = {
+        dir: path.join(agentCodexHomeDir(agentId), "skills"),
+        source: "agent-codex",
+    };
+    const dirs = runtimeFamily(opts.runtime) === "codex"
+        ? [agentCodex, agentClaude]
+        : [agentClaude, agentCodex];
     if (includeGlobal) {
-        dirs.push({ dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" }, { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" });
+        const globalClaude = { dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" };
+        const globalCodex = { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" };
+        dirs.push(...(runtimeFamily(opts.runtime) === "codex"
+            ? [globalCodex, globalClaude]
+            : [globalClaude, globalCodex]));
     }
     const envDirs = parseSkillDirsEnv(process.env.BOTCORD_SKILL_DIRS);
     for (const dir of [...envDirs, ...(opts.extraDirs ?? [])]) {
         dirs.push({ dir, source: "external" });
     }
-    return dedupeDirs(dirs);
+    return dedupeDirs(expandSkillRoots(dirs));
 }
 export function scanSoftSkills(agentId, opts = {}) {
     const byName = new Map();
@@ -34,7 +39,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;
@@ -63,17 +68,28 @@ export function scanSoftSkills(agentId, opts = {}) {
                 description: parsed.description,
                 mtimeMs: st.mtimeMs,
             };
-            if (!existing || priority(root.source) < priority(existing.source)) {
+            if (!existing || priority(root.source, opts.runtime) < priority(existing.source, opts.runtime)) {
                 byName.set(entry.name, entry);
             }
         }
     }
     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 = [
@@ -145,7 +161,38 @@ function dedupeDirs(dirs) {
     }
     return out;
 }
-function priority(source) {
+function expandSkillRoots(dirs) {
+    const out = [];
+    for (const entry of dirs) {
+        out.push(entry);
+        if (entry.source.includes("codex")) {
+            out.push({ dir: path.join(entry.dir, ".system"), source: entry.source });
+        }
+    }
+    return out;
+}
+function runtimeFamily(runtime) {
+    if (runtime === "codex")
+        return "codex";
+    if (runtime === "claude-code")
+        return "claude";
+    return "other";
+}
+function priority(source, runtime) {
+    if (runtimeFamily(runtime) === "codex") {
+        switch (source) {
+            case "agent-codex":
+                return 0;
+            case "global-codex":
+                return 1;
+            case "agent-claude":
+                return 2;
+            case "global-claude":
+                return 3;
+            default:
+                return 4;
+        }
+    }
     switch (source) {
         case "agent-claude":
             return 0;

package/dist/turn-text.js

@@ -118,6 +118,39 @@ function entryText(e) {
         return e.envelope.payload.text;
     return "";
 }
+/**
+ * Format the inline quote-reply context line that prefixes a message body
+ * when the inbound envelope replies to another message. Single layer — we
+ * never render a quote-of-a-quote chain. Returns `null` when the source
+ * carries no reply_preview, so the caller can skip emitting an empty line.
+ *
+ * Both sender label and preview body are sanitized; the preview is hard-
+ * capped at 120 chars to mirror the backend truncation.
+ */
+function formatReplyQuoteLine(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const rp = raw.reply_preview;
+    if (!rp || typeof rp !== "object")
+        return null;
+    if (rp.deleted === true) {
+        return "[quoting (deleted message)]";
+    }
+    const senderRaw = typeof rp.sender_display_name === "string" && rp.sender_display_name
+        ? rp.sender_display_name
+        : typeof rp.sender_id === "string" && rp.sender_id
+            ? rp.sender_id
+            : "unknown";
+    const sender = sanitizeSenderName(senderRaw);
+    const previewRaw = typeof rp.text_preview === "string" ? rp.text_preview : "";
+    const previewClean = sanitizeUntrustedContent(previewRaw)
+        .replace(/[\r\n]+/g, " ")
+        .slice(0, 120);
+    if (!previewClean) {
+        return `[quoting ${sender}]`;
+    }
+    return `[quoting ${sender}: "${previewClean}"]`;
+}
 function formatRoomContext(raw, fallback) {
     const r = raw && typeof raw === "object" ? raw : {};
     const roomId = typeof r.room_id === "string" && r.room_id ? r.room_id : fallback.id;
@@ -206,11 +239,13 @@ export function composeBotCordUserTurn(msg) {
             "they can decide whether to accept or reject it. Include the sender's " +
             "agent ID and any message they attached.]"
         : null;
+    const quoteLine = formatReplyQuoteLine(msg.raw);
     const lines = [
         headerFields.join(" | "),
         ...formatScheduleContext(msg.raw),
         ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
         `<${tag} sender="${sanitizedSenderLabel}" sender_kind="${senderKindAttr}">`,
+        ...(quoteLine ? [quoteLine] : []),
         trimmed,
         `</${tag}>`,
         "",
@@ -256,7 +291,9 @@ function composeBatchedTurn(msg, batch) {
         // non-owner. Still sanitize defensively.
         const safeBody = sanitizeUntrustedContent(raw);
         const tag = kind === "human" ? "human-message" : "agent-message";
-        blocks.push(`<${tag} sender="${safeLabel}" sender_kind="${kind}">\n${safeBody}\n</${tag}>`);
+        const quoteLine = formatReplyQuoteLine(entry);
+        const inner = quoteLine ? `${quoteLine}\n${safeBody}` : safeBody;
+        blocks.push(`<${tag} sender="${safeLabel}" sender_kind="${kind}">\n${inner}\n</${tag}>`);
         if (envelopeType === "contact_request") {
             contactRequestSenders.push(safeLabel);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.85",
+  "version": "0.2.87",
   "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__/dispatcher-reply-to.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { pickReplyToTarget } from "../gateway/dispatcher.js";
+import type { GatewayInboundMessage } from "../gateway/index.js";
+
+function makeMsg(partial: Partial<GatewayInboundMessage> = {}): GatewayInboundMessage {
+  return {
+    id: partial.id ?? "h_abc123",
+    channel: partial.channel ?? "botcord",
+    accountId: partial.accountId ?? "ag_me",
+    conversation: partial.conversation ?? { id: "rm_room", kind: "group" },
+    sender: partial.sender ?? { id: "ag_alice", kind: "agent" },
+    text: partial.text ?? "hi",
+    raw: partial.raw ?? null,
+    receivedAt: partial.receivedAt ?? Date.now(),
+    mentioned: partial.mentioned ?? false,
+    replyTo: partial.replyTo ?? null,
+  };
+}
+
+describe("pickReplyToTarget", () => {
+  it("returns msg.replyTo when the inbound was already a reply (chain semantics)", () => {
+    const result = pickReplyToTarget(
+      makeMsg({
+        replyTo: "11111111-2222-3333-4444-555555555555",
+        id: "h_inbound",
+        raw: { envelope: { msg_id: "ignored-because-chain-takes-priority" } },
+      }),
+    );
+    expect(result).toBe("11111111-2222-3333-4444-555555555555");
+  });
+
+  it("returns envelope.msg_id (canonical UUID) when present and not chained", () => {
+    const result = pickReplyToTarget(
+      makeMsg({
+        id: "h_inbound",
+        raw: { envelope: { msg_id: "11111111-2222-3333-4444-555555555555" } },
+      }),
+    );
+    expect(result).toBe("11111111-2222-3333-4444-555555555555");
+    expect(result).not.toMatch(/^h_/);
+  });
+
+  it("falls back to hub_msg_id when envelope.msg_id is missing", () => {
+    const result = pickReplyToTarget(
+      makeMsg({ id: "h_inbound", raw: null }),
+    );
+    // Hub is lenient (accepts h_* via _load_reply_target), so this is still
+    // resolvable on the wire — but the helper should clearly mark the fallback.
+    expect(result).toBe("h_inbound");
+  });
+
+  it("ignores non-string envelope.msg_id and falls back to hub_msg_id", () => {
+    const result = pickReplyToTarget(
+      makeMsg({
+        id: "h_inbound",
+        raw: { envelope: { msg_id: 42 as unknown as string } },
+      }),
+    );
+    expect(result).toBe("h_inbound");
+  });
+});

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 = {