@botcord/daemon 0.2.6 → 0.2.9

package/dist/provision.js

@@ -4,7 +4,7 @@
  * side effects (register agent, write credentials, load route, add/remove
  * gateway channel) and return an ack payload.
  */
-import { existsSync, rmSync, unlinkSync } from "node:fs";
+import { existsSync, 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";
@@ -13,6 +13,7 @@ import { BOTCORD_CHANNEL_TYPE, buildManagedRoutes, prepareGatewayProfile, } from
 import { agentHomeDir, agentStateDir, agentWorkspaceDir, applyAgentIdentity, ensureAgentWorkspace, } from "./agent-workspace.js";
 import { detectRuntimes, getAdapterModule } from "./adapters/runtimes.js";
 import { log as daemonLog } from "./log.js";
+import { discoverAgentCredentials } from "./agent-discovery.js";
 /**
  * Build a dispatcher function that routes a `ControlFrame` to the right
  * handler. Returned function signature matches
@@ -179,6 +180,7 @@ export function createProvisioner(opts) {
         }
     };
 }
+const openclawProvisionLocks = new Map();
 async function provisionAgent(params, ctx) {
     // Validate both caller-supplied cwd sources up front. Previously only
     // `params.cwd` was checked, so `params.credentials.cwd` could smuggle an
@@ -186,13 +188,44 @@ async function provisionAgent(params, ctx) {
     // that hole by moving the check to the union of both.
     const explicitCwd = params.credentials?.cwd ?? params.cwd;
     assertSafeCwd(explicitCwd);
+    const openclawSel = pickOpenclawSelection(params);
+    if (openclawSel.gateway && openclawSel.agent) {
+        return withOpenclawProvisionLock(openclawSel.gateway, openclawSel.agent, async () => {
+            const existing = findCredentialsByOpenclaw(openclawSel.gateway, openclawSel.agent);
+            if (existing) {
+                daemonLog.info("provision_agent: openclaw binding already exists", {
+                    gateway: openclawSel.gateway,
+                    openclawAgent: openclawSel.agent,
+                    agentId: existing.agentId,
+                });
+                return installExistingOpenclawBinding(existing.agentId, ctx);
+            }
+            const cfg = loadConfig();
+            const credentials = await materializeCredentials(params, cfg, ctx, explicitCwd);
+            return installLocalAgent(credentials, {
+                ...ctx,
+                cfg,
+                bio: params.bio,
+                source: params.credentials ? "hub-supplied" : "registered",
+            });
+        });
+    }
     const cfg = loadConfig();
     const credentials = await materializeCredentials(params, cfg, ctx, explicitCwd);
+    return installLocalAgent(credentials, {
+        ...ctx,
+        cfg,
+        bio: params.bio,
+        source: params.credentials ? "hub-supplied" : "registered",
+    });
+}
+async function installLocalAgent(credentials, ctx) {
+    const cfg = ctx.cfg;
     daemonLog.debug("provision: credentials materialized", {
         agentId: credentials.agentId,
         hubUrl: credentials.hubUrl,
         runtime: credentials.runtime ?? null,
-        source: params.credentials ? "hub-supplied" : "registered",
+        source: ctx.source,
     });
     const credentialsFile = writeCredentialsFile(defaultCredentialsFile(credentials.agentId), credentials);
     // Seed the per-agent workspace directory. On failure, unlink the fresh
@@ -201,7 +234,7 @@ async function provisionAgent(params, ctx) {
     try {
         ensureAgentWorkspace(credentials.agentId, {
             displayName: credentials.displayName,
-            bio: params.bio,
+            bio: ctx.bio,
             runtime: credentials.runtime,
             keyId: credentials.keyId,
             savedAt: credentials.savedAt,
@@ -267,35 +300,7 @@ async function provisionAgent(params, ctx) {
     // Hot-add the synthesized per-agent managed route so the next turn picks
     // the agent's runtime + workspace cwd without waiting for reload_config.
     try {
-        const synthRoute = {
-            match: { accountId: credentials.agentId },
-            runtime: credentials.runtime ?? cfg.defaultRoute.adapter,
-            cwd: credentials.cwd ?? agentWorkspaceDir(credentials.agentId),
-        };
-        if (synthRoute.runtime === "openclaw-acp") {
-            // Resolve gateway from the freshly written credentials + the live
-            // openclawGateways registry. A missing/unknown gateway here yields a
-            // disabled route (set_route style); next turn for this agent falls
-            // back to defaultRoute. Caller already validated via reload semantics.
-            const profile = (cfg.openclawGateways ?? []).find((g) => g.name === credentials.openclawGateway);
-            if (profile) {
-                // Run the same tokenFile-aware resolver `toGatewayConfig` uses so the
-                // first turn after provisioning doesn't auth-fail when the gateway
-                // ships its bearer via `tokenFile` instead of an inline `token`.
-                const prepared = prepareGatewayProfile(profile);
-                synthRoute.gateway = {
-                    name: prepared.name,
-                    url: prepared.url,
-                    ...(prepared.resolvedToken ? { token: prepared.resolvedToken } : {}),
-                    ...(credentials.openclawAgent
-                        ? { openclawAgent: credentials.openclawAgent }
-                        : prepared.defaultAgent
-                            ? { openclawAgent: prepared.defaultAgent }
-                            : {}),
-                };
-            }
-        }
-        ctx.gateway.upsertManagedRoute(credentials.agentId, synthRoute);
+        upsertManagedRouteForCredentials(credentials, cfg, ctx.gateway);
     }
     catch (err) {
         // Rollback the channel + config + credentials on managed-route failure
@@ -336,6 +341,53 @@ async function provisionAgent(params, ctx) {
         credentialsFile,
     };
 }
+function upsertManagedRouteForCredentials(credentials, cfg, gateway) {
+    const synthRoute = {
+        match: { accountId: credentials.agentId },
+        runtime: credentials.runtime ?? cfg.defaultRoute.adapter,
+        cwd: credentials.cwd ?? agentWorkspaceDir(credentials.agentId),
+    };
+    if (synthRoute.runtime === "openclaw-acp") {
+        const profile = (cfg.openclawGateways ?? []).find((g) => g.name === credentials.openclawGateway);
+        if (profile) {
+            const prepared = prepareGatewayProfile(profile);
+            synthRoute.gateway = {
+                name: prepared.name,
+                url: prepared.url,
+                ...(prepared.resolvedToken ? { token: prepared.resolvedToken } : {}),
+                ...(credentials.openclawAgent
+                    ? { openclawAgent: credentials.openclawAgent }
+                    : prepared.defaultAgent
+                        ? { openclawAgent: prepared.defaultAgent }
+                        : {}),
+            };
+        }
+    }
+    gateway.upsertManagedRoute(credentials.agentId, synthRoute);
+}
+async function installExistingOpenclawBinding(agentId, ctx) {
+    const credentialsFile = defaultCredentialsFile(agentId);
+    const credentials = loadStoredCredentials(credentialsFile);
+    const cfg = loadConfig();
+    const updated = addAgentToConfig(cfg, credentials.agentId);
+    if (updated)
+        saveConfig(updated);
+    const snap = ctx.gateway.snapshot();
+    if (!snap.channels[credentials.agentId]) {
+        await ctx.gateway.addChannel({
+            id: credentials.agentId,
+            type: BOTCORD_CHANNEL_TYPE,
+            accountId: credentials.agentId,
+            agentId: credentials.agentId,
+        });
+    }
+    upsertManagedRouteForCredentials(credentials, cfg, ctx.gateway);
+    return {
+        agentId: credentials.agentId,
+        hubUrl: credentials.hubUrl,
+        credentialsFile,
+    };
+}
 async function materializeCredentials(params, cfg, ctx, explicitCwd) {
     // Runtime is an agent property. Hub is authoritative; top-level `runtime`
     // wins, `adapter` is a one-release alias, and `credentials.runtime` is the
@@ -442,6 +494,121 @@ function pickOpenclawSelection(params) {
     }
     return out;
 }
+async function withOpenclawProvisionLock(gateway, agent, fn) {
+    const key = `${gateway}\0${agent}`;
+    const prev = openclawProvisionLocks.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const chain = prev.then(() => current);
+    openclawProvisionLocks.set(key, chain);
+    await prev.catch(() => undefined);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (openclawProvisionLocks.get(key) === chain) {
+            openclawProvisionLocks.delete(key);
+        }
+    }
+}
+function findCredentialsByOpenclaw(gateway, openclawAgent) {
+    const discovered = discoverAgentCredentials({
+        credentialsDir: path.join(homedir(), ".botcord", "credentials"),
+    });
+    for (const a of discovered.agents) {
+        if (a.openclawGateway === gateway && a.openclawAgent === openclawAgent) {
+            return { agentId: a.agentId, credentialsFile: a.credentialsFile };
+        }
+    }
+    return null;
+}
+export async function adoptDiscoveredOpenclawAgents(ctx) {
+    const register = ctx.register ?? BotCordClient.register;
+    const cfg = ctx.cfg ?? loadConfig();
+    const result = {
+        adopted: [],
+        skipped: [],
+        failed: [],
+    };
+    for (const gw of cfg.openclawGateways ?? []) {
+        let probeResult;
+        try {
+            probeResult = await probeOpenclawAgents(gw, {
+                timeoutMs: ctx.timeoutMs,
+                probe: ctx.probe,
+            });
+        }
+        catch (err) {
+            result.failed.push({
+                gateway: gw.name,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            continue;
+        }
+        if (!probeResult.ok) {
+            result.skipped.push({
+                gateway: gw.name,
+                reason: probeResult.error ?? "gateway_unreachable",
+            });
+            continue;
+        }
+        for (const oc of probeResult.agents ?? []) {
+            await withOpenclawProvisionLock(gw.name, oc.id, async () => {
+                const existing = findCredentialsByOpenclaw(gw.name, oc.id);
+                if (existing) {
+                    result.skipped.push({
+                        gateway: gw.name,
+                        openclawAgent: oc.id,
+                        reason: "already_bound",
+                    });
+                    return;
+                }
+                const freshCfg = loadConfig();
+                if (!inferHubUrl(freshCfg)) {
+                    result.skipped.push({
+                        gateway: gw.name,
+                        openclawAgent: oc.id,
+                        reason: "missing_hub_url",
+                    });
+                    daemonLog.warn("openclaw adopt skipped: no known hubUrl", {
+                        gateway: gw.name,
+                        openclawAgent: oc.id,
+                    });
+                    return;
+                }
+                try {
+                    const params = {
+                        runtime: "openclaw-acp",
+                        name: oc.name ?? `openclaw-${oc.id}`,
+                        openclaw: { gateway: gw.name, agent: oc.id },
+                    };
+                    const credentials = await materializeCredentials(params, freshCfg, {
+                        gateway: ctx.gateway,
+                        register,
+                    }, undefined);
+                    const installed = await installLocalAgent(credentials, {
+                        gateway: ctx.gateway,
+                        register,
+                        cfg: freshCfg,
+                        source: "adopted-openclaw",
+                    });
+                    result.adopted.push(installed.agentId);
+                }
+                catch (err) {
+                    result.failed.push({
+                        gateway: gw.name,
+                        openclawAgent: oc.id,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            });
+        }
+    }
+    return result;
+}
 async function revokeAgent(params, ctx) {
     if (!params.agentId) {
         throw new Error("revoke_agent requires params.agentId");
@@ -634,16 +801,22 @@ export function collectRuntimeSnapshot() {
 /** Maximum number of `endpoints[]` entries persisted per runtime (RFC §3.8.2). */
 export const RUNTIME_ENDPOINTS_CAP = 32;
 /**
- * Default L2 + L3 probe — opens a WS handshake against the OpenClaw gateway
- * and, when the connection is up, issues a JSON-RPC `agents.list` request to
- * enumerate configured agent profiles. Best-effort: a successful WS open with
- * a failed `agents.list` still reports `ok: true` (just without `agents`),
- * matching the RFC's "agents populated only when listing succeeded" rule.
+ * Default L2 + L3 probe — speaks OpenClaw's WS frame protocol against the
+ * gateway and enumerates agent profiles via `agents.list`.
+ *
+ * Wire flow (see `~/claws/openclaw/src/gateway/server/ws-connection/message-handler.ts`
+ * and `~/claws/openclaw/src/gateway/protocol/schema/frames.ts`):
+ *   1. WS upgrade (no auth required at the HTTP layer).
+ *   2. Server emits `{type:"event", event:"connect.challenge", payload:{nonce}}`.
+ *   3. Client sends `{type:"req", id, method:"connect", params:{minProtocol, maxProtocol,
+ *      client:{id:"openclaw-probe", mode:"probe", ...}, auth:{token}}}`.
+ *   4. Server responds `{type:"res", id, ok:true, payload:{type:"hello-ok", server:{version}, ...}}`.
+ *   5. Client sends `{type:"req", id, method:"agents.list", params:{}}`.
+ *   6. Server responds with `{payload: { defaultId, mainKey, scope, agents:[{id, name?, workspace?, model?}] }}`.
  *
- * Method name and result shape follow OpenClaw:
- *   `~/claws/openclaw/src/gateway/server-methods/agents.ts:416` and
- *   `~/claws/openclaw/src/gateway/session-utils.ts:783` —
- *   `{ defaultId, mainKey, scope, agents: [{ id, name?, identity?, workspace, model? }] }`.
+ * Best-effort: a successful WS open with a failed handshake / `agents.list`
+ * still reports `ok: true` (just without `agents`), matching the RFC's
+ * "agents populated only when listing succeeded" rule.
  */
 async function defaultWsProbe(args) {
     const { default: WebSocket } = await import("ws");
@@ -651,6 +824,9 @@ async function defaultWsProbe(args) {
         let settled = false;
         let ws;
         let timer;
+        let serverVersion;
+        const CONNECT_ID = "probe-connect";
+        let connectSent = false;
         const settle = (v) => {
             if (settled)
                 return;
@@ -667,6 +843,8 @@ async function defaultWsProbe(args) {
         };
         try {
             const headers = {};
+            // Some deployments gate the WS upgrade on Authorization too; harmless
+            // when not enforced — auth is also re-asserted in the connect frame.
             if (args.token)
                 headers["Authorization"] = `Bearer ${args.token}`;
             ws = new WebSocket(args.url, { headers });
@@ -676,68 +854,161 @@ async function defaultWsProbe(args) {
             return;
         }
         timer = setTimeout(() => settle({ ok: false, error: "timeout" }), args.timeoutMs);
-        const requestId = "probe-agents-list";
-        ws.on("open", () => {
-            // L3: enumerate agent profiles. We don't fail the L2 result if this
-            // call fails — the gateway is reachable either way.
+        const sendConnect = () => {
+            if (connectSent)
+                return;
+            connectSent = true;
+            const params = {
+                minProtocol: 3,
+                maxProtocol: 3,
+                client: {
+                    id: "openclaw-probe",
+                    version: "0.1.0",
+                    platform: process.platform || "node",
+                    mode: "probe",
+                },
+                role: "operator",
+                scopes: ["operator.read"],
+            };
+            if (args.token)
+                params.auth = { token: args.token };
             try {
-                ws.send(JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: requestId,
-                    method: "agents.list",
-                    params: {},
-                }));
+                ws.send(JSON.stringify({ type: "req", id: CONNECT_ID, method: "connect", params }));
             }
             catch (err) {
-                settle({ ok: true, error: `agents.list send failed: ${err.message}` });
+                settle({ ok: true, error: `connect send failed: ${err.message}` });
             }
+        };
+        ws.on("open", () => {
+            // Some servers send `connect.challenge` before the socket is fully
+            // wired; if it never arrives we still try a best-effort connect after
+            // a short delay so the probe doesn't stall on legacy gateways.
+            setTimeout(() => {
+                if (!connectSent && !settled)
+                    sendConnect();
+            }, 250);
         });
         ws.on("message", (raw) => {
+            let msg;
             try {
-                const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
-                if (msg?.id !== requestId)
-                    return; // ignore unrelated frames
-                if (msg.error) {
-                    settle({ ok: true, error: String(msg.error?.message ?? "agents.list error") });
+                msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+            }
+            catch {
+                return;
+            }
+            if (!msg || typeof msg !== "object")
+                return;
+            if (msg.type === "event" && msg.event === "connect.challenge") {
+                // Nonce only matters for device-pairing flows; token-only auth ignores it.
+                sendConnect();
+                return;
+            }
+            if (msg.type !== "res" || typeof msg.id !== "string")
+                return;
+            if (msg.id === CONNECT_ID) {
+                if (!msg.ok) {
+                    const errMsg = msg.error?.message ? String(msg.error.message) : "connect rejected";
+                    settle({ ok: true, error: errMsg });
                     return;
                 }
-                const list = Array.isArray(msg.result?.agents) ? msg.result.agents : [];
-                const agents = [];
-                for (const a of list) {
-                    if (!a || typeof a.id !== "string" || a.id.length === 0)
-                        continue;
-                    const row = { id: a.id };
-                    if (typeof a.name === "string")
-                        row.name = a.name;
-                    if (typeof a.workspace === "string")
-                        row.workspace = a.workspace;
-                    if (a.model && typeof a.model === "object") {
-                        const model = {};
-                        if (typeof a.model.name === "string")
-                            model.name = a.model.name;
-                        if (typeof a.model.provider === "string")
-                            model.provider = a.model.provider;
-                        if (model.name || model.provider)
-                            row.model = model;
-                    }
-                    agents.push(row);
-                }
-                settle({ ok: true, agents });
-            }
-            catch (err) {
-                settle({ ok: true, error: `agents.list parse failed: ${err.message}` });
+                const v = msg.payload?.server?.version;
+                if (typeof v === "string" && v)
+                    serverVersion = v;
+                // We don't fetch agents.list over the wire: it requires `operator.read`
+                // which the gateway only grants to clients that present a paired device
+                // identity (see message-handler.ts:478 — self-declared scopes are
+                // cleared without device pairing). For local OpenClaw the agent list
+                // is sourced directly from disk by `probeOpenclawAgents`.
+                settle({ ok: true, version: serverVersion });
             }
         });
         ws.on("error", (err) => {
             settle({ ok: false, error: err.message });
         });
         ws.on("close", () => {
-            // If the socket closes before `agents.list` resolved we still treat
-            // L2 as ok (open fired) and emit no agents.
-            settle({ ok: true });
+            // If the socket closes before we got our agents.list response, treat
+            // L2 as ok (the upgrade succeeded) and emit no agents.
+            settle({ ok: true, version: serverVersion });
         });
     });
 }
+export async function probeOpenclawAgents(profile, opts = {}) {
+    const probe = opts.probe ?? defaultWsProbe;
+    const prepared = prepareGatewayProfile({
+        name: "probe",
+        url: profile.url,
+        ...(profile.token ? { token: profile.token } : {}),
+        ...(profile.tokenFile ? { tokenFile: profile.tokenFile } : {}),
+    });
+    const result = await probe({
+        url: profile.url,
+        token: prepared.resolvedToken,
+        timeoutMs: opts.timeoutMs ?? 3000,
+    });
+    // For loopback gateways the agent roster lives in `~/.openclaw/openclaw.json`
+    // and is the source of truth — listing it over the wire would require a
+    // paired device identity (operator.read scope). When the WS probe is the
+    // default (i.e. no test injection) we enrich the result from disk.
+    if (result.ok && !result.agents && !opts.probe && isLoopbackUrl(profile.url)) {
+        const local = readLocalOpenclawAgents();
+        if (local && local.length > 0)
+            result.agents = local;
+    }
+    return result;
+}
+function isLoopbackUrl(raw) {
+    try {
+        const u = new URL(raw);
+        return u.hostname === "127.0.0.1" || u.hostname === "::1" || u.hostname === "localhost";
+    }
+    catch {
+        return false;
+    }
+}
+function readLocalOpenclawAgents() {
+    try {
+        const file = path.join(homedir(), ".openclaw", "openclaw.json");
+        if (!existsSync(file))
+            return null;
+        const cfg = JSON.parse(readFileSync(file, "utf8"));
+        const list = Array.isArray(cfg?.agents?.list) ? cfg.agents.list : [];
+        const defaultId = typeof cfg?.agents?.defaults?.id === "string" ? cfg.agents.defaults.id : "default";
+        const seen = new Set();
+        const out = [];
+        const push = (raw, fallbackId) => {
+            const id = typeof raw?.id === "string" && raw.id ? raw.id : fallbackId;
+            if (!id || seen.has(id))
+                return;
+            seen.add(id);
+            const row = { id };
+            if (typeof raw?.name === "string")
+                row.name = raw.name;
+            if (typeof raw?.workspace === "string")
+                row.workspace = raw.workspace;
+            const m = raw?.model;
+            if (m && typeof m === "object") {
+                const model = {};
+                if (typeof m.primary === "string")
+                    model.name = m.primary;
+                else if (typeof m.name === "string")
+                    model.name = m.name;
+                if (typeof m.provider === "string")
+                    model.provider = m.provider;
+                if (model.name || model.provider)
+                    row.model = model;
+            }
+            out.push(row);
+        };
+        // Default agent first so it surfaces at the top of the dropdown.
+        push({ id: defaultId, workspace: cfg?.agents?.defaults?.workspace, model: cfg?.agents?.defaults?.model }, defaultId);
+        for (const entry of list)
+            push(entry);
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Async variant that includes L2 (gateway reachability) and L3 (agent listing)
  * probes for runtimes that talk to external services. Used by the production
@@ -752,18 +1023,17 @@ export async function collectRuntimeSnapshotAsync(opts = {}) {
     const gateways = opts.cfg?.openclawGateways ?? [];
     if (gateways.length === 0)
         return base;
-    const probe = opts.wsProbe ?? defaultWsProbe;
     // Default daemon-side budget is 3s — it must stay below the Hub's
     // `list_runtimes` ack wait (5s, see backend/hub/routers/daemon_control.py)
     // so a single slow gateway can't blow the whole snapshot to a 504.
     const timeoutMs = opts.timeoutMs ?? 3000;
     const capped = gateways.slice(0, RUNTIME_ENDPOINTS_CAP);
     const endpoints = await Promise.all(capped.map(async (g) => {
-        // Resolve `tokenFile` here so token-file-only profiles probe with auth
-        // and aren't falsely marked unreachable in the dashboard.
-        const prepared = prepareGatewayProfile(g);
         try {
-            const res = await probe({ url: g.url, token: prepared.resolvedToken, timeoutMs });
+            const res = await probeOpenclawAgents(g, {
+                probe: opts.wsProbe,
+                timeoutMs,
+            });
             const entry = { name: g.name, url: g.url, reachable: res.ok };
             if (res.version)
                 entry.version = res.version;
@@ -1106,5 +1376,14 @@ function inferHubUrl(cfg) {
             // skip
         }
     }
+    if (ids.length === 0) {
+        const discovered = discoverAgentCredentials({
+            credentialsDir: path.join(homedir(), ".botcord", "credentials"),
+        });
+        for (const a of discovered.agents) {
+            if (a.hubUrl)
+                return a.hubUrl;
+        }
+    }
     return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@botcord/cli": "^0.1.7",
-    "@botcord/protocol-core": "^0.2.0",
+    "@botcord/protocol-core": "^0.2.2",
     "ws": "^8.18.0"
   },
   "devDependencies": {