@botcord/daemon 0.2.90 → 0.2.92

package/src/gateway-control.ts

@@ -271,6 +271,9 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     }
 
     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
@@ -349,43 +352,66 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     } 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 (!session.appId || !session.appSecret) {
-        return {
-          ok: false,
-          error: { code: "login_unconfirmed", message: "feishu login session has no app credentials yet" },
-        };
+        if (
+          !prevProfile ||
+          prevProfile.type !== "feishu" ||
+          prevProfile.accountId !== params.accountId ||
+          !prevProfile.appId
+        ) {
+          return badParams("upsert_gateway: feishu requires loginId");
+        }
+        const existing = loadGatewaySecret<{ appSecret?: string }>(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;
+      } 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 as { type: string }).type}"`);
     }
@@ -393,12 +419,9 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     // 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<{ botToken?: string }>(params.id)
+      ? loadGatewaySecret<{ botToken?: string; appSecret?: string }>(params.id)
       : null;
 
     // Persist secret first (so a config write that succeeds is never
@@ -458,20 +481,27 @@ export function createGatewayControl(ctx: GatewayControlContext) {
           }
           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 as typeof params.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,
@@ -1074,6 +1104,9 @@ function validateOutboundConversation(
       },
     };
   }
+  if (profile.type === "feishu" && (profile.allowedChatIds ?? []).length === 0) {
+    return null;
+  }
   const allowed = new Set((profile.allowedChatIds ?? []).map(String));
   if (!allowed.has(chatId)) {
     return {
@@ -1161,6 +1194,21 @@ function upsertProfileInConfig(
   return { ...cfg, thirdPartyGateways: list };
 }
 
+function replaceProfileInConfig(
+  cfg: DaemonConfig,
+  profile: ThirdPartyGatewayProfile,
+): DaemonConfig {
+  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: ThirdPartyGatewayProfile): ThirdPartyGatewayProfile {
   const out: ThirdPartyGatewayProfile = {
     id: p.id,

package/src/provision.ts

@@ -91,6 +91,7 @@ import {
   handleCloudGatewayRuntimeInbound,
   type CloudGatewayTypingEmitter,
 } from "./cloud-gateway-runtime.js";
+import { scheduleDaemonSelfRestart } from "./self-restart.js";
 
 function skillIndexOptionsForLoadedAgent(gateway: Gateway, agentId: string): SkillIndexOptions {
   const route = gateway.listManagedRoutes()
@@ -397,6 +398,17 @@ export function createProvisioner(opts: ProvisionerOptions): (
         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();
 
@@ -729,8 +741,15 @@ async function handleWakeAgent(gateway: Gateway, raw: unknown): Promise<AckBody>
     },
   };
 
-  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 } };
 }
 
 // W8: hand-written runtime validator for the third-party gateway frame

package/src/self-restart.ts

@@ -0,0 +1,218 @@
+import { spawn, type ChildProcess } 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 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 function findDaemonInstallPrefix(entrypoint?: string): string | null {
+  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): string {
+  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: ScheduleDaemonSelfRestartOptions = {},
+  deps: ScheduleDaemonSelfRestartDeps = {},
+): DaemonRestartPlan {
+  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: NodeJS.ProcessEnv = {
+    ...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,
+  }) as ChildProcess;
+  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: string): string | null {
+  try {
+    return realpathSync(input);
+  } catch {
+    return null;
+  }
+}
+
+function installPrefixFromPath(input: string): string | null {
+  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: ReturnType<typeof setTimeout>): void {
+  const maybe = timer as { unref?: () => void };
+  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/src/skill-index.ts

@@ -74,6 +74,18 @@ export function defaultSkillDirs(
     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: SkillRoot[] = [];
@@ -91,6 +103,23 @@ export function defaultSkillDirs(
     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) {
@@ -308,8 +337,9 @@ function hermesSkillRoot(agentId: string, profile: string | undefined): SkillRoo
   };
 }
 
-function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "hermes" | "other" {
+function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "gemini" | "hermes" | "other" {
   if (runtime === "codex") return "codex";
+  if (runtime === "gemini") return "gemini";
   if (runtime === "hermes-agent") return "hermes";
   if (!runtime) return "claude";
   if (runtime === "claude-code") return "claude";
@@ -317,18 +347,9 @@ function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "herme
 }
 
 function priority(source: string, _runtime: string | undefined): number {
-  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: string): "workspace" | "runtime-global" {