@botcord/daemon 0.2.5 → 0.2.8

package/dist/openclaw-discovery.js

@@ -0,0 +1,228 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { log as daemonLog } from "./log.js";
+import { probeOpenclawAgents } from "./provision.js";
+const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "/etc/openclaw/"];
+const DEFAULT_PORTS = [18789];
+export async function discoverLocalOpenclawGateways(opts = {}) {
+    const found = [];
+    for (const root of opts.searchPaths ?? DEFAULT_SEARCH_PATHS) {
+        found.push(...discoverFromConfigDir(root));
+    }
+    const env = opts.env ?? process.env;
+    const envUrl = env.OPENCLAW_ACP_URL;
+    if (envUrl) {
+        const item = {
+            name: nameFromUrl(envUrl),
+            url: envUrl,
+            source: "env",
+        };
+        if (env.OPENCLAW_ACP_TOKEN)
+            item.token = env.OPENCLAW_ACP_TOKEN;
+        else if (env.OPENCLAW_ACP_TOKEN_FILE)
+            item.tokenFile = env.OPENCLAW_ACP_TOKEN_FILE;
+        found.push(item);
+    }
+    const ports = opts.defaultPorts ?? DEFAULT_PORTS;
+    if (ports.length > 0) {
+        await Promise.all(ports.map(async (port) => {
+            const url = `ws://127.0.0.1:${port}`;
+            try {
+                const res = await probeOpenclawAgents({ url }, { probe: opts.probe, timeoutMs: opts.timeoutMs });
+                if (res.ok) {
+                    found.push({ name: nameFromUrl(url), url, source: "default-port" });
+                }
+            }
+            catch (err) {
+                daemonLog.debug("openclaw discovery default-port probe failed", {
+                    url,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }));
+    }
+    return dedupeDiscovered(found);
+}
+export function mergeOpenclawGateways(cfg, found) {
+    const existing = cfg.openclawGateways ?? [];
+    const existingUrls = new Set(existing.map((g) => normalizeUrlKey(g.url)));
+    const existingNames = new Set(existing.map((g) => g.name));
+    const added = [];
+    for (const item of found) {
+        const key = normalizeUrlKey(item.url);
+        if (existingUrls.has(key))
+            continue;
+        const profile = {
+            name: uniqueName(item.name, existingNames),
+            url: item.url,
+        };
+        if (item.token)
+            profile.token = item.token;
+        else if (item.tokenFile)
+            profile.tokenFile = item.tokenFile;
+        existingUrls.add(key);
+        existingNames.add(profile.name);
+        added.push(profile);
+    }
+    if (added.length === 0)
+        return { cfg, changed: false, added };
+    return {
+        cfg: { ...cfg, openclawGateways: [...existing, ...added] },
+        changed: true,
+        added,
+    };
+}
+function discoverFromConfigDir(root) {
+    const dir = expandHome(root);
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names.sort()) {
+        if (!name.endsWith(".json") && !name.endsWith(".toml"))
+            continue;
+        const file = path.join(dir, name);
+        try {
+            const st = statSync(file);
+            if (!st.isFile())
+                continue;
+            const raw = readFileSync(file, "utf8");
+            const parsed = name.endsWith(".json") ? parseJsonConfig(raw) : parseTomlConfig(raw);
+            if (!parsed?.url)
+                continue;
+            const item = {
+                name: nameFromUrl(parsed.url),
+                url: parsed.url,
+                source: "config-file",
+            };
+            if (parsed.token)
+                item.token = parsed.token;
+            else if (parsed.tokenFile)
+                item.tokenFile = parsed.tokenFile;
+            out.push(item);
+        }
+        catch (err) {
+            daemonLog.debug("openclaw discovery config skipped", {
+                file,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return out;
+}
+function parseJsonConfig(raw) {
+    const obj = JSON.parse(raw);
+    const acp = obj?.acp ?? obj?.gateway?.acp ?? obj?.gateway ?? obj;
+    return pickConfigValues(acp);
+}
+function parseTomlConfig(raw) {
+    let inAcp = false;
+    const values = {};
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.replace(/#.*/, "").trim();
+        if (!trimmed)
+            continue;
+        const section = trimmed.match(/^\[([^\]]+)\]$/);
+        if (section) {
+            inAcp = section[1] === "acp" || section[1].endsWith(".acp");
+            continue;
+        }
+        if (!inAcp)
+            continue;
+        const m = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*"(.*)"\s*$/);
+        if (m)
+            values[m[1]] = m[2];
+    }
+    return pickConfigValues(values);
+}
+function pickConfigValues(obj) {
+    if (!obj || typeof obj !== "object")
+        return null;
+    const url = pickString(obj, ["url", "wsUrl", "ws_url", "endpoint"]);
+    if (!url)
+        return null;
+    const token = pickString(obj, ["token", "bearerToken", "bearer_token"]);
+    const tokenFile = pickString(obj, ["tokenFile", "token_file"]);
+    return { url, token, tokenFile };
+}
+function pickString(obj, keys) {
+    for (const key of keys) {
+        const value = obj[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function dedupeDiscovered(items) {
+    const priority = {
+        "config-file": 3,
+        env: 2,
+        "default-port": 1,
+    };
+    const byUrl = new Map();
+    for (const item of items) {
+        const key = normalizeUrlKey(item.url);
+        const prev = byUrl.get(key);
+        if (!prev || priority[item.source] > priority[prev.source] || hasMoreAuth(item, prev)) {
+            byUrl.set(key, item);
+        }
+    }
+    return [...byUrl.values()];
+}
+function hasMoreAuth(a, b) {
+    const score = (x) => (x.token ? 2 : x.tokenFile ? 1 : 0);
+    return score(a) > score(b);
+}
+function nameFromUrl(raw) {
+    try {
+        const u = new URL(raw);
+        const base = `${u.hostname}-${u.port || (u.protocol === "wss:" ? "443" : "80")}`;
+        return `openclaw-${base.replace(/[^A-Za-z0-9_-]+/g, "-")}`;
+    }
+    catch {
+        return "openclaw-local";
+    }
+}
+function uniqueName(base, existing) {
+    let candidate = base;
+    let i = 2;
+    while (existing.has(candidate)) {
+        candidate = `${base}-${i}`;
+        i += 1;
+    }
+    return candidate;
+}
+function normalizeUrlKey(raw) {
+    try {
+        const u = new URL(raw);
+        u.hash = "";
+        return u.toString();
+    }
+    catch {
+        return raw.trim();
+    }
+}
+function expandHome(p) {
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return path.join(homedir(), p.slice(2));
+    return p;
+}
+export function defaultOpenclawDiscoverySearchPaths() {
+    return DEFAULT_SEARCH_PATHS.slice();
+}
+export function defaultOpenclawDiscoveryPorts() {
+    return DEFAULT_PORTS.slice();
+}
+export function openclawDiscoveryConfigEnabled(cfg) {
+    return cfg.openclawDiscovery?.enabled !== false;
+}
+export function openclawAutoProvisionEnabled(cfg) {
+    return cfg.openclawDiscovery?.autoProvision !== false;
+}

package/dist/provision.d.ts

@@ -1,5 +1,6 @@
-import { BotCordClient, type ControlAck, type ControlFrame, type ListRuntimesResult } from "@botcord/protocol-core";
+import { BotCordClient, type AgentIdentitySnapshot, type ControlAck, type ControlFrame, type ListRuntimesResult } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
+import type { PolicyResolverLike } from "./gateway/policy-resolver.js";
 import { type DaemonConfig } from "./config.js";
 /** Options accepted by {@link createProvisioner}. */
 export interface ProvisionerOptions {
@@ -10,6 +11,14 @@ export interface ProvisionerOptions {
      * run without a real Hub.
      */
     register?: typeof BotCordClient.register;
+    /**
+     * Optional policy-resolver handle (PR3). When present, the
+     * `policy_updated` control frame routes through it: cache is invalidated
+     * for the (agent, room?) pair, and any embedded `policy` payload is
+     * applied directly so the next inbound sees the fresh policy without an
+     * extra round-trip.
+     */
+    policyResolver?: PolicyResolverLike;
 }
 /** The value a frame handler returns (minus the `id` which the channel fills in). */
 type AckBody = Omit<ControlAck, "id">;
@@ -19,6 +28,26 @@ type AckBody = Omit<ControlAck, "id">;
  * `ControlChannelOptions.handle`.
  */
 export declare function createProvisioner(opts: ProvisionerOptions): (frame: ControlFrame) => Promise<AckBody>;
+export interface AdoptDiscoveredOpenclawAgentsResult {
+    adopted: string[];
+    skipped: Array<{
+        gateway: string;
+        openclawAgent?: string;
+        reason: string;
+    }>;
+    failed: Array<{
+        gateway: string;
+        openclawAgent?: string;
+        error: string;
+    }>;
+}
+export declare function adoptDiscoveredOpenclawAgents(ctx: {
+    gateway: Gateway;
+    register?: typeof BotCordClient.register;
+    cfg?: DaemonConfig;
+    timeoutMs?: number;
+    probe?: WsEndpointProbeFn;
+}): Promise<AdoptDiscoveredOpenclawAgentsResult>;
 /**
  * Append `agentId` to the daemon config if not already present. Returns a
  * new config object or `null` if nothing changed (so callers can skip the
@@ -36,6 +65,89 @@ export declare function removeAgentFromConfig(cfg: DaemonConfig, agentId: string
  * gateway already isolates from throwing) and reading the wall clock.
  */
 export declare function collectRuntimeSnapshot(): ListRuntimesResult;
+/** Maximum number of `endpoints[]` entries persisted per runtime (RFC §3.8.2). */
+export declare const RUNTIME_ENDPOINTS_CAP = 32;
+/** Injection seam for L2 + L3 endpoint probes — kept testable + side-effect-free. */
+export type WsEndpointProbeFn = (args: {
+    url: string;
+    token?: string;
+    timeoutMs: number;
+}) => Promise<{
+    ok: boolean;
+    version?: string;
+    /**
+     * L3 — populated when `agents.list` succeeds. `id` is the stable key
+     * consumed by route lookups / `openclawAgent`; `name` is display-only.
+     */
+    agents?: Array<{
+        id: string;
+        name?: string;
+        workspace?: string;
+        model?: {
+            name?: string;
+            provider?: string;
+        };
+    }>;
+    error?: string;
+}>;
+export declare function probeOpenclawAgents(profile: {
+    url: string;
+    token?: string;
+    tokenFile?: string;
+}, opts?: {
+    timeoutMs?: number;
+    probe?: WsEndpointProbeFn;
+}): Promise<{
+    ok: boolean;
+    version?: string;
+    agents?: Array<{
+        id: string;
+        name?: string;
+        workspace?: string;
+        model?: {
+            name?: string;
+            provider?: string;
+        };
+    }>;
+    error?: string;
+}>;
+/**
+ * Async variant that includes L2 (gateway reachability) and L3 (agent listing)
+ * probes for runtimes that talk to external services. Used by the production
+ * `list_runtimes` and first-connect snapshot paths.
+ *
+ * `cfg` is optional so existing callers without a loaded config (e.g. tests)
+ * can keep using the sync `collectRuntimeSnapshot()` — when absent, the result
+ * is identical to that function.
+ */
+export declare function collectRuntimeSnapshotAsync(opts?: {
+    cfg?: {
+        openclawGateways?: Array<{
+            name: string;
+            url: string;
+            token?: string;
+            tokenFile?: string;
+        }>;
+    };
+    wsProbe?: WsEndpointProbeFn;
+    timeoutMs?: number;
+}): Promise<ListRuntimesResult>;
+interface HelloIdentityResult {
+    updated: number;
+    skipped: number;
+}
+/**
+ * Reconcile every agent identity carried by the `hello.agents` snapshot
+ * against the on-disk `identity.md`. Best-effort: a malformed entry or a
+ * file-system error for one agent never aborts the rest.
+ *
+ * Identity-snapshot semantics intentionally only touch the metadata
+ * line + Bio body — Role/Boundaries paragraphs the user authored locally
+ * are preserved (see `applyAgentIdentity`). Missing identity.md files
+ * (agent provisioned on a different daemon, or workspace cleared) are
+ * silently skipped.
+ */
+export declare function applyHelloIdentitySnapshot(snapshot: AgentIdentitySnapshot[] | undefined): HelloIdentityResult;
 interface ReloadResult {
     reloaded: true;
     added: string[];