@botcord/daemon 0.2.88 → 0.2.90

package/src/gateway/runtimes/registry.ts

@@ -91,14 +91,16 @@ export const hermesAgentModule: RuntimeModule = {
     'Install: pip install "hermes-agent[acp]"  (or set BOTCORD_HERMES_AGENT_BIN to the absolute path of hermes-acp)',
 };
 
-/** Built-in runtime module entry for Gemini (probe-only stub). */
+/** Built-in runtime module entry for Gemini CLI. */
 export const geminiModule: RuntimeModule = {
   id: "gemini",
   displayName: "Gemini CLI",
   binary: "gemini",
+  envVar: "BOTCORD_GEMINI_BIN",
   probe: () => probeGemini(),
   create: () => new GeminiAdapter(),
-  supportsRun: false,
+  installHint:
+    "Install with `npm install -g @google/gemini-cli` (or `brew install gemini-cli`) and run `gemini` once to complete authentication. Override the binary with BOTCORD_GEMINI_BIN.",
 };
 
 /** Built-in runtime module entry for OpenClaw (ACP). */

package/src/provision.ts

@@ -28,6 +28,8 @@ import {
   type StoredBotCordCredentials,
   type UpdateAgentParams,
   type GatewayInboundFrame,
+  type InstallAgentSkillParams,
+  type ListAgentSkillsParams,
 } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
 import type { GatewayInboundMessage } from "./gateway/index.js";
