@botcord/daemon 0.2.90 → 0.2.92

package/dist/gateway/channels/botcord.js

@@ -187,6 +187,35 @@ function normalizeInboxBatch(msgs, options) {
         raw: { ...latest, batch: msgs },
     };
 }
+/**
+ * Fire-and-forget authenticated POST for presence/streaming control requests
+ * (`/hub/typing`, `/hub/stream-block`). Mirrors `BotCordClient.hubFetch`'s 401
+ * handling: a stale-but-unexpired token (e.g. after a Hub JWT secret rotation,
+ * which `ensureToken()` won't refresh because it only refreshes near expiry) is
+ * refreshed once and the request retried. Without this, typing/stream-block
+ * silently 401 in a loop until the next actual message send happens to refresh
+ * the token — leaving the conversation with no typing indicator or live stream.
+ */
+async function postControlWithRefresh(client, hubUrl, path, body) {
+    let token = await client.ensureToken();
+    for (let attempt = 0; attempt <= 1; attempt++) {
+        const resp = await fetch(`${hubUrl}${path}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (resp.status === 401 && attempt === 0) {
+            token = await client.refreshToken();
+            continue;
+        }
+        return resp;
+    }
+    throw new Error("postControlWithRefresh: exhausted retries");
+}
 /**
  * Construct a BotCord channel adapter.
  *
@@ -758,21 +787,12 @@ export function createBotCordChannel(options) {
             const client = ensureClient();
             const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
             try {
-                const token = await client.ensureToken();
                 const block = ctx.block;
                 const seq = typeof block?.seq === "number" ? block.seq : 0;
-                const resp = await fetch(`${hubUrl}/hub/stream-block`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${token}`,
-                    },
-                    body: JSON.stringify({
-                        trace_id: ctx.traceId,
-                        seq,
-                        block: normalizeBlockForHub(block, seq),
-                    }),
-                    signal: AbortSignal.timeout(10_000),
+                const resp = await postControlWithRefresh(client, hubUrl, "/hub/stream-block", {
+                    trace_id: ctx.traceId,
+                    seq,
+                    block: normalizeBlockForHub(block, seq),
                 });
                 if (!resp.ok && resp.status !== 204) {
                     const body = await resp.text().catch(() => "");
@@ -790,15 +810,8 @@ export function createBotCordChannel(options) {
             const client = ensureClient();
             const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
             try {
-                const token = await client.ensureToken();
-                const resp = await fetch(`${hubUrl}/hub/typing`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${token}`,
-                    },
-                    body: JSON.stringify({ room_id: ctx.conversationId }),
-                    signal: AbortSignal.timeout(10_000),
+                const resp = await postControlWithRefresh(client, hubUrl, "/hub/typing", {
+                    room_id: ctx.conversationId,
                 });
                 if (!resp.ok && resp.status !== 204) {
                     const body = await resp.text().catch(() => "");

package/dist/gateway-control.js

@@ -66,6 +66,9 @@ export function createGatewayControl(ctx) {
             throw urlErr;
         }
         const cfg = cfgIO.load();
+        const existingProfiles = cfg.thirdPartyGateways ?? [];
+        const prevProfile = existingProfiles.find((g) => g.id === params.id);
+        const hadExistingProfile = prevProfile !== undefined;
         // accountId must belong to a daemon-bound agent. An empty agent set
         // (no agents provisioned yet) is itself a hard reject — otherwise we
         // would silently accept upserts against a daemon that has nowhere to
@@ -144,42 +147,62 @@ export function createGatewayControl(ctx) {
         else if (params.type === "feishu") {
             const loginId = params.loginId;
             if (!loginId) {
-                return badParams("upsert_gateway: feishu requires loginId");
-            }
-            const resolved = sessions.resolve(loginId);
-            if (resolved.state !== "live") {
-                return {
-                    ok: false,
-                    error: resolved.state === "missing"
-                        ? { code: "login_missing", message: `feishu login session "${loginId}" not found` }
-                        : { code: "login_expired", message: `feishu login session "${loginId}" expired` },
-                };
-            }
-            const session = resolved.session;
-            if (session.provider !== "feishu") {
-                return badParams(`upsert_gateway: login session provider "${session.provider}" != "feishu"`);
-            }
-            if (session.accountId !== params.accountId) {
-                return {
-                    ok: false,
-                    error: {
-                        code: "login_account_mismatch",
-                        message: "feishu login session accountId does not match upsert request",
-                    },
-                };
+                if (!prevProfile ||
+                    prevProfile.type !== "feishu" ||
+                    prevProfile.accountId !== params.accountId ||
+                    !prevProfile.appId) {
+                    return badParams("upsert_gateway: feishu requires loginId");
+                }
+                const existing = loadGatewaySecret(params.id);
+                if (!existing?.appSecret) {
+                    return badParams("upsert_gateway: feishu requires loginId");
+                }
+                if (params.settings?.domain !== undefined &&
+                    params.settings.domain !== (prevProfile.domain ?? "feishu")) {
+                    return badParams("upsert_gateway: feishu domain change requires a fresh loginId");
+                }
+                secretPayload = { appSecret: existing.appSecret };
+                tokenPreviewSource = existing.appSecret;
+                feishuAppId = prevProfile.appId;
+                feishuDomain = params.settings?.domain ?? prevProfile.domain ?? "feishu";
+                feishuUserOpenId = prevProfile.userOpenId;
             }
-            if (!session.appId || !session.appSecret) {
-                return {
-                    ok: false,
-                    error: { code: "login_unconfirmed", message: "feishu login session has no app credentials yet" },
-                };
+            else {
+                const resolved = sessions.resolve(loginId);
+                if (resolved.state !== "live") {
+                    return {
+                        ok: false,
+                        error: resolved.state === "missing"
+                            ? { code: "login_missing", message: `feishu login session "${loginId}" not found` }
+                            : { code: "login_expired", message: `feishu login session "${loginId}" expired` },
+                    };
+                }
+                const session = resolved.session;
+                if (session.provider !== "feishu") {
+                    return badParams(`upsert_gateway: login session provider "${session.provider}" != "feishu"`);
+                }
+                if (session.accountId !== params.accountId) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "login_account_mismatch",
+                            message: "feishu login session accountId does not match upsert request",
+                        },
+                    };
+                }
+                if (!session.appId || !session.appSecret) {
+                    return {
+                        ok: false,
+                        error: { code: "login_unconfirmed", message: "feishu login session has no app credentials yet" },
+                    };
+                }
+                secretPayload = { appSecret: session.appSecret };
+                tokenPreviewSource = session.appSecret;
+                feishuAppId = session.appId;
+                feishuDomain = session.domain ?? params.settings?.domain ?? "feishu";
+                feishuUserOpenId = session.userOpenId;
+                sessions.update(loginId, { gatewayId: params.id });
             }
-            secretPayload = { appSecret: session.appSecret };
-            tokenPreviewSource = session.appSecret;
-            feishuAppId = session.appId;
-            feishuDomain = session.domain ?? params.settings?.domain ?? "feishu";
-            feishuUserOpenId = session.userOpenId;
-            sessions.update(loginId, { gatewayId: params.id });
         }
         else {
             return badParams(`upsert_gateway: unknown provider "${params.type}"`);
@@ -187,9 +210,6 @@ export function createGatewayControl(ctx) {
         // W3/W6: remember whether a profile already exists for this id BEFORE we
         // write the secret/config. For UPDATE path, capture previous profile +
         // previous secret so addChannel failure can restore prior state.
-        const existingProfiles = cfg.thirdPartyGateways ?? [];
-        const hadExistingProfile = existingProfiles.some((g) => g.id === params.id);
-        const prevProfile = existingProfiles.find((g) => g.id === params.id);
         // W6: load the previous secret for UPDATE rollback BEFORE overwriting.
         const prevSecret = hadExistingProfile
             ? loadGatewaySecret(params.id)
@@ -253,19 +273,24 @@ export function createGatewayControl(ctx) {
                     }
                     try {
                         if (prevProfile) {
-                            cfgIO.save(upsertProfileInConfig(cfgIO.load(), prevProfile));
+                            cfgIO.save(replaceProfileInConfig(cfgIO.load(), prevProfile));
                         }
                     }
                     catch {
                         // best-effort
                     }
                     try {
-                        if (prevProfile && prevSecret?.botToken) {
+                        if (prevProfile &&
+                            ((prevProfile.type === "telegram" && prevSecret?.botToken) ||
+                                (prevProfile.type === "feishu" && prevSecret?.appSecret))) {
                             await ctx.gateway.addChannel(buildChannelConfig({
                                 ...params,
                                 type: prevProfile.type,
+                                accountId: prevProfile.accountId,
                                 enabled: prevProfile.enabled !== false,
-                                secret: { botToken: prevSecret.botToken },
+                                ...(prevProfile.type === "telegram"
+                                    ? { secret: { botToken: prevSecret.botToken } }
+                                    : {}),
                                 settings: {
                                     baseUrl: prevProfile.baseUrl,
                                     allowedSenderIds: prevProfile.allowedSenderIds,
@@ -854,6 +879,9 @@ function validateOutboundConversation(profile, conversationId) {
             },
         };
     }
+    if (profile.type === "feishu" && (profile.allowedChatIds ?? []).length === 0) {
+        return null;
+    }
     const allowed = new Set((profile.allowedChatIds ?? []).map(String));
     if (!allowed.has(chatId)) {
         return {
@@ -929,6 +957,18 @@ function upsertProfileInConfig(cfg, patch) {
     }
     return { ...cfg, thirdPartyGateways: list };
 }
+function replaceProfileInConfig(cfg, profile) {
+    const list = (cfg.thirdPartyGateways ?? []).slice();
+    const idx = list.findIndex((g) => g.id === profile.id);
+    const compact = compactProfile(profile);
+    if (idx >= 0) {
+        list[idx] = compact;
+    }
+    else {
+        list.push(compact);
+    }
+    return { ...cfg, thirdPartyGateways: list };
+}
 function compactProfile(p) {
     const out = {
         id: p.id,

package/dist/provision.js

@@ -23,6 +23,7 @@ import { collectAgentSkillSnapshot } from "./skill-index.js";
 import { installAgentSkillManifest, installBotLearnArchiveManifest, installVercelSkillsForAgent, } from "./skill-installer.js";
 import { buildRuntimeSelectionExtraArgs, mergeRuntimeExtraArgs, } from "./runtime-route-options.js";
 import { handleCloudGatewayRuntimeInbound, } from "./cloud-gateway-runtime.js";
+import { scheduleDaemonSelfRestart } from "./self-restart.js";
 function skillIndexOptionsForLoadedAgent(gateway, agentId) {
     const route = gateway.listManagedRoutes()
         .find((entry) => entry.match?.accountId === agentId);
@@ -240,6 +241,16 @@ export function createProvisioner(opts) {
                 daemonLog.debug("list_runtimes", { count: snapshot.runtimes.length });
                 return { ok: true, result: snapshot };
             }
+            case CONTROL_FRAME_TYPES.RESTART_DAEMON: {
+                const plan = scheduleDaemonSelfRestart({ update: true });
+                daemonLog.warn("restart_daemon: scheduled self restart", {
+                    updateRequested: plan.updateRequested,
+                    updateSupported: plan.updateSupported,
+                    installPrefix: plan.installPrefix,
+                    packageSpec: plan.packageSpec,
+                });
+                return { ok: true, result: plan };
+            }
             case "list_gateways":
                 return gatewayControl.handleList();
             case "upsert_gateway": {
@@ -530,8 +541,15 @@ async function handleWakeAgent(gateway, raw) {
             streamable: false,
         },
     };
-    await gateway.injectInbound(msg);
-    return { ok: true, result: { agent_id: agentId } };
+    void gateway.injectInbound(msg).catch((err) => {
+        daemonLog.error("wake_agent: async inject failed", {
+            agentId,
+            scheduleId: scheduleId ?? null,
+            runId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    return { ok: true, result: { agent_id: agentId, queued: true } };
 }
 function validateGatewayParams(raw, spec) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {

package/dist/self-restart.d.ts

@@ -0,0 +1,29 @@
+import { spawn } from "node:child_process";
+export interface DaemonRestartPlan {
+    scheduled: boolean;
+    updateRequested: boolean;
+    updateSupported: boolean;
+    installPrefix: string | null;
+    packageSpec: string;
+}
+export interface ScheduleDaemonSelfRestartOptions {
+    update?: boolean;
+    packageSpec?: string;
+    delayMs?: number;
+    forceExitAfterMs?: number;
+    entrypoint?: string;
+    restartArgs?: string[];
+}
+export interface ScheduleDaemonSelfRestartDeps {
+    spawn?: typeof spawn;
+    setTimeout?: typeof setTimeout;
+    kill?: (pid: number, signal: NodeJS.Signals) => void;
+    exit?: (code?: number) => never;
+    pid?: number;
+    execPath?: string;
+    argv?: string[];
+    env?: NodeJS.ProcessEnv;
+}
+export declare function findDaemonInstallPrefix(entrypoint?: string): string | null;
+export declare function resolveNpmBin(nodePath?: string): string;
+export declare function scheduleDaemonSelfRestart(opts?: ScheduleDaemonSelfRestartOptions, deps?: ScheduleDaemonSelfRestartDeps): DaemonRestartPlan;

package/dist/self-restart.js

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+const DEFAULT_DAEMON_PACKAGE = "@botcord/daemon@latest";
+const DEFAULT_SHUTDOWN_DELAY_MS = 750;
+const DEFAULT_FORCE_EXIT_MS = 10_000;
+const DEFAULT_PARENT_EXIT_WAIT_MS = 30_000;
+const DEFAULT_INSTALL_TIMEOUT_MS = 120_000;
+export function findDaemonInstallPrefix(entrypoint) {
+    if (!entrypoint)
+        return null;
+    const candidates = [entrypoint, safeRealpath(entrypoint)];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const prefix = installPrefixFromPath(candidate);
+        if (prefix)
+            return prefix;
+    }
+    return null;
+}
+export function resolveNpmBin(nodePath = process.execPath) {
+    const name = process.platform === "win32" ? "npm.cmd" : "npm";
+    const sibling = path.join(path.dirname(nodePath), name);
+    return existsSync(sibling) ? sibling : name;
+}
+export function scheduleDaemonSelfRestart(opts = {}, deps = {}) {
+    const env = deps.env ?? process.env;
+    const argv = deps.argv ?? process.argv;
+    const entrypoint = opts.entrypoint ?? argv[1];
+    if (!entrypoint) {
+        throw new Error("cannot restart daemon: process entrypoint is unknown");
+    }
+    const updateRequested = opts.update !== false;
+    const installPrefix = updateRequested ? findDaemonInstallPrefix(entrypoint) : null;
+    const packageSpec = opts.packageSpec ?? env.BOTCORD_DAEMON_PACKAGE ?? DEFAULT_DAEMON_PACKAGE;
+    const execPath = deps.execPath ?? process.execPath;
+    const pid = deps.pid ?? process.pid;
+    const restartArgs = opts.restartArgs ?? ["start", "--foreground"];
+    const supervisorEnv = {
+        ...env,
+        BOTCORD_DAEMON_CHILD: "1",
+        BOTCORD_RESTART_PARENT_PID: String(pid),
+        BOTCORD_RESTART_ENTRYPOINT: entrypoint,
+        BOTCORD_RESTART_ARGS_JSON: JSON.stringify(restartArgs),
+        BOTCORD_RESTART_NODE: execPath,
+        BOTCORD_RESTART_NPM_BIN: resolveNpmBin(execPath),
+        BOTCORD_RESTART_UPDATE: updateRequested && installPrefix ? "1" : "0",
+        BOTCORD_RESTART_INSTALL_PREFIX: installPrefix ?? "",
+        BOTCORD_RESTART_PACKAGE: packageSpec,
+        BOTCORD_RESTART_PARENT_EXIT_WAIT_MS: String(DEFAULT_PARENT_EXIT_WAIT_MS),
+        BOTCORD_RESTART_INSTALL_TIMEOUT_MS: String(DEFAULT_INSTALL_TIMEOUT_MS),
+    };
+    const spawnImpl = deps.spawn ?? spawn;
+    const child = spawnImpl(execPath, ["-e", RESTART_SUPERVISOR_SCRIPT], {
+        detached: true,
+        stdio: "ignore",
+        env: supervisorEnv,
+    });
+    child.unref();
+    const setTimer = deps.setTimeout ?? setTimeout;
+    const kill = deps.kill ?? process.kill.bind(process);
+    const exit = deps.exit ?? process.exit.bind(process);
+    const delayMs = opts.delayMs ?? DEFAULT_SHUTDOWN_DELAY_MS;
+    const forceExitAfterMs = opts.forceExitAfterMs ?? DEFAULT_FORCE_EXIT_MS;
+    const shutdownTimer = setTimer(() => {
+        try {
+            kill(pid, "SIGTERM");
+        }
+        catch {
+            exit(0);
+            return;
+        }
+        const exitTimer = setTimer(() => exit(0), forceExitAfterMs);
+        unrefTimer(exitTimer);
+    }, delayMs);
+    unrefTimer(shutdownTimer);
+    return {
+        scheduled: true,
+        updateRequested,
+        updateSupported: installPrefix !== null,
+        installPrefix,
+        packageSpec,
+    };
+}
+function safeRealpath(input) {
+    try {
+        return realpathSync(input);
+    }
+    catch {
+        return null;
+    }
+}
+function installPrefixFromPath(input) {
+    const parts = path.resolve(input).split(path.sep);
+    for (let i = parts.length - 3; i >= 0; i--) {
+        if (parts[i] !== "node_modules" ||
+            parts[i + 1] !== "@botcord" ||
+            parts[i + 2] !== "daemon") {
+            continue;
+        }
+        const prefix = parts.slice(0, i).join(path.sep) || path.sep;
+        const packageJson = path.join(prefix, "node_modules", "@botcord", "daemon", "package.json");
+        return existsSync(packageJson) ? prefix : null;
+    }
+    return null;
+}
+function unrefTimer(timer) {
+    const maybe = timer;
+    if (typeof maybe.unref === "function") {
+        maybe.unref();
+    }
+}
+const RESTART_SUPERVISOR_SCRIPT = `
+const cp = require("node:child_process");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const parentPid = Number(process.env.BOTCORD_RESTART_PARENT_PID || "0");
+  const waitMs = Number(process.env.BOTCORD_RESTART_PARENT_EXIT_WAIT_MS || "30000");
+  const deadline = Date.now() + waitMs;
+  while (parentPid > 0 && alive(parentPid) && Date.now() < deadline) {
+    await sleep(250);
+  }
+
+  const update = process.env.BOTCORD_RESTART_UPDATE === "1";
+  const installPrefix = process.env.BOTCORD_RESTART_INSTALL_PREFIX || "";
+  if (update && installPrefix) {
+    const npmBin = process.env.BOTCORD_RESTART_NPM_BIN || "npm";
+    const packageSpec = process.env.BOTCORD_RESTART_PACKAGE || "${DEFAULT_DAEMON_PACKAGE}";
+    const timeout = Number(process.env.BOTCORD_RESTART_INSTALL_TIMEOUT_MS || "120000");
+    cp.spawnSync(npmBin, ["install", "--prefix", installPrefix, packageSpec], {
+      stdio: "ignore",
+      env: process.env,
+      timeout,
+    });
+  }
+
+  const node = process.env.BOTCORD_RESTART_NODE || process.execPath;
+  const entrypoint = process.env.BOTCORD_RESTART_ENTRYPOINT;
+  if (!entrypoint) process.exit(1);
+  let args = ["start", "--foreground"];
+  try {
+    const parsed = JSON.parse(process.env.BOTCORD_RESTART_ARGS_JSON || "[]");
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+      args = parsed;
+    }
+  } catch {
+    // keep default args
+  }
+  const child = cp.spawn(node, [entrypoint, ...args], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, BOTCORD_DAEMON_CHILD: "1" },
+  });
+  child.unref();
+}
+
+main().catch(() => process.exit(1));
+`;

package/dist/skill-index.js

@@ -18,6 +18,18 @@ export function defaultSkillDirs(agentId, opts = {}) {
         source: "agent-codex",
         runtime: "codex",
     };
+    const agentGemini = [
+        {
+            dir: path.join(agentWorkspaceDir(agentId), ".gemini", "skills"),
+            source: "agent-gemini",
+            runtime: "gemini",
+        },
+        {
+            dir: path.join(agentWorkspaceDir(agentId), ".agents", "skills"),
+            source: "agent-agents",
+            runtime: "gemini",
+        },
+    ];
     const agentHermes = hermesSkillRoot(agentId, opts.hermesProfile);
     const dirs = [];
     switch (runtimeFamily(opts.runtime)) {
@@ -34,6 +46,20 @@ export function defaultSkillDirs(agentId, opts = {}) {
         case "hermes":
             dirs.push(agentHermes);
             break;
+        case "gemini":
+            dirs.push(...agentGemini);
+            if (includeGlobal) {
+                dirs.push({
+                    dir: path.join(homedir(), ".gemini", "skills"),
+                    source: "global-gemini",
+                    runtime: "gemini",
+                }, {
+                    dir: path.join(homedir(), ".agents", "skills"),
+                    source: "global-agents",
+                    runtime: "gemini",
+                });
+            }
+            break;
         case "claude":
             dirs.push(agentClaude);
             if (includeGlobal) {
@@ -228,6 +254,8 @@ function hermesSkillRoot(agentId, profile) {
 function runtimeFamily(runtime) {
     if (runtime === "codex")
         return "codex";
+    if (runtime === "gemini")
+        return "gemini";
     if (runtime === "hermes-agent")
         return "hermes";
     if (!runtime)
@@ -237,18 +265,11 @@ function runtimeFamily(runtime) {
     return "other";
 }
 function priority(source, _runtime) {
-    switch (source) {
-        case "agent-claude":
-        case "agent-codex":
-        case "agent-hermes":
-        case "agent-hermes-profile":
-            return 0;
-        case "global-claude":
-        case "global-codex":
-            return 1;
-        default:
-            return 2;
-    }
+    if (source.startsWith("agent-"))
+        return 0;
+    if (source.startsWith("global-"))
+        return 1;
+    return 2;
 }
 function snapshotSource(source) {
     return source.startsWith("agent-") ? "workspace" : "runtime-global";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.90",
+  "version": "0.2.92",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -23,8 +23,8 @@
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.63.1",
     "ws": "^8.20.1",
-    "@botcord/protocol-core": "^0.2.13",
-    "@botcord/cli": "^0.1.18"
+    "@botcord/cli": "^0.1.19",
+    "@botcord/protocol-core": "^0.2.13"
   },
   "overrides": {
     "axios": "^1.15.2"