@botcord/daemon 0.2.75 → 0.2.77

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;