@botcord/daemon 0.2.75 → 0.2.76

package/dist/daemon-singleton.d.ts

@@ -0,0 +1,26 @@
+export interface SingletonLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+}
+export declare function readPid(pidPath?: string): number | null;
+export declare function pidAlive(pid: number): boolean;
+export declare function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean>;
+export declare function stopExistingDaemonForRestart(pid: number, opts?: {
+    pidPath?: string;
+    currentPid?: number;
+    logger?: SingletonLogger;
+}): Promise<void>;
+export declare function stopDaemonFromPidFileForRestart(opts?: {
+    pidPath?: string;
+    currentPid?: number;
+    logger?: SingletonLogger;
+}): Promise<void>;
+export declare function ensureNoOtherDaemonFromPidFile(opts?: {
+    pidPath?: string;
+    currentPid?: number;
+}): number | null;
+export declare function writeCurrentPid(opts?: {
+    pidPath?: string;
+    currentPid?: number;
+}): void;
+export declare function removePidFile(pidPath?: string): void;

package/dist/daemon-singleton.js

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { PID_PATH } from "./config.js";
+const noopLogger = {
+    info() {
+        // noop
+    },
+    warn() {
+        // noop
+    },
+};
+export function readPid(pidPath = PID_PATH) {
+    if (!existsSync(pidPath))
+        return null;
+    const raw = readFileSync(pidPath, "utf8").trim();
+    const pid = Number(raw);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+export function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function waitForPidExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!pidAlive(pid))
+            return true;
+        await delay(100);
+    }
+    return !pidAlive(pid);
+}
+export async function stopExistingDaemonForRestart(pid, opts = {}) {
+    const pidPath = opts.pidPath ?? PID_PATH;
+    const currentPid = opts.currentPid ?? process.pid;
+    const logger = opts.logger ?? noopLogger;
+    if (pid === currentPid)
+        return;
+    logger.info("existing daemon found; restarting", { pid });
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        removePidFile(pidPath);
+        return;
+    }
+    if (!(await waitForPidExit(pid, 5_000))) {
+        logger.warn("existing daemon did not stop after SIGTERM; sending SIGKILL", { pid });
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // ignore
+        }
+        await waitForPidExit(pid, 2_000);
+    }
+    removePidFile(pidPath);
+}
+export async function stopDaemonFromPidFileForRestart(opts = {}) {
+    const pidPath = opts.pidPath ?? PID_PATH;
+    const existing = readPid(pidPath);
+    if (existing && pidAlive(existing)) {
+        await stopExistingDaemonForRestart(existing, opts);
+    }
+}
+export function ensureNoOtherDaemonFromPidFile(opts = {}) {
+    const pidPath = opts.pidPath ?? PID_PATH;
+    const currentPid = opts.currentPid ?? process.pid;
+    const existing = readPid(pidPath);
+    if (existing && existing !== currentPid && pidAlive(existing)) {
+        return existing;
+    }
+    return null;
+}
+export function writeCurrentPid(opts = {}) {
+    writeFileSync(opts.pidPath ?? PID_PATH, String(opts.currentPid ?? process.pid), { mode: 0o600 });
+}
+export function removePidFile(pidPath = PID_PATH) {
+    try {
+        unlinkSync(pidPath);
+    }
+    catch {
+        // ignore
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/daemon.d.ts

@@ -64,7 +64,7 @@ export interface RuntimeSnapshotSink {
  * failure is non-fatal (the Hub will re-query via `list_runtimes` on demand
  * or wait for the next daemon restart). Exported for unit tests.
  */
-export declare function pushRuntimeSnapshot(sink: RuntimeSnapshotSink): boolean;
+export declare function pushRuntimeSnapshot(sink: RuntimeSnapshotSink, liveSnapshot?: GatewayRuntimeSnapshot): boolean;
 /** Options accepted by {@link startDaemon} — the P0.5 compatibility shim. */
 export interface DaemonRuntimeOptions {
     config: DaemonConfig;

package/dist/daemon.js

@@ -7,7 +7,7 @@ import { ensureAgentWorkspace } from "./agent-workspace.js";
 import { ControlChannel } from "./control-channel.js";
 import { toGatewayConfig } from "./daemon-config-map.js";
 import { log as daemonLog } from "./log.js";
-import { adoptDiscoveredOpenclawAgents, collectRuntimeSnapshot, createProvisioner, } from "./provision.js";
+import { adoptDiscoveredOpenclawAgents, attachRuntimeHealth, collectRuntimeSnapshot, createProvisioner, } from "./provision.js";
 import { openclawAutoProvisionEnabled } from "./openclaw-discovery.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
@@ -146,8 +146,9 @@ export function createDaemonChannel(chCfg, deps) {
  * failure is non-fatal (the Hub will re-query via `list_runtimes` on demand
  * or wait for the next daemon restart). Exported for unit tests.
  */
-export function pushRuntimeSnapshot(sink) {
-    const snap = collectRuntimeSnapshot();
+export function pushRuntimeSnapshot(sink, liveSnapshot) {
+    const base = collectRuntimeSnapshot();
+    const snap = liveSnapshot ? attachRuntimeHealth(base, liveSnapshot) : base;
     const ok = sink.send({
         id: `rt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
         type: CONTROL_FRAME_TYPES.RUNTIME_SNAPSHOT,
@@ -353,7 +354,15 @@ export async function startDaemon(opts) {
             }));
         }
     };
-    const gateway = new Gateway({
+    let controlChannel = null;
+    let gateway;
+    const pushLiveRuntimeSnapshot = () => {
+        if (!controlChannel)
+            return;
+        const pushed = pushRuntimeSnapshot(controlChannel, gateway.snapshot());
+        logger.info("control-channel: live runtime_snapshot push", { ok: pushed });
+    };
+    gateway = new Gateway({
         config: gwConfig,
         sessionStorePath: opts.sessionStorePath ?? SESSIONS_PATH,
         createChannel: (chCfg) => createDaemonChannel(chCfg, {
@@ -367,6 +376,7 @@ export async function startDaemon(opts) {
         buildMemoryContext,
         onInbound,
         onOutbound,
+        onRuntimeCircuitBreakerChange: pushLiveRuntimeSnapshot,
         composeUserTurn: composeBotCordUserTurn,
         attentionGate,
         resolveHubUrl,
@@ -416,7 +426,6 @@ export async function startDaemon(opts) {
     // Control channel is optional — daemon still runs (data-plane only)
     // when user-auth hasn't been set up yet. Operators can `login` later
     // without restarting, but for P0 we require a restart to pick it up.
-    let controlChannel = null;
     if (userAuth?.current && !opts.disableControlChannel) {
         logger.info("control-channel: enabling", {
             userId: userAuth.current.userId,
@@ -455,7 +464,7 @@ export async function startDaemon(opts) {
             // Plan §8.5 P0 — push one runtime snapshot immediately after connect
             // so Hub's `daemon_instances.runtimes_json` is populated for the
             // dashboard even before any user action. No periodic refresh in P0.
-            const pushed = pushRuntimeSnapshot(controlChannel);
+            const pushed = pushRuntimeSnapshot(controlChannel, gateway.snapshot());
             logger.info("control-channel: initial runtime_snapshot push", {
                 ok: pushed,
             });

package/dist/doctor.d.ts

@@ -1,5 +1,6 @@
 import type { RuntimeProbeEntry } from "./adapters/runtimes.js";
 import type { DaemonConfig } from "./config.js";
+import { type ClaudeAuthProbeResult } from "./gateway/runtimes/claude-code.js";
 /** Summary of a single channel's readiness, printable by the doctor command. */
 export interface ChannelProbeResult {
     id: string;
@@ -50,6 +51,7 @@ export interface DoctorRuntimeEndpoint {
 /** Augmented runtime entry that may carry endpoint probe results. */
 export interface DoctorRuntimeEntry extends RuntimeProbeEntry {
     endpoints?: DoctorRuntimeEndpoint[];
+    auth?: ClaudeAuthProbeResult;
 }
 /** Input for the rendered doctor output. */
 export interface DoctorInput {
@@ -107,9 +109,10 @@ export declare function renderDoctor(input: DoctorInput): string;
  * Thin orchestrator: runs runtime + channel probes and returns the rendered
  * text. Keeps `index.ts` free of probe wiring.
  */
-export declare function runDoctor(runtimes: RuntimeProbeEntry[], channels: ChannelProbeConfig[], opts: {
+export declare function runDoctor(runtimes: DoctorRuntimeEntry[], channels: ChannelProbeConfig[], opts: {
     credentialsPath: (accountId: string) => string;
     fileReader: DoctorFileReader;
     fetcher: DoctorHttpFetcher;
     timeoutMs?: number;
+    authCheck?: boolean;
 }): Promise<DoctorInput>;

package/dist/doctor.js

@@ -1,4 +1,5 @@
 import { resolveBootAgents } from "./agent-discovery.js";
+import { probeClaudeAuth } from "./gateway/runtimes/claude-code.js";
 /**
  * Build the implicit channel list for a daemon config. One channel per
  * configured or discovered agent, keyed by agentId (matches
@@ -74,12 +75,11 @@ export async function probeChannel(ch, opts) {
         result.hubMessage = "skipped (no hub URL)";
         return result;
     }
-    // Probe `/` — the hub is ASGI and responds 2xx/3xx/404 which is fine for
-    // "reachable". We treat any response as reachable; network errors fall
-    // through to hubOk=false.
+    // Probe `/` — the hub is ASGI and may answer 404 when the host is still
+    // reachable. Network errors fall through to hubOk=false.
     const probeUrl = `${result.hubUrl.replace(/\/+$/, "")}/`;
     const http = await opts.fetcher(probeUrl, opts.timeoutMs);
-    if (http.ok) {
+    if (http.ok || http.status === 404) {
         result.hubOk = true;
         result.hubMessage = `reachable (HTTP ${http.status})`;
     }
@@ -159,6 +159,10 @@ export function renderDoctor(input) {
         if (!e.result.available && e.installHint) {
             lines.push(`    → ${e.installHint}`);
         }
+        if (e.auth) {
+            const authStatus = e.auth.checked ? (e.auth.ok ? "ok" : "failed") : "skipped";
+            lines.push(`    auth ${authStatus}: ${e.auth.message}`);
+        }
         if (e.endpoints && e.endpoints.length > 0) {
             for (const ep of e.endpoints) {
                 const mark = ep.reachable ? "✓" : "✗";
@@ -204,6 +208,13 @@ export function renderDoctor(input) {
  * text. Keeps `index.ts` free of probe wiring.
  */
 export async function runDoctor(runtimes, channels, opts) {
+    if (opts.authCheck) {
+        for (const runtime of runtimes) {
+            if (runtime.id === "claude-code" && runtime.result.available) {
+                runtime.auth = probeClaudeAuth();
+            }
+        }
+    }
     const channelResults = await probeChannels({
         channels,
         credentialsPath: opts.credentialsPath,

package/dist/gateway/channels/botcord.d.ts

@@ -51,7 +51,7 @@ export interface BotCordChannelOptions {
     credentialsPath?: string;
     /** Override the Hub base URL. Defaults to the `hubUrl` stored in credentials. */
     hubBaseUrl?: string;
-    /** Not used by the WS-only loop today; kept for future polling fallback. */
+    /** Periodic inbox polling fallback. Set to 0 to disable. Defaults to 30s. */
     pollIntervalMs?: number;
     /** Test hook: supply a pre-built client instead of loading credentials from disk. */
     client?: BotCordChannelClient;

package/dist/gateway/channels/botcord.js

@@ -59,6 +59,10 @@ function isOwnerTrust(msg) {
         return true;
     if (msg.source_type === "dashboard_user_chat")
         return true;
+    // Cloud Agent run tasks are Hub-issued on the user's behalf, same
+    // trust posture as owner chat.
+    if (msg.source_type === "cloud_agent_run")
+        return true;
     return false;
 }
 /**
@@ -89,11 +93,16 @@ function normalizeInbox(msg, options) {
         return null;
     // `message` is the normal conversational envelope; `contact_request` is
     // a lightweight inbound asking the agent to notify its owner (the
-    // composer appends the notify-owner hint). All other envelope types
-    // (notification, system, contact_added/removed, …) are still filtered
-    // out here — they belong in a separate push-notification path that
-    // daemon does not yet implement.
-    if (env.type !== "message" && env.type !== "contact_request")
+    // composer appends the notify-owner hint); `cloud_run` carries a
+    // Cloud Agent run task with embedded run_id + budget (the cloud
+    // daemon's runtime adapter reads them from `raw.envelope.payload.cloud_run`
+    // and reports usage back via /internal/cloud-agents/.../settle when the
+    // run completes). All other envelope types (notification, system,
+    // contact_added/removed, …) are still filtered out — they belong in
+    // a separate push-notification path that daemon does not yet implement.
+    if (env.type !== "message" &&
+        env.type !== "contact_request" &&
+        env.type !== "cloud_run")
         return null;
     if (!msg.room_id)
         return null;
@@ -348,6 +357,7 @@ export function createBotCordChannel(options) {
         let ws = null;
         let reconnectTimer = null;
         let keepaliveTimer = null;
+        let pollTimer = null;
         let reconnectAttempt = 0;
         let connectionSeq = 0;
         let consecutiveAuthFailures = 0;
@@ -371,6 +381,10 @@ export function createBotCordChannel(options) {
                 clearInterval(keepaliveTimer);
                 keepaliveTimer = null;
             }
+            if (pollTimer) {
+                clearInterval(pollTimer);
+                pollTimer = null;
+            }
         }
         function markStatus(patch) {
             statusSnapshot = { ...statusSnapshot, ...patch };
@@ -574,6 +588,17 @@ export function createBotCordChannel(options) {
                     });
                     log.info("botcord ws authenticated", { agentId: msg.agent_id });
                     void fireInbox("ws_auth_ok");
+                    const pollIntervalMs = options.pollIntervalMs ?? 30_000;
+                    if (pollTimer)
+                        clearInterval(pollTimer);
+                    if (pollIntervalMs > 0) {
+                        pollTimer = setInterval(() => {
+                            if (ws === socket && socket.readyState === WebSocket.OPEN) {
+                                void fireInbox("poll_interval");
+                            }
+                        }, pollIntervalMs);
+                        pollTimer.unref?.();
+                    }
                     if (keepaliveTimer)
                         clearInterval(keepaliveTimer);
                     keepaliveTimer = setInterval(() => {
@@ -912,6 +937,15 @@ function normalizeBlockForHub(block, seq) {
         return { kind: "thinking", seq, payload };
     }
     // "other" — e.g. Claude Code `type:"result"` end-of-turn summary.
+    if (isTerminalRuntimeBlock(raw)) {
+        payload.terminal = true;
+        payload.details = formatBlockDetails(raw);
+        const event = typeof raw?.event === "string" ? raw.event : undefined;
+        const embedded = typeof raw?.payload?.event === "string" ? raw.payload.event : undefined;
+        if (event || embedded)
+            payload.event = event ?? embedded;
+        return { kind: "other", seq, payload };
+    }
     if (raw?.type === "result") {
         if (typeof raw.result === "string")
             payload.text = raw.result;
@@ -922,6 +956,15 @@ function normalizeBlockForHub(block, seq) {
     }
     return { kind: "other", seq, payload };
 }
+function isTerminalRuntimeBlock(raw) {
+    const event = typeof raw?.event === "string" ? raw.event : undefined;
+    const embedded = typeof raw?.payload?.event === "string" ? raw.payload.event : undefined;
+    const terminal = event ?? embedded;
+    return (terminal === "turn.completed" ||
+        terminal === "turn.finished" ||
+        terminal === "turn.done" ||
+        terminal === "done");
+}
 function formatBlockDetails(raw) {
     if (!raw || typeof raw !== "object")
         return "";

package/dist/gateway/dispatcher.d.ts

@@ -1,7 +1,7 @@
 import type { GatewayLogger } from "./log.js";
 import { type SessionStore } from "./session-store.js";
 import { type TranscriptWriter } from "./transcript.js";
-import type { ChannelAdapter, GatewayConfig, GatewayInboundEnvelope, GatewayInboundMessage, GatewayRoute, InboundObserver, MemoryContextBuilder, OutboundObserver, RuntimeAdapter, SystemContextBuilder, TurnStatusSnapshot, UserTurnBuilder } from "./types.js";
+import type { ChannelAdapter, GatewayConfig, GatewayInboundEnvelope, GatewayInboundMessage, GatewayRoute, InboundObserver, MemoryContextBuilder, OutboundObserver, RuntimeAdapter, RuntimeRunResult, RuntimeCircuitBreakerSnapshot, SystemContextBuilder, TurnStatusSnapshot, UserTurnBuilder } from "./types.js";
 /** Factory signature for building a runtime adapter at turn dispatch time. */
 export type RuntimeFactory = (runtimeId: string, extraArgs?: string[]) => RuntimeAdapter;
 /** Constructor options for `Dispatcher`. */
@@ -12,6 +12,8 @@ export interface DispatcherOptions {
     sessionStore: SessionStore;
     log: GatewayLogger;
     turnTimeoutMs?: number;
+    runtimeAuthFailureThreshold?: number;
+    runtimeAuthFailureCooldownMs?: number;
     /**
      * Live reference to the Gateway's managed-route map. Dispatcher reads
      * `values()` on every `resolveRoute` call so hot-add/remove take effect
@@ -50,6 +52,24 @@ export interface DispatcherOptions {
      * and suppressed so observer failures never break the turn.
      */
     onOutbound?: OutboundObserver;
+    onRuntimeCircuitBreakerChange?: () => void;
+    /**
+     * Optional observer fired exactly once per turn after ``runtime.run``
+     * resolves (or throws / times out). Receives the inbound message, the
+     * raw runtime result (may be undefined on throw), the elapsed wall
+     * time in milliseconds, and any thrown error. The cloud daemon hooks
+     * this to settle ``cloud_run`` envelopes against the Hub's usage
+     * ledger; local daemons leave it unset.
+     *
+     * Errors thrown by the observer are logged and swallowed — settle
+     * failures must never break the agent reply path.
+     */
+    onTurnComplete?: (event: {
+        message: GatewayInboundMessage;
+        result?: RuntimeRunResult;
+        wallTimeMs: number;
+        error?: unknown;
+    }) => Promise<void> | void;
     /**
      * Optional attention gate (PR3, design §4.2). Resolved AFTER `onInbound`
      * runs and BEFORE the runtime turn enqueues, so working memory / activity
@@ -92,10 +112,14 @@ export declare class Dispatcher {
     private readonly sessionStore;
     private readonly log;
     private readonly turnTimeoutMs;
+    private readonly runtimeAuthFailureThreshold;
+    private readonly runtimeAuthFailureCooldownMs;
     private readonly buildSystemContext?;
     private readonly buildMemoryContext?;
     private readonly onInbound?;
     private readonly onOutbound?;
+    private readonly onTurnComplete?;
+    private readonly onRuntimeCircuitBreakerChange?;
     private readonly composeUserTurn?;
     private readonly managedRoutes?;
     private readonly attentionGate?;
@@ -103,6 +127,7 @@ export declare class Dispatcher {
     private readonly transcript;
     private readonly queues;
     private readonly deferredMultimodal;
+    private readonly runtimeAuthFailures;
     /**
      * Last `/hub/typing` ping timestamp per (accountId, conversationId).
      * Used to debounce cancel-previous bursts so we don't trip Hub's 20/min
@@ -114,10 +139,18 @@ export declare class Dispatcher {
     handle(envelope: GatewayInboundEnvelope): Promise<void>;
     /** Snapshot of currently running turns keyed by queue key. */
     turns(): Record<string, TurnStatusSnapshot>;
+    runtimeCircuitBreakers(): Record<string, RuntimeCircuitBreakerSnapshot>;
     private safeAck;
     private getQueue;
     private deferMultimodal;
     private takeDeferredMultimodal;
+    private runtimeAuthBreakerKey;
+    private openRuntimeAuthBreaker;
+    private pruneExpiredRuntimeAuthBreakers;
+    private recordRuntimeAuthFailure;
+    private clearRuntimeAuthFailures;
+    private notifyRuntimeCircuitBreakerChange;
+    private skipRuntimeForAuthBreaker;
     private runCancelPrevious;
     /**
      * Serial mode with coalesce-on-drain semantics: