@botcord/daemon 0.2.27 → 0.2.29

package/dist/openclaw-discovery.js

@@ -10,6 +10,14 @@ const DEFAULT_TOKEN_FILE_PATHS = [
     "/var/run/openclaw/gateway-token",
     "~/.openclaw/gateway-token",
 ];
+const DEFAULT_SYSTEMD_UNIT_PATHS = [
+    "/etc/systemd/system/openclaw.service",
+    "/etc/systemd/system/openclaw-gateway.service",
+    "/lib/systemd/system/openclaw.service",
+    "/lib/systemd/system/openclaw-gateway.service",
+    "/usr/lib/systemd/system/openclaw.service",
+    "/usr/lib/systemd/system/openclaw-gateway.service",
+];
 export async function discoverLocalOpenclawGateways(opts = {}) {
     const found = [];
     for (const root of opts.searchPaths ?? DEFAULT_SEARCH_PATHS) {
@@ -17,6 +25,7 @@ export async function discoverLocalOpenclawGateways(opts = {}) {
     }
     const env = opts.env ?? process.env;
     found.push(...discoverFromEnv(env));
+    found.push(...discoverFromSystemdUnits(opts.systemdUnitPaths ?? DEFAULT_SYSTEMD_UNIT_PATHS));
     const envAuth = pickOpenclawEnvAuth(env) ?? pickDefaultTokenFile();
     const ports = opts.defaultPorts ?? DEFAULT_PORTS;
     if (ports.length > 0) {
@@ -38,6 +47,167 @@ export async function discoverLocalOpenclawGateways(opts = {}) {
     }
     return dedupeDiscovered(found);
 }
+function discoverFromSystemdUnits(paths) {
+    const out = [];
+    for (const unitPath of paths) {
+        try {
+            if (!existsSync(unitPath))
+                continue;
+            const parsed = parseSystemdUnit(readFileSync(unitPath, "utf8"), path.dirname(unitPath));
+            const url = parsed.url ?? urlFromGatewayPort(parsed.env);
+            if (!url)
+                continue;
+            const auth = pickOpenclawEnvAuth(parsed.env);
+            out.push({
+                name: nameFromUrl(url),
+                url,
+                source: "systemd-unit",
+                ...auth,
+            });
+        }
+        catch (err) {
+            daemonLog.debug("openclaw discovery systemd unit skipped", {
+                file: unitPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return out;
+}
+function parseSystemdUnit(raw, unitDir) {
+    const env = {};
+    let url;
+    for (const line of joinedSystemdLines(raw)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = trimmed.slice(0, eq);
+        const value = trimmed.slice(eq + 1).trim();
+        if (key === "Environment") {
+            Object.assign(env, parseSystemdEnvironment(value));
+        }
+        else if (key === "EnvironmentFile") {
+            for (const file of splitSystemdWords(value)) {
+                const optional = file.startsWith("-");
+                const resolved = path.resolve(unitDir, expandHome(optional ? file.slice(1) : file));
+                try {
+                    Object.assign(env, parseEnvFile(readFileSync(resolved, "utf8")));
+                }
+                catch (err) {
+                    if (!optional) {
+                        daemonLog.debug("openclaw discovery environment file skipped", {
+                            file: resolved,
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                }
+            }
+        }
+        else if (key === "ExecStart") {
+            url = urlFromExecStart(value) ?? url;
+        }
+    }
+    return { env, url };
+}
+function joinedSystemdLines(raw) {
+    const out = [];
+    let cur = "";
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmedEnd = line.replace(/\s+$/, "");
+        if (trimmedEnd.endsWith("\\")) {
+            cur += trimmedEnd.slice(0, -1) + " ";
+            continue;
+        }
+        out.push(cur + line);
+        cur = "";
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+function parseSystemdEnvironment(raw) {
+    const env = {};
+    for (const word of splitSystemdWords(raw)) {
+        const eq = word.indexOf("=");
+        if (eq <= 0)
+            continue;
+        env[word.slice(0, eq)] = word.slice(eq + 1);
+    }
+    return env;
+}
+function parseEnvFile(raw) {
+    const env = {};
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0)
+            continue;
+        env[trimmed.slice(0, eq)] = unquote(trimmed.slice(eq + 1).trim());
+    }
+    return env;
+}
+function urlFromExecStart(raw) {
+    const words = splitSystemdWords(raw);
+    const portIdx = words.indexOf("--port");
+    const rawPort = portIdx >= 0 ? words[portIdx + 1] : words.find((w) => w.startsWith("--port="))?.slice(7);
+    if (!rawPort)
+        return undefined;
+    const port = Number(rawPort);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        return undefined;
+    return `ws://127.0.0.1:${port}`;
+}
+function splitSystemdWords(raw) {
+    const words = [];
+    let cur = "";
+    let quote = null;
+    let escaped = false;
+    for (const ch of raw) {
+        if (escaped) {
+            cur += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (cur) {
+                words.push(cur);
+                cur = "";
+            }
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur)
+        words.push(cur);
+    return words.map(unquote);
+}
+function unquote(raw) {
+    if ((raw.startsWith('"') && raw.endsWith('"')) ||
+        (raw.startsWith("'") && raw.endsWith("'"))) {
+        return raw.slice(1, -1);
+    }
+    return raw;
+}
 function discoverFromEnv(env) {
     const url = pickEnv(env, "OPENCLAW_ACP_URL") ??
         pickEnv(env, "OPENCLAW_GATEWAY_URL") ??
@@ -244,8 +414,9 @@ function pickString(obj, keys) {
 }
 function dedupeDiscovered(items) {
     const priority = {
-        "config-file": 3,
-        env: 2,
+        "config-file": 4,
+        env: 3,
+        "systemd-unit": 2,
         "default-port": 1,
     };
     const byUrl = new Map();
@@ -307,6 +478,9 @@ export function defaultOpenclawDiscoveryPorts() {
 export function defaultOpenclawDiscoveryTokenFilePaths() {
     return DEFAULT_TOKEN_FILE_PATHS.slice();
 }
+export function defaultOpenclawDiscoverySystemdUnitPaths() {
+    return DEFAULT_SYSTEMD_UNIT_PATHS.slice();
+}
 export function openclawDiscoveryConfigEnabled(cfg) {
     return cfg.openclawDiscovery?.enabled !== false;
 }

package/dist/provision.d.ts

@@ -90,14 +90,6 @@ export declare function addAgentToConfig(cfg: DaemonConfig, agentId: string): Da
 export declare function removeAgentFromConfig(cfg: DaemonConfig, agentId: string): DaemonConfig | null;
 /** Drop the cache (e.g. before a `doctor`-style interactive re-probe). */
 export declare function clearRuntimeProbeCache(): void;
-/**
- * Probe every registered adapter and shape the result as the wire-level
- * {@link ListRuntimesResult} — used by both the `list_runtimes` ack path and
- * the daemon-side first-connect `runtime_snapshot` push in `daemon.ts`.
- *
- * Cached for {@link RUNTIME_PROBE_CACHE_TTL_MS}; pass `{ force: true }` to
- * bypass the cache.
- */
 export declare function collectRuntimeSnapshot(opts?: {
     force?: boolean;
 }): ListRuntimesResult;
@@ -200,6 +192,18 @@ interface ReloadResult {
 export declare function reloadConfig(ctx: {
     gateway: Gateway;
 }): Promise<ReloadResult>;
+/**
+ * Scan `~/.botcord/credentials/*.json` and return a mapping from hermes
+ * profile name to the BotCord agent currently bound to it. Used by the
+ * runtime snapshot path to mark profiles as occupied in the picker, and by
+ * the provision path to enforce the 1 BotCord agent : 1 hermes profile
+ * invariant. The scan is cheap and authoritative — running daemon state may
+ * lag (e.g. between provision and reconcile), so we always read disk.
+ */
+export declare function profileOccupancyMap(): Map<string, {
+    agentId: string;
+    agentName?: string;
+}>;
 /**
  * Per-agent entry returned by `list_agents`. Wire shape: `{id, name, online}`.
  * `status` and `lastMessageAt` are extra daemon-only fields the dashboard

package/dist/provision.js

@@ -4,14 +4,15 @@
  * side effects (register agent, write credentials, load route, add/remove
  * gateway channel) and return an ack payload.
  */
-import { existsSync, readFileSync, rmSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, rmSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { BotCordClient, CONTROL_FRAME_TYPES, defaultCredentialsFile, derivePublicKey, loadStoredCredentials, writeCredentialsFile, } from "@botcord/protocol-core";
 import { loadConfig, resolveConfiguredAgentIds, saveConfig, } from "./config.js";
 import { BOTCORD_CHANNEL_TYPE, buildManagedRoutes, prepareGatewayProfile, } from "./daemon-config-map.js";
-import { agentHomeDir, agentStateDir, agentWorkspaceDir, applyAgentIdentity, ensureAgentWorkspace, } from "./agent-workspace.js";
+import { agentHomeDir, agentStateDir, agentWorkspaceDir, applyAgentIdentity, ensureAttachedHermesProfileSkills, ensureAgentWorkspace, } from "./agent-workspace.js";
 import { detectRuntimes, getAdapterModule } from "./adapters/runtimes.js";
+import { hermesProfileHomeDir, isValidHermesProfileName, listHermesProfiles, } from "./gateway/runtimes/hermes-agent.js";
 import { log as daemonLog } from "./log.js";
 import { discoverAgentCredentials } from "./agent-discovery.js";
 /**
@@ -67,7 +68,33 @@ export function createProvisioner(opts) {
                     runtime: pickRuntime(params) ?? null,
                     name: params.name ?? null,
                 });
-                const agent = await provisionAgent(params, { gateway, register, onAgentInstalled });
+                let agent;
+                try {
+                    agent = await provisionAgent(params, {
+                        gateway,
+                        register,
+                        onAgentInstalled,
+                    });
+                }
+                catch (err) {
+                    if (err instanceof HermesProfileError) {
+                        daemonLog.warn("provision_agent: hermes profile rejected", {
+                            code: err.code,
+                            profile: err.profile,
+                            occupiedBy: err.occupiedBy ?? null,
+                        });
+                        return {
+                            ok: false,
+                            error: {
+                                code: err.code,
+                                message: err.message,
+                                ...(err.occupiedBy ? { occupiedBy: err.occupiedBy } : {}),
+                                profile: err.profile,
+                            },
+                        };
+                    }
+                    throw err;
+                }
                 // Seed the policy resolver from the optional `defaultAttention` /
                 // `attentionKeywords` fields (PR3, control-frame.ts). Hub builds that
                 // don't yet emit these stay backwards-compatible — the resolver just
@@ -213,6 +240,23 @@ async function provisionAgent(params, ctx) {
             });
         });
     }
+    const hermesSel = pickHermesSelection(resolvedParams);
+    if (hermesSel) {
+        return withHermesProvisionLock(hermesSel, async () => {
+            // Race-safe re-check inside the per-profile lock so two concurrent
+            // provisions for the same profile (e.g. two dashboard tabs) cannot
+            // both succeed.
+            validateHermesProfileForProvision(hermesSel, params.credentials?.agentId);
+            const cfg = loadConfig();
+            const credentials = await materializeCredentials(resolvedParams, cfg, ctx, explicitCwd);
+            return installLocalAgent(credentials, {
+                ...ctx,
+                cfg,
+                bio: params.bio,
+                source: params.credentials ? "hub-supplied" : "registered",
+            });
+        });
+    }
     const credentials = await materializeCredentials(resolvedParams, initialCfg, ctx, explicitCwd);
     return installLocalAgent(credentials, {
         ...ctx,
@@ -241,6 +285,9 @@ async function installLocalAgent(credentials, ctx) {
             keyId: credentials.keyId,
             savedAt: credentials.savedAt,
         });
+        if (credentials.runtime === "hermes-agent" && credentials.hermesProfile) {
+            ensureAttachedHermesProfileSkills(hermesProfileHomeDir(credentials.hermesProfile));
+        }
     }
     catch (err) {
         try {
@@ -391,6 +438,9 @@ function upsertManagedRouteForCredentials(credentials, cfg, gateway) {
             };
         }
     }
+    if (synthRoute.runtime === "hermes-agent" && credentials.hermesProfile) {
+        synthRoute.hermesProfile = credentials.hermesProfile;
+    }
     gateway.upsertManagedRoute(credentials.agentId, synthRoute);
 }
 async function installExistingOpenclawBinding(agentId, ctx) {
@@ -482,6 +532,9 @@ async function materializeCredentials(params, cfg, ctx, explicitCwd) {
             record.openclawGateway = openclawSel.gateway;
         if (openclawSel.agent)
             record.openclawAgent = openclawSel.agent;
+        const hermesSel = pickHermesSelection(params);
+        if (hermesSel)
+            record.hermesProfile = hermesSel;
         return record;
     }
     // Slow path: daemon registers a fresh identity against Hub. We need a
@@ -514,6 +567,9 @@ async function materializeCredentials(params, cfg, ctx, explicitCwd) {
         record.openclawGateway = openclawSel.gateway;
     if (openclawSel.agent)
         record.openclawAgent = openclawSel.agent;
+    const hermesSel = pickHermesSelection(params);
+    if (hermesSel)
+        record.hermesProfile = hermesSel;
     return record;
 }
 /**
@@ -596,6 +652,69 @@ function withResolvedOpenclawSelection(params, selection) {
         },
     };
 }
+/**
+ * Resolve hermes profile selection from a `provision_agent` frame. Top-level
+ * `params.hermes.profile` (nested) wins over the flat
+ * `credentials.hermesProfile` mirror. Returning `undefined` is fine — the
+ * adapter falls back to the BotCord-isolated HERMES_HOME under
+ * `~/.botcord/agents/<id>/` when the agent is not attached to a profile.
+ */
+function pickHermesSelection(params) {
+    const top = params.hermes;
+    if (top && typeof top.profile === "string" && top.profile.length > 0) {
+        return top.profile;
+    }
+    const flat = params.credentials;
+    if (flat && typeof flat.hermesProfile === "string" && flat.hermesProfile.length > 0) {
+        return flat.hermesProfile;
+    }
+    return undefined;
+}
+const hermesProvisionLocks = new Map();
+async function withHermesProvisionLock(profile, fn) {
+    const prev = hermesProvisionLocks.get(profile) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    hermesProvisionLocks.set(profile, next);
+    try {
+        return (await next);
+    }
+    finally {
+        if (hermesProvisionLocks.get(profile) === next) {
+            hermesProvisionLocks.delete(profile);
+        }
+    }
+}
+class HermesProfileError extends Error {
+    code;
+    profile;
+    occupiedBy;
+    constructor(code, message, profile, occupiedBy) {
+        super(message);
+        this.code = code;
+        this.profile = profile;
+        this.occupiedBy = occupiedBy;
+        this.name = "HermesProfileError";
+    }
+}
+/**
+ * Validate that `profile` exists on disk and is not already bound to another
+ * BotCord agent. Throws {@link HermesProfileError} on failure so the caller
+ * can surface the structured error code via the control-frame ack.
+ */
+function validateHermesProfileForProvision(profile, selfAgentId) {
+    if (!isValidHermesProfileName(profile)) {
+        throw new HermesProfileError("hermes_profile_invalid", `Hermes profile "${profile}" is not a valid profile name.`, profile);
+    }
+    const home = hermesProfileHomeDir(profile);
+    if (!existsSync(home)) {
+        throw new HermesProfileError("hermes_profile_not_found", `Hermes profile "${profile}" does not exist at ${home}. Create it via "hermes profile create ${profile}" and retry.`, profile);
+    }
+    const occupancy = profileOccupancyMap();
+    const owner = occupancy.get(profile);
+    if (owner && owner.agentId !== selfAgentId) {
+        throw new HermesProfileError("hermes_profile_occupied", `Hermes profile "${profile}" is already bound to BotCord agent ${owner.agentId}.`, profile, owner.agentId);
+    }
+}
 async function withOpenclawProvisionLock(gateway, agent, fn) {
     const key = `${gateway}\0${agent}`;
     const prev = openclawProvisionLocks.get(key) ?? Promise.resolve();
@@ -922,6 +1041,33 @@ export function clearRuntimeProbeCache() {
  * Cached for {@link RUNTIME_PROBE_CACHE_TTL_MS}; pass `{ force: true }` to
  * bypass the cache.
  */
+/**
+ * Build the wire-shape `HermesProfileProbe[]` for the runtime snapshot,
+ * joining the on-disk profile listing with the BotCord-side occupancy map
+ * so dashboards can render disabled rows without a second round trip.
+ */
+function listHermesProfilesForSnapshot(occupancy) {
+    return listHermesProfiles().map((p) => {
+        const out = { name: p.name, home: p.home };
+        if (p.isDefault)
+            out.isDefault = true;
+        if (p.isActive)
+            out.isActive = true;
+        if (p.modelName)
+            out.modelName = p.modelName;
+        if (typeof p.sessionsCount === "number")
+            out.sessionsCount = p.sessionsCount;
+        if (p.hasSoul)
+            out.hasSoul = true;
+        const owner = occupancy.get(p.name);
+        if (owner) {
+            out.occupiedBy = owner.agentId;
+            if (owner.agentName)
+                out.occupiedByName = owner.agentName;
+        }
+        return out;
+    });
+}
 export function collectRuntimeSnapshot(opts = {}) {
     if (!opts.force &&
         _runtimeProbeCache &&
@@ -929,6 +1075,7 @@ export function collectRuntimeSnapshot(opts = {}) {
         return _runtimeProbeCache.value;
     }
     const entries = detectRuntimes();
+    const occupancy = profileOccupancyMap();
     const runtimes = entries.map((entry) => {
         const record = {
             id: entry.id,
@@ -945,6 +1092,9 @@ export function collectRuntimeSnapshot(opts = {}) {
         // already swallows throws into `{available: false}`. We leave the wire
         // field blank in that case and let callers treat `!available` as reason
         // enough; filling a synthetic message would be misleading.
+        if (entry.id === "hermes-agent" && entry.result.available) {
+            record.profiles = listHermesProfilesForSnapshot(occupancy);
+        }
         return record;
     });
     const value = { runtimes, probedAt: Date.now() };
@@ -1457,7 +1607,9 @@ function readAgentRuntimesFromCredentials(agentIds) {
                 entry.openclawGateway = creds.openclawGateway;
             if (creds.openclawAgent)
                 entry.openclawAgent = creds.openclawAgent;
-            if (entry.runtime || entry.cwd || entry.openclawGateway || entry.openclawAgent)
+            if (creds.hermesProfile)
+                entry.hermesProfile = creds.hermesProfile;
+            if (entry.runtime || entry.cwd || entry.openclawGateway || entry.openclawAgent || entry.hermesProfile)
                 out[id] = entry;
         }
         catch {
@@ -1466,6 +1618,48 @@ function readAgentRuntimesFromCredentials(agentIds) {
     }
     return out;
 }
+/**
+ * Scan `~/.botcord/credentials/*.json` and return a mapping from hermes
+ * profile name to the BotCord agent currently bound to it. Used by the
+ * runtime snapshot path to mark profiles as occupied in the picker, and by
+ * the provision path to enforce the 1 BotCord agent : 1 hermes profile
+ * invariant. The scan is cheap and authoritative — running daemon state may
+ * lag (e.g. between provision and reconcile), so we always read disk.
+ */
+export function profileOccupancyMap() {
+    const out = new Map();
+    const dir = path.join(homedir(), ".botcord", "credentials");
+    let names = [];
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return out;
+    }
+    for (const file of names) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const creds = loadStoredCredentials(path.join(dir, file));
+            if (creds.runtime !== "hermes-agent")
+                continue;
+            if (!creds.hermesProfile)
+                continue;
+            // First write wins — ties shouldn't happen, but if they do, the
+            // provision path's race check will surface it.
+            if (!out.has(creds.hermesProfile)) {
+                out.set(creds.hermesProfile, {
+                    agentId: creds.agentId,
+                    agentName: creds.displayName,
+                });
+            }
+        }
+        catch {
+            // skip unreadable
+        }
+    }
+    return out;
+}
 function listAgentsFromGateway(gateway) {
     const snap = gateway.snapshot();
     // Include any configured agents that the gateway may not have a status for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/agent-workspace.test.ts

@@ -18,6 +18,7 @@ import {
   agentStateDir,
   agentWorkspaceDir,
   applyAgentIdentity,
+  ensureAttachedHermesProfileSkills,
   ensureAgentCodexHome,
   ensureAgentHermesWorkspace,
   ensureAgentWorkspace,
@@ -150,6 +151,23 @@ describe("ensureAgentWorkspace", () => {
     expect(reseeded).toContain("name: botcord");
   });
 
+  it("seeds bundled skills into an attached Hermes profile without creating private home state", () => {
+    const profileHome = path.join(tmpHome, ".hermes", "profiles", "coder");
+    mkdirSync(profileHome, { recursive: true });
+
+    const { hermesHome, hermesWorkspace } = ensureAgentHermesWorkspace("ag_hermes_attach", {
+      attached: true,
+    });
+    ensureAttachedHermesProfileSkills(profileHome);
+
+    expect(existsSync(path.join(profileHome, "skills", "botcord", "SKILL.md"))).toBe(true);
+    expect(existsSync(path.join(profileHome, "skills", "botcord-user-guide", "SKILL.md"))).toBe(
+      true,
+    );
+    expect(existsSync(hermesWorkspace)).toBe(true);
+    expect(existsSync(hermesHome)).toBe(false);
+  });
+
   it("does not overwrite a user-modified memory.md on a second call", () => {
     ensureAgentWorkspace("ag_keep", {});
     const memoryPath = path.join(agentWorkspaceDir("ag_keep"), "memory.md");