@botcord/daemon 0.2.84 → 0.2.86

package/src/daemon-singleton.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { PID_PATH } from "./config.js";
 
@@ -17,6 +17,18 @@ const noopLogger: SingletonLogger = {
   },
 };
 
+const DEFAULT_LOCK_WAIT_MS = 15_000;
+const DEFAULT_LOCK_RETRY_MS = 50;
+
+export interface DaemonSingletonLock {
+  lockPath: string;
+  release(): void;
+}
+
+export function defaultLockPath(pidPath = PID_PATH): string {
+  return `${pidPath}.lock`;
+}
+
 export function readPid(pidPath = PID_PATH): number | null {
   if (!existsSync(pidPath)) return null;
   const raw = readFileSync(pidPath, "utf8").trim();
@@ -24,6 +36,10 @@ export function readPid(pidPath = PID_PATH): number | null {
   return Number.isFinite(pid) && pid > 0 ? pid : null;
 }
 
+function readLockOwner(lockPath: string): number | null {
+  return readPid(path.join(lockPath, "owner.pid"));
+}
+
 export function pidAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
@@ -127,6 +143,78 @@ export async function stopDaemonFromPidFileForRestart(
   }
 }
 
+export async function acquireDaemonSingletonLock(
+  opts: {
+    lockPath?: string;
+    pidPath?: string;
+    currentPid?: number;
+    logger?: SingletonLogger;
+    timeoutMs?: number;
+  } = {},
+): Promise<DaemonSingletonLock> {
+  const pidPath = opts.pidPath ?? PID_PATH;
+  const lockPath = opts.lockPath ?? defaultLockPath(pidPath);
+  const currentPid = opts.currentPid ?? process.pid;
+  const logger = opts.logger ?? noopLogger;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_LOCK_WAIT_MS;
+  const deadline = Date.now() + timeoutMs;
+
+  ensureParentDir(lockPath);
+  while (true) {
+    try {
+      mkdirSync(lockPath, { mode: 0o700 });
+      writeFileSync(path.join(lockPath, "owner.pid"), String(currentPid), { mode: 0o600 });
+      return {
+        lockPath,
+        release() {
+          const owner = readLockOwner(lockPath);
+          if (owner !== null && owner !== currentPid) return;
+          try {
+            rmSync(lockPath, { recursive: true, force: true });
+          } catch {
+            // ignore
+          }
+        },
+      };
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code !== "EEXIST") throw err;
+    }
+
+    const owner = readLockOwner(lockPath);
+    if (owner === currentPid) {
+      return {
+        lockPath,
+        release() {
+          try {
+            rmSync(lockPath, { recursive: true, force: true });
+          } catch {
+            // ignore
+          }
+        },
+      };
+    }
+    if (owner !== null && pidAlive(owner)) {
+      logger.info("daemon singleton lock owner found; restarting", { pid: owner });
+      await stopExistingDaemonForRestart(owner, { pidPath, currentPid, logger });
+    }
+
+    const refreshedOwner = readLockOwner(lockPath);
+    if (refreshedOwner === null || !pidAlive(refreshedOwner)) {
+      try {
+        rmSync(lockPath, { recursive: true, force: true });
+      } catch {
+        // another starter may have removed/recreated it
+      }
+    }
+
+    if (Date.now() >= deadline) {
+      throw new Error(`timed out acquiring daemon singleton lock at ${lockPath}`);
+    }
+    await delay(DEFAULT_LOCK_RETRY_MS);
+  }
+}
+
 export async function stopOtherDaemonProcessesForRestart(
   opts: {
     currentPid?: number;
@@ -187,11 +275,7 @@ export function writeCurrentPid(
   // Cloud-mode startup writes the PID file before `saveConfig` runs, so
   // the daemon dir may not exist yet. mkdir its parent (0700) so the
   // first write doesn't crash with ENOENT.
-  try {
-    mkdirSync(path.dirname(pidPath), { recursive: true, mode: 0o700 });
-  } catch {
-    // best-effort — writeFileSync below will surface the real error
-  }
+  ensureParentDir(pidPath);
   writeFileSync(pidPath, String(opts.currentPid ?? process.pid), { mode: 0o600 });
 }
 
@@ -231,3 +315,11 @@ export function isBotCordDaemonStartCommand(command: string): boolean {
 function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+function ensureParentDir(filePath: string): void {
+  try {
+    mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  } catch {
+    // best-effort — the next filesystem operation will surface real errors
+  }
+}

package/src/daemon.ts

@@ -52,6 +52,7 @@ import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-res
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 import { createAttentionPolicyFetcher } from "./attention-policy-fetcher.js";
+import { collectAgentSkillSnapshot } from "./skill-index.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -245,6 +246,26 @@ export function pushRuntimeSnapshot(
   return ok;
 }
 
+export function pushAgentSkillSnapshot(
+  sink: RuntimeSnapshotSink,
+  agentId: string,
+): boolean {
+  const snap = collectAgentSkillSnapshot(agentId);
+  const ok = sink.send({
+    id: `skill_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    type: "agent_skill_snapshot",
+    params: snap as unknown as Record<string, unknown>,
+    ts: Date.now(),
+  });
+  if (!ok) {
+    daemonLog.warn("agent-skill-snapshot: control-channel send returned false", {
+      agentId,
+      skills: snap.skills.length,
+    });
+  }
+  return ok;
+}
+
 /** Options accepted by {@link startDaemon} — the P0.5 compatibility shim. */
 export interface DaemonRuntimeOptions {
   config: DaemonConfig;
@@ -648,6 +669,13 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
       logger.info("control-channel: initial runtime_snapshot push", {
         ok: pushed,
       });
+      for (const agentId of agentIds) {
+        const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId);
+        logger.info("control-channel: initial agent_skill_snapshot push", {
+          agentId,
+          ok: skillsPushed,
+        });
+      }
     } catch (err) {
       logger.warn("control-channel failed to start; continuing without it", {
         error: err instanceof Error ? err.message : String(err),

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

@@ -793,6 +793,85 @@ describe("createBotCordChannel — streamBlock()", () => {
     });
   });
 
+  it("normalizes wrapped DeepSeek item.started tool input from the runtime event stream", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_use",
+          seq: 5,
+          raw: {
+            event: "item.started",
+            payload: {
+              seq: 922,
+              thread_id: "thr_test",
+              turn_id: "turn_test",
+              item_id: "item_exec",
+              event: "item.started",
+              payload: {
+                item: {
+                  id: "item_exec",
+                  kind: "tool_call",
+                  status: "in_progress",
+                  summary: "exec_shell started",
+                  detail: "{\"cmd\":\"botcord-daemon status\"}",
+                },
+              },
+            },
+          },
+        },
+        5,
+      ),
+    ).toMatchObject({
+      kind: "tool_call",
+      seq: 5,
+      payload: {
+        id: "item_exec",
+        name: "exec_shell",
+        params: { cmd: "botcord-daemon status" },
+        status: "in_progress",
+      },
+    });
+  });
+
+  it("normalizes wrapped DeepSeek item.completed output without showing the event envelope", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_result",
+          seq: 6,
+          raw: {
+            event: "item.completed",
+            payload: {
+              seq: 955,
+              thread_id: "thr_test",
+              turn_id: "turn_test",
+              item_id: "item_exec",
+              event: "item.completed",
+              payload: {
+                item: {
+                  id: "item_exec",
+                  kind: "command_execution",
+                  status: "completed",
+                  summary: "exec_shell: daemon: pid 49616",
+                  detail: "daemon: pid 49616 (alive)",
+                },
+              },
+            },
+          },
+        },
+        6,
+      ),
+    ).toMatchObject({
+      kind: "tool_result",
+      seq: 6,
+      payload: {
+        name: "exec_shell",
+        result: "daemon: pid 49616 (alive)",
+        tool_use_id: "item_exec",
+      },
+    });
+  });
+
   it("POSTs to /hub/stream-block with the right trace_id + block", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;

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

@@ -353,6 +353,55 @@ describe("DeepseekTuiAdapter", () => {
     }
   });
 
+  it("treats DeepSeek command_execution item.started events as tool blocks", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        {
+          event: "turn.started",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.started" },
+        },
+        {
+          event: "item.started",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.started",
+            payload: {
+              item: {
+                id: "item_exec",
+                kind: "command_execution",
+                status: "in_progress",
+                summary: "exec_shell started",
+                detail: "{\"cmd\":\"date\"}",
+              },
+            },
+          },
+        },
+        {
+          event: "item.delta",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.delta",
+            payload: { kind: "agent_message", delta: "done" },
+          },
+        },
+        {
+          event: "turn.completed",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.completed" },
+        },
+      ],
+    });
+    try {
+      const { result, blocks, status } = runAdapter(server.baseUrl, server.token);
+      await expect(result).resolves.toMatchObject({ text: "done" });
+      expect(blocks).toEqual(expect.arrayContaining(["tool_use", "assistant_text"]));
+      expect(status).toContainEqual({ phase: "updated", label: "exec_shell" });
+    } finally {
+      await server.close();
+    }
+  });
+
   it("emits current DeepSeek agent_reasoning completions as thinking blocks", async () => {
     const server = await startMockDeepseekServer({
       events: [

package/src/gateway/channels/botcord.ts

@@ -1196,27 +1196,46 @@ function extractToolResult(raw: any): { name?: string; result: string; id?: stri
 function extractDeepseekToolCall(raw: any): { name: string; params?: unknown; id?: string; status?: string } | null {
   const payload = raw?.payload;
   if (!payload || typeof payload !== "object") return null;
+  const innerPayload = unwrapDeepseekPayload(raw);
+  const event = stringField(raw, "event") ?? stringField(payload, "event");
 
-  if (raw?.event === "tool.started") {
-    const tool = payload.tool && typeof payload.tool === "object" ? payload.tool : undefined;
+  if (event === "tool.started") {
+    const tool = innerPayload?.tool && typeof innerPayload.tool === "object" ? innerPayload.tool : undefined;
     return {
-      name: stringField(payload, "name") ?? stringField(tool, "name") ?? "tool",
-      params: parseMaybeJson(payload.input ?? payload.arguments ?? payload.params ?? tool?.input ?? tool?.rawInput),
-      id: stringField(payload, "id") ?? stringField(tool, "id"),
-      status: stringField(payload, "status") ?? stringField(tool, "status"),
+      name: stringField(innerPayload, "name") ?? stringField(tool, "name") ?? "tool",
+      params: parseMaybeJson(
+        innerPayload?.input ??
+          innerPayload?.arguments ??
+          innerPayload?.params ??
+          tool?.input ??
+          tool?.rawInput ??
+          tool?.arguments ??
+          tool?.params,
+      ),
+      id: stringField(innerPayload, "id") ?? stringField(tool, "id"),
+      status: stringField(innerPayload, "status") ?? stringField(tool, "status"),
     };
   }
 
-  if (raw?.event === "item.started" || payload.event === "item.started") {
-    const inner =
-      raw?.event === "item.started"
-        ? payload
-        : payload.payload && typeof payload.payload === "object"
-          ? payload.payload
-          : {};
+  if (event === "item.started") {
+    const inner = innerPayload ?? {};
     const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
     const tool = inner.tool && typeof inner.tool === "object" ? inner.tool : item?.tool;
-    const itemParams = parseMaybeJson(item?.input ?? item?.arguments ?? item?.detail);
+    const metadata = item?.metadata && typeof item.metadata === "object" ? item.metadata : undefined;
+    const metadataCommand =
+      metadata && (metadata.command ?? metadata.cmd)
+        ? { [metadata.command ? "command" : "cmd"]: metadata.command ?? metadata.cmd }
+        : undefined;
+    const itemParams = parseMaybeJson(
+      item?.input ??
+        item?.arguments ??
+        item?.params ??
+        metadata?.input ??
+        metadata?.arguments ??
+        metadata?.params ??
+        metadataCommand ??
+        item?.detail,
+    );
     const detailParams =
       itemParams !== undefined
         ? itemParams
@@ -1240,9 +1259,18 @@ function extractDeepseekToolCall(raw: any): { name: string; params?: unknown; id
           inner.arguments ??
           inner.params ??
           item?.input ??
-          item?.arguments,
+          item?.arguments ??
+          item?.params ??
+          metadata?.input ??
+          metadata?.arguments ??
+          metadata?.params ??
+          metadataCommand,
       ) ?? detailParams ?? tool ?? item,
-      id: stringField(tool, "id") ?? stringField(inner, "id") ?? stringField(item, "id"),
+      id:
+        stringField(tool, "id") ??
+        stringField(inner, "id") ??
+        stringField(item, "id") ??
+        stringField(payload, "item_id"),
       status: stringField(tool, "status") ?? stringField(inner, "status") ?? stringField(item, "status"),
     };
   }
@@ -1253,28 +1281,26 @@ function extractDeepseekToolCall(raw: any): { name: string; params?: unknown; id
 function extractDeepseekToolResult(raw: any): { name?: string; result: string; id?: string } | null {
   const payload = raw?.payload;
   if (!payload || typeof payload !== "object") return null;
+  const innerPayload = unwrapDeepseekPayload(raw);
+  const event = stringField(raw, "event") ?? stringField(payload, "event");
 
-  if (raw?.event === "tool.completed") {
-    const result = payload.output ?? payload.result ?? payload.content ?? payload.error ?? payload;
+  if (event === "tool.completed") {
+    const result =
+      innerPayload?.output ??
+      innerPayload?.result ??
+      innerPayload?.content ??
+      innerPayload?.error ??
+      innerPayload ??
+      payload;
     return {
-      name: stringField(payload, "name"),
+      name: stringField(innerPayload, "name"),
       result: stringifyToolResult(result),
-      id: stringField(payload, "id"),
+      id: stringField(innerPayload, "id"),
     };
   }
 
-  if (
-    raw?.event === "item.completed" ||
-    raw?.event === "item.failed" ||
-    payload.event === "item.completed" ||
-    payload.event === "item.failed"
-  ) {
-    const inner =
-      raw?.event === "item.completed" || raw?.event === "item.failed"
-        ? payload
-        : payload.payload && typeof payload.payload === "object"
-          ? payload.payload
-          : {};
+  if (event === "item.completed" || event === "item.failed") {
+    const inner = innerPayload ?? {};
     const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
     const result =
       item?.output ??
@@ -1295,13 +1321,35 @@ function extractDeepseekToolResult(raw: any): { name?: string; result: string; i
         stringField(inner, "name") ??
         stringField(item, "type"),
       result: stringifyToolResult(result),
-      id: stringField(item, "id") ?? stringField(inner, "id"),
+      id: stringField(item, "id") ?? stringField(inner, "id") ?? stringField(payload, "item_id"),
     };
   }
 
   return null;
 }
 
+function unwrapDeepseekPayload(raw: any): any {
+  const payload = raw?.payload;
+  if (!payload || typeof payload !== "object") return undefined;
+  const nested = payload.payload;
+  if (nested && typeof nested === "object") {
+    const outerEvent = stringField(payload, "event");
+    if (
+      outerEvent ||
+      nested.item ||
+      nested.tool ||
+      nested.turn ||
+      nested.kind ||
+      nested.output ||
+      nested.result ||
+      nested.error
+    ) {
+      return nested;
+    }
+  }
+  return payload;
+}
+
 function formatBlockDetails(raw: unknown): string {
   if (!raw || typeof raw !== "object") return "";
   const r = raw as any;

package/src/gateway/runtimes/deepseek-tui.ts

@@ -497,9 +497,15 @@ function isDeepseekTerminalEvent(eventName: string, payload: any): boolean {
 }
 
 function isToolStarted(eventName: string, payload: any): boolean {
+  const itemKind = payload?.payload?.item?.kind ?? payload?.item?.kind;
   return (
     (eventName === "item.started" &&
-      (!!payload?.tool || payload?.item?.kind === "tool_call" || payload?.payload?.item?.kind === "tool_call")) ||
+      (
+        !!payload?.tool ||
+        itemKind === "tool_call" ||
+        itemKind === "command_execution" ||
+        itemKind === "file_change"
+      )) ||
     (payload?.event === "item.started" && !!payload?.payload?.tool)
   );
 }

package/src/index.ts

@@ -17,6 +17,7 @@ import {
   type RouteRuleMatch,
 } from "./config.js";
 import {
+  acquireDaemonSingletonLock,
   ensureNoOtherDaemonFromPidFile,
   findOtherDaemonProcesses,
   pidAlive,
@@ -625,13 +626,22 @@ async function cmdStart(args: ParsedArgs): Promise<void> {
   }
 
   // Foreground: we ARE the daemon.
+  const singletonLock = await acquireDaemonSingletonLock({ logger: log });
   writeCurrentPid();
-  const handle = await startDaemon({ config: cfg, configPath: CONFIG_FILE_PATH });
+  let handle: Awaited<ReturnType<typeof startDaemon>>;
+  try {
+    handle = await startDaemon({ config: cfg, configPath: CONFIG_FILE_PATH });
+  } catch (err) {
+    removePidFile();
+    singletonLock.release();
+    throw err;
+  }
 
   const shutdown = async (sig: string) => {
     log.info("signal received", { sig });
     await handle.stop(sig);
     removePidFile();
+    singletonLock.release();
     process.exit(0);
   };
   process.on("SIGTERM", () => shutdown("SIGTERM"));
@@ -661,6 +671,7 @@ async function cmdStartCloud(_args: ParsedArgs): Promise<void> {
     daemonInstanceId: cloudConfig.daemonInstanceId,
     hubUrl: cloudConfig.hubUrl,
   });
+  const singletonLock = await acquireDaemonSingletonLock({ logger: log });
   await stopDaemonFromPidFileForRestart({ logger: log });
   await stopOtherDaemonProcessesForRestart({ logger: log });
   writeCurrentPid();
@@ -676,16 +687,24 @@ async function cmdStartCloud(_args: ParsedArgs): Promise<void> {
   saveConfig(cfg);
   log.info("cloud mode config initialized", { configPath: CONFIG_FILE_PATH });
 
-  const handle = await startCloudDaemon({
-    cloudConfig,
-    config: cfg,
-    configPath: CONFIG_FILE_PATH,
-  });
+  let handle: Awaited<ReturnType<typeof startCloudDaemon>>;
+  try {
+    handle = await startCloudDaemon({
+      cloudConfig,
+      config: cfg,
+      configPath: CONFIG_FILE_PATH,
+    });
+  } catch (err) {
+    removePidFile();
+    singletonLock.release();
+    throw err;
+  }
 
   const shutdown = async (sig: string): Promise<void> => {
     log.info("signal received", { sig });
     await handle.stop(sig);
     removePidFile();
+    singletonLock.release();
     process.exit(0);
   };
   process.on("SIGTERM", () => void shutdown("SIGTERM"));

package/src/provision.ts

@@ -13,6 +13,7 @@ import {
   defaultCredentialsFile,
   derivePublicKey,
   loadStoredCredentials,
+  normalizeTokenExpiresAt,
   writeCredentialsFile,
   type AgentIdentitySnapshot,
   type ControlAck,
@@ -74,6 +75,7 @@ import { log as daemonLog } from "./log.js";
 import { discoverAgentCredentials } from "./agent-discovery.js";
 import { resolveMemoryDir } from "./working-memory.js";
 import { discoverRuntimeModelCatalog } from "./runtime-models.js";
+import { collectAgentSkillSnapshot } from "./skill-index.js";
 import {
   buildRuntimeSelectionExtraArgs,
   mergeRuntimeExtraArgs,
@@ -83,6 +85,10 @@ import {
   type CloudGatewayTypingEmitter,
 } from "./cloud-gateway-runtime.js";
 
+interface ListAgentSkillsParams {
+  agentId: string;
+}
+
 /**
  * Information passed to {@link OnAgentInstalledHook} after a successful
  * provision. Mirrors the credential fields the daemon's per-agent caches
@@ -486,6 +492,32 @@ export function createProvisioner(opts: ProvisionerOptions): (
         return { ok: true, result };
       }
 
+      case "list_agent_skills": {
+        const params = (frame.params ?? {}) as unknown as ListAgentSkillsParams;
+        if (!params.agentId) {
+          return {
+            ok: false,
+            error: { code: "bad_params", message: "list_agent_skills requires params.agentId" },
+          };
+        }
+        const channels = gateway.snapshot().channels;
+        if (!channels[params.agentId]) {
+          return {
+            ok: false,
+            error: {
+              code: "agent_not_loaded",
+              message: `agent ${params.agentId} is not loaded in daemon gateway`,
+            },
+          };
+        }
+        const result = collectAgentSkillSnapshot(params.agentId);
+        daemonLog.debug("list_agent_skills", {
+          agentId: params.agentId,
+          count: result.skills.length,
+        });
+        return { ok: true, result };
+      }
+
       case "wake_agent": {
         return handleWakeAgent(gateway, frame.params);
       }
@@ -1227,7 +1259,8 @@ async function materializeCredentials(
     };
     if (c.displayName) record.displayName = c.displayName;
     if (c.token) record.token = c.token;
-    if (typeof c.tokenExpiresAt === "number") record.tokenExpiresAt = c.tokenExpiresAt;
+    const tokenExpiresAt = normalizeTokenExpiresAt(c.tokenExpiresAt);
+    if (tokenExpiresAt !== undefined) record.tokenExpiresAt = tokenExpiresAt;
     if (runtime) record.runtime = runtime;
     const runtimeSelection = pickRuntimeSelection(params);
     if (runtimeSelection.runtimeModel) record.runtimeModel = runtimeSelection.runtimeModel;