@@ -75,7 +77,12 @@ 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 { collectAgentSkillSnapshot, type SkillIndexOptions } from "./skill-index.js";
+import {
+  installAgentSkillManifest,
+  installBotLearnArchiveManifest,
+  installVercelSkillsForAgent,
+} from "./skill-installer.js";
 import {
   buildRuntimeSelectionExtraArgs,
   mergeRuntimeExtraArgs,
@@ -85,14 +92,21 @@ import {
   type CloudGatewayTypingEmitter,
 } from "./cloud-gateway-runtime.js";
 
-interface ListAgentSkillsParams {
-  agentId: string;
-}
-
-function runtimeForLoadedAgent(gateway: Gateway, agentId: string): string | undefined {
-  return gateway.listManagedRoutes()
-    .find((route) => route.match?.accountId === agentId)
-    ?.runtime;
+function skillIndexOptionsForLoadedAgent(gateway: Gateway, agentId: string): SkillIndexOptions {
+  const route = gateway.listManagedRoutes()
+    .find((entry) => entry.match?.accountId === agentId);
+  let credentials: StoredBotCordCredentials | null = null;
+  try {
+    credentials = loadStoredCredentials(defaultCredentialsFile(agentId));
+  } catch {
+    credentials = null;
+  }
+  const runtime = route?.runtime ?? credentials?.runtime;
+  const hermesProfile = route?.hermesProfile ?? credentials?.hermesProfile;
+  return {
+    ...(runtime ? { runtime } : {}),
+    ...(hermesProfile ? { hermesProfile } : {}),
+  };
 }
 
 /**
@@ -108,6 +122,7 @@ export interface InstalledAgentInfo {
   hubUrl: string;
   displayName?: string;
   runtime?: string;
+  hermesProfile?: string;
 }
 
 /**
@@ -516,16 +531,77 @@ export function createProvisioner(opts: ProvisionerOptions): (
             },
           };
         }
-        const runtime = runtimeForLoadedAgent(gateway, params.agentId);
-        const result = collectAgentSkillSnapshot(params.agentId, { runtime });
+        const skillIndexOptions = skillIndexOptionsForLoadedAgent(gateway, params.agentId);
+        const result = collectAgentSkillSnapshot(params.agentId, skillIndexOptions);
         daemonLog.debug("list_agent_skills", {
           agentId: params.agentId,
-          runtime,
+          runtime: skillIndexOptions.runtime,
+          hermesProfile: skillIndexOptions.hermesProfile ?? null,
           count: result.skills.length,
         });
         return { ok: true, result };
       }
 
+      case CONTROL_FRAME_TYPES.INSTALL_AGENT_SKILL: {
+        const params = (frame.params ?? {}) as unknown as InstallAgentSkillParams;
+        if (!params.agentId) {
+          return {
+            ok: false,
+            error: { code: "bad_params", message: "install_agent_skill 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 skillIndexOptions = skillIndexOptionsForLoadedAgent(gateway, params.agentId);
+        const runtime = skillIndexOptions.runtime;
+        const modes = [params.manifest, params.archiveManifest, params.vercel].filter(Boolean).length;
+        if (modes !== 1) {
+          return {
+            ok: false,
+            error: {
+              code: "bad_params",
+              message: "install_agent_skill requires exactly one of manifest, archiveManifest, or vercel",
+            },
+          };
+        }
+        let result;
+        try {
+          result = params.vercel
+            ? await installVercelSkillsForAgent({
+              agentId: params.agentId,
+              packageSpec: params.vercel.packageSpec,
+              skills: params.vercel.skills,
+              runtime,
+            })
+            : params.archiveManifest
+              ? installBotLearnArchiveManifest(params.agentId, params.archiveManifest, { runtime })
+              : installAgentSkillManifest(params.agentId, params.manifest!, { runtime });
+        } catch (err) {
+          return {
+            ok: false,
+            error: {
+              code: "skill_install_failed",
+              message: err instanceof Error ? err.message : String(err),
+            },
+          };
+        }
+        daemonLog.debug("install_agent_skill", {
+          agentId: params.agentId,
+          runtime,
+          installed: result.installed.map((s) => s.name),
+          snapshotCount: result.snapshot.skills.length,
+        });
+        return { ok: true, result };
+      }
+
       case "wake_agent": {
         return handleWakeAgent(gateway, frame.params);
       }
@@ -1118,6 +1194,7 @@ async function installLocalAgent(
         hubUrl: credentials.hubUrl,
         ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
         ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
       });
     } catch (err) {
       // Hook misbehavior must not fail the install — the agent is already
@@ -1212,6 +1289,7 @@ async function installExistingOpenclawBinding(
         hubUrl: credentials.hubUrl,
         ...(credentials.displayName ? { displayName: credentials.displayName } : {}),
         ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        ...(credentials.hermesProfile ? { hermesProfile: credentials.hermesProfile } : {}),
       });
     } catch (err) {
       daemonLog.error("provision.onAgentInstalled threw — caches may be stale", {

package/src/runtime-models.ts

@@ -68,6 +68,37 @@ const KIMI_FALLBACK_MODELS: RuntimeModelProbe[] = [
   { id: "kimi-k2-0711", displayName: "kimi-k2-0711", provider: "kimi", source: "builtin" },
 ];
 
+// Gemini CLI has no `gemini models list` command — the model set is
+// hard-coded inside the bundle's `VALID_GEMINI_MODELS` (see `@google/gemini-cli`
+// bundle `chunk-BE42OOYM.js:275832`). We mirror the documented user-facing
+// names here as a static catalog; the actual availability depends on the
+// user's auth tier (gcloud ADC / Vertex / GEMINI_API_KEY) and project quota.
+// The `auto` alias is the default — it lets gemini pick the best model.
+const GEMINI_FALLBACK_MODELS: RuntimeModelProbe[] = [
+  { id: "auto", displayName: "Auto (let Gemini pick)", provider: "google", source: "builtin", isDefault: true },
+  { id: "pro", displayName: "Pro alias", provider: "google", source: "builtin" },
+  { id: "flash", displayName: "Flash alias", provider: "google", source: "builtin" },
+  { id: "flash-lite", displayName: "Flash Lite alias", provider: "google", source: "builtin" },
+  { id: "gemini-2.5-pro", displayName: "Gemini 2.5 Pro", provider: "google", source: "builtin" },
+  { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", provider: "google", source: "builtin" },
+  { id: "gemini-2.5-flash-lite", displayName: "Gemini 2.5 Flash Lite", provider: "google", source: "builtin" },
+  { id: "gemini-3-pro-preview", displayName: "Gemini 3 Pro (preview)", provider: "google", source: "builtin" },
+  { id: "gemini-3-flash-preview", displayName: "Gemini 3 Flash (preview)", provider: "google", source: "builtin" },
+  { id: "gemini-3.1-pro-preview", displayName: "Gemini 3.1 Pro (preview)", provider: "google", source: "builtin" },
+  {
+    id: "gemini-3.1-pro-preview-customtools",
+    displayName: "Gemini 3.1 Pro Custom Tools (preview)",
+    provider: "google",
+    source: "builtin",
+  },
+  {
+    id: "gemini-3.1-flash-lite-preview",
+    displayName: "Gemini 3.1 Flash Lite (preview)",
+    provider: "google",
+    source: "builtin",
+  },
+];
+
 export interface RuntimeModelDiscovery {
   models?: RuntimeModelProbe[];
   parameters?: RuntimeParameterProbe[];
@@ -160,6 +191,22 @@ function runtimeCatalogStrategy(entry: RuntimeProbeEntry): RuntimeCatalogStrateg
           ],
         }),
       };
+    case "gemini":
+      // Gemini CLI exposes no runtime discovery command and its thinking
+      // budget / level (see bundle `ThinkingLevel`, `thinkingBudget`) is
+      // configured per-installation in `~/.gemini/settings.json`, not via
+      // any CLI flag — so we ship a static model catalog with no parameter
+      // controls. settings.json + BOTCORD_GEMINI_BIN feed the cache key so
+      // user-side reconfig (e.g. switching auth type) busts the cache.
+      return {
+        id: entry.id,
+        contextKey: runtimeCatalogContextKey(entry, {
+          settings: fileStatKey(path.join(homedir(), ".gemini", "settings.json")),
+          env: pickEnv(["BOTCORD_GEMINI_BIN", "GEMINI_CLI_HOME"]),
+        }),
+        discoverFresh: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+        fallback: () => ({ models: GEMINI_FALLBACK_MODELS.slice() }),
+      };
     default:
       return null;
   }

package/src/skill-index.ts

@@ -8,8 +8,10 @@ import { homedir } from "node:os";
 import path from "node:path";
 import {
   agentCodexHomeDir,
+  agentHermesHomeDir,
   agentWorkspaceDir,
 } from "./agent-workspace.js";
+import { hermesProfileHomeDir } from "./gateway/runtimes/hermes-agent.js";
 
 const MAX_SKILLS = 24;
 const MAX_DESCRIPTION_CHARS = 260;
@@ -19,6 +21,8 @@ export interface SoftSkillEntry {
   name: string;
   path: string;
   source: string;
+  runtime?: string;
+  profile?: string;
   description?: string;
   mtimeMs: number;
 }
@@ -26,53 +30,89 @@ export interface SoftSkillEntry {
 export interface AgentSkillSnapshotEntry {
   name: string;
   source: string;
+  sourceDetail?: string;
+  runtime?: string;
+  path?: string;
+  profile?: string;
   description?: string;
   mtimeMs: number;
 }
 
 export interface AgentSkillSnapshot {
   agentId: string;
+  runtime?: string;
   skills: AgentSkillSnapshotEntry[];
   probedAt: number;
 }
 
 export interface SkillIndexOptions {
   extraDirs?: string[];
+  hermesProfile?: string;
   includeGlobal?: boolean;
   runtime?: string;
 }
 
+interface SkillRoot {
+  dir: string;
+  source: string;
+  runtime?: string;
+  profile?: string;
+}
+
 export function defaultSkillDirs(
   agentId: string,
   opts: SkillIndexOptions = {},
-): Array<{ dir: string; source: string }> {
+): SkillRoot[] {
   const includeGlobal = opts.includeGlobal !== false;
   const agentClaude = {
     dir: path.join(agentWorkspaceDir(agentId), ".claude", "skills"),
     source: "agent-claude",
+    runtime: "claude-code",
   };
   const agentCodex = {
     dir: path.join(agentCodexHomeDir(agentId), "skills"),
     source: "agent-codex",
+    runtime: "codex",
   };
-  const dirs: Array<{ dir: string; source: string }> =
-    runtimeFamily(opts.runtime) === "codex"
-      ? [agentCodex, agentClaude]
-      : [agentClaude, agentCodex];
-
-  if (includeGlobal) {
-    const globalClaude = { dir: path.join(homedir(), ".claude", "skills"), source: "global-claude" };
-    const globalCodex = { dir: path.join(homedir(), ".codex", "skills"), source: "global-codex" };
-    dirs.push(
-      ...(runtimeFamily(opts.runtime) === "codex"
-        ? [globalCodex, globalClaude]
-        : [globalClaude, globalCodex]),
-    );
+  const agentHermes = hermesSkillRoot(agentId, opts.hermesProfile);
+
+  const dirs: SkillRoot[] = [];
+  switch (runtimeFamily(opts.runtime)) {
+    case "codex":
+      dirs.push(agentCodex);
+      if (includeGlobal) {
+        dirs.push({
+          dir: path.join(homedir(), ".codex", "skills"),
+          source: "global-codex",
+          runtime: "codex",
+        });
+      }
+      break;
+    case "hermes":
+      dirs.push(agentHermes);
+      break;
+    case "claude":
+      dirs.push(agentClaude);
+      if (includeGlobal) {
+        dirs.push({
+          dir: path.join(homedir(), ".claude", "skills"),
+          source: "global-claude",
+          runtime: "claude-code",
+        });
+      }
+      break;
+    case "other":
+      break;
   }
 
   const envDirs = parseSkillDirsEnv(process.env.BOTCORD_SKILL_DIRS);
   for (const dir of [...envDirs, ...(opts.extraDirs ?? [])]) {
-    dirs.push({ dir, source: "external" });
+    dirs.push({
+      dir,
+      source: "external",
+      ...(opts.runtime ? { runtime: opts.runtime } : {}),
+      ...(opts.hermesProfile ? { profile: opts.hermesProfile } : {}),
+    });
   }
 
   return dedupeDirs(expandSkillRoots(dirs));
@@ -114,6 +154,8 @@ export function scanSoftSkills(
         name: parsed.name,
         path: skillMd,
         source: root.source,
+        ...(root.runtime ? { runtime: root.runtime } : {}),
+        ...(root.profile ? { profile: root.profile } : {}),
         description: parsed.description,
         mtimeMs: st.mtimeMs,
       };
@@ -133,9 +175,14 @@ export function collectAgentSkillSnapshot(
 ): AgentSkillSnapshot {
   return {
     agentId,
+    ...(opts.runtime ? { runtime: opts.runtime } : {}),
     skills: scanSoftSkills(agentId, opts).map((skill) => ({
       name: skill.name,
-      source: skill.source.startsWith("agent-") ? "workspace" : "runtime-global",
+      source: snapshotSource(skill.source),
+      sourceDetail: skill.source,
+      ...(skill.runtime ? { runtime: skill.runtime } : {}),
+      path: skill.path,
+      ...(skill.profile ? { profile: skill.profile } : {}),
       ...(skill.description ? { description: skill.description } : {}),
       mtimeMs: skill.mtimeMs,
     })),
@@ -217,68 +264,77 @@ function parseSkillDirsEnv(value: string | undefined): string[] {
 }
 
 function dedupeDirs(
-  dirs: Array<{ dir: string; source: string }>,
-): Array<{ dir: string; source: string }> {
+  dirs: SkillRoot[],
+): SkillRoot[] {
   const seen = new Set<string>();
-  const out: Array<{ dir: string; source: string }> = [];
+  const out: SkillRoot[] = [];
   for (const entry of dirs) {
     const resolved = path.resolve(entry.dir);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
-    out.push({ dir: resolved, source: entry.source });
+    out.push({ ...entry, dir: resolved });
   }
   return out;
 }
 
-function expandSkillRoots(
-  dirs: Array<{ dir: string; source: string }>,
-): Array<{ dir: string; source: string }> {
-  const out: Array<{ dir: string; source: string }> = [];
+function expandSkillRoots(dirs: SkillRoot[]): SkillRoot[] {
+  const out: SkillRoot[] = [];
   for (const entry of dirs) {
     out.push(entry);
     if (entry.source.includes("codex")) {
-      out.push({ dir: path.join(entry.dir, ".system"), source: entry.source });
+      out.push({ ...entry, dir: path.join(entry.dir, ".system") });
     }
   }
   return out;
 }
 
-function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "other" {
+function hermesSkillRoot(agentId: string, profile: string | undefined): SkillRoot {
+  if (profile) {
+    try {
+      return {
+        dir: path.join(hermesProfileHomeDir(profile), "skills"),
+        source: "agent-hermes-profile",
+        runtime: "hermes-agent",
+        profile,
+      };
+    } catch {
+      // Corrupt legacy credentials should not make the whole skill snapshot fail.
+    }
+  }
+  return {
+    dir: path.join(agentHermesHomeDir(agentId), "skills"),
+    source: "agent-hermes",
+    runtime: "hermes-agent",
+  };
+}
+
+function runtimeFamily(runtime: string | undefined): "codex" | "claude" | "hermes" | "other" {
   if (runtime === "codex") return "codex";
+  if (runtime === "hermes-agent") return "hermes";
+  if (!runtime) return "claude";
   if (runtime === "claude-code") return "claude";
   return "other";
 }
 
-function priority(source: string, runtime: string | undefined): number {
-  if (runtimeFamily(runtime) === "codex") {
-    switch (source) {
-      case "agent-codex":
-        return 0;
-      case "global-codex":
-        return 1;
-      case "agent-claude":
-        return 2;
-      case "global-claude":
-        return 3;
-      default:
-        return 4;
-    }
-  }
-
+function priority(source: string, _runtime: string | undefined): number {
   switch (source) {
     case "agent-claude":
-      return 0;
     case "agent-codex":
-      return 1;
+    case "agent-hermes":
+    case "agent-hermes-profile":
+      return 0;
     case "global-claude":
-      return 2;
     case "global-codex":
-      return 3;
+      return 1;
     default:
-      return 4;
+      return 2;
   }
 }
 
+function snapshotSource(source: string): "workspace" | "runtime-global" {
+  return source.startsWith("agent-") ? "workspace" : "runtime-global";
+}
+
 function unquote(value: string): string {
   const trimmed = value.trim();
   if (