@botcord/daemon 0.2.6 → 0.2.9

package/dist/config.d.ts

@@ -74,6 +74,16 @@ export interface AgentDiscoveryConfig {
     enabled?: boolean;
     credentialsDir?: string;
 }
+export interface OpenclawDiscoveryConfig {
+    /** Defaults to true. */
+    enabled?: boolean;
+    /** Overrides the local config-file search roots. */
+    searchPaths?: string[];
+    /** Overrides the local loopback ports to probe. */
+    defaultPorts?: number[];
+    /** Defaults to true. When false, discovery only persists gateways. */
+    autoProvision?: boolean;
+}
 export interface DaemonConfig {
     /**
      * @deprecated Kept for backward compatibility with pre-multi-agent configs.
@@ -113,6 +123,11 @@ export interface DaemonConfig {
      * so the dispatcher never re-queries this list.
      */
     openclawGateways?: OpenclawGatewayProfile[];
+    /**
+     * Daemon-side local OpenClaw discovery. Omitted means enabled with default
+     * search paths/ports and automatic adoption of discovered agents.
+     */
+    openclawDiscovery?: OpenclawDiscoveryConfig;
 }
 /**
  * Persistent transcript settings (design §6). Default-off — `botcord-daemon

package/dist/config.js

@@ -186,6 +186,22 @@ export function loadConfig() {
         }
         out.agentDiscovery = copy;
     }
+    const openclawDiscovery = parsed.openclawDiscovery;
+    if (openclawDiscovery && typeof openclawDiscovery === "object") {
+        const copy = {};
+        if (typeof openclawDiscovery.enabled === "boolean")
+            copy.enabled = openclawDiscovery.enabled;
+        if (Array.isArray(openclawDiscovery.searchPaths)) {
+            copy.searchPaths = openclawDiscovery.searchPaths.filter((p) => typeof p === "string" && p.length > 0);
+        }
+        if (Array.isArray(openclawDiscovery.defaultPorts)) {
+            copy.defaultPorts = openclawDiscovery.defaultPorts.filter((p) => Number.isInteger(p) && p > 0 && p < 65536);
+        }
+        if (typeof openclawDiscovery.autoProvision === "boolean") {
+            copy.autoProvision = openclawDiscovery.autoProvision;
+        }
+        out.openclawDiscovery = copy;
+    }
     return out;
 }
 function validateAdapter(id, field) {

package/dist/daemon.js

@@ -7,7 +7,8 @@ import { ensureAgentWorkspace } from "./agent-workspace.js";
 import { ControlChannel } from "./control-channel.js";
 import { toGatewayConfig } from "./daemon-config-map.js";
 import { log as daemonLog } from "./log.js";
-import { collectRuntimeSnapshot, createProvisioner } from "./provision.js";
+import { adoptDiscoveredOpenclawAgents, collectRuntimeSnapshot, createProvisioner, } from "./provision.js";
+import { openclawAutoProvisionEnabled } from "./openclaw-discovery.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
@@ -289,6 +290,28 @@ export async function startDaemon(opts) {
     }
     await gateway.start();
     logger.info("daemon started", { agents: agentIds });
+    if (openclawAutoProvisionEnabled(opts.config)) {
+        try {
+            const adopted = await adoptDiscoveredOpenclawAgents({
+                gateway,
+                cfg: opts.config,
+            });
+            if (adopted.adopted.length > 0 ||
+                adopted.failed.length > 0 ||
+                adopted.skipped.length > 0) {
+                logger.info("openclaw auto-provision completed", {
+                    adopted: adopted.adopted,
+                    skipped: adopted.skipped,
+                    failed: adopted.failed,
+                });
+            }
+        }
+        catch (err) {
+            logger.warn("openclaw auto-provision failed; continuing", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     // Control channel is optional — daemon still runs (data-plane only)
     // when user-auth hasn't been set up yet. Operators can `login` later
     // without restarting, but for P0 we require a restart to pick it up.

package/dist/index.js

@@ -15,6 +15,7 @@ import { renderStatus } from "./status-render.js";
 import { appendNextParam } from "./url-utils.js";
 import { channelsFromDaemonConfig, defaultHttpFetcher, renderDoctor, runDoctor, } from "./doctor.js";
 import { clearWorkingMemory, readWorkingMemory, resolveMemoryDir, updateWorkingMemory, DEFAULT_SECTION, } from "./working-memory.js";
+import { discoverLocalOpenclawGateways, mergeOpenclawGateways, openclawDiscoveryConfigEnabled, } from "./openclaw-discovery.js";
 const ADAPTER_LIST = listAdapterIds().join("|");
 const DEFAULT_HUB = "https://api.botcord.chat";
 /**
@@ -320,7 +321,29 @@ async function ensureUserAuthForStart(args) {
     return runDeviceCodeFlow({ hubUrl, label });
 }
 async function cmdStart(args) {
-    const cfg = loadOrInitConfig(args);
+    let cfg = loadOrInitConfig(args);
+    if (openclawDiscoveryConfigEnabled(cfg)) {
+        try {
+            const found = await discoverLocalOpenclawGateways({
+                searchPaths: cfg.openclawDiscovery?.searchPaths,
+                defaultPorts: cfg.openclawDiscovery?.defaultPorts,
+                timeoutMs: 500,
+            });
+            const merged = mergeOpenclawGateways(cfg, found);
+            if (merged.changed) {
+                cfg = merged.cfg;
+                saveConfig(cfg);
+                log.info("openclaw discovery: gateways merged", {
+                    added: merged.added.map((g) => ({ name: g.name, url: g.url })),
+                });
+            }
+        }
+        catch (err) {
+            log.warn("openclaw discovery failed; continuing", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
     // Foreground is now the default. --background (alias -d) detaches.
     // --foreground is still accepted (no-op) for backwards compatibility and
     // is also what the detached child re-execs itself with.

package/dist/openclaw-discovery.d.ts

@@ -0,0 +1,28 @@
+import type { DaemonConfig, OpenclawGatewayProfile } from "./config.js";
+import { type WsEndpointProbeFn } from "./provision.js";
+export type DiscoveredOpenclawGatewaySource = "config-file" | "env" | "default-port";
+export interface DiscoveredOpenclawGateway {
+    name: string;
+    url: string;
+    token?: string;
+    tokenFile?: string;
+    source: DiscoveredOpenclawGatewaySource;
+}
+export interface OpenclawGatewayDiscoveryOptions {
+    searchPaths?: string[];
+    defaultPorts?: number[];
+    probe?: WsEndpointProbeFn;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+export interface MergeOpenclawGatewayResult {
+    cfg: DaemonConfig;
+    changed: boolean;
+    added: OpenclawGatewayProfile[];
+}
+export declare function discoverLocalOpenclawGateways(opts?: OpenclawGatewayDiscoveryOptions): Promise<DiscoveredOpenclawGateway[]>;
+export declare function mergeOpenclawGateways(cfg: DaemonConfig, found: DiscoveredOpenclawGateway[]): MergeOpenclawGatewayResult;
+export declare function defaultOpenclawDiscoverySearchPaths(): string[];
+export declare function defaultOpenclawDiscoveryPorts(): number[];
+export declare function openclawDiscoveryConfigEnabled(cfg: DaemonConfig): boolean;
+export declare function openclawAutoProvisionEnabled(cfg: DaemonConfig): boolean;

package/dist/openclaw-discovery.js

@@ -0,0 +1,272 @@
+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 byUrl = new Map();
+    existing.forEach((g, i) => byUrl.set(normalizeUrlKey(g.url), i));
+    const existingNames = new Set(existing.map((g) => g.name));
+    const merged = existing.map((g) => ({ ...g }));
+    const added = [];
+    let mutated = false;
+    for (const item of found) {
+        const key = normalizeUrlKey(item.url);
+        const idx = byUrl.get(key);
+        if (idx !== undefined) {
+            // Same URL already configured — only fill in auth that the user is
+            // missing, never overwrite an existing token / tokenFile.
+            const cur = merged[idx];
+            if (!cur.token && !cur.tokenFile) {
+                if (item.token) {
+                    cur.token = item.token;
+                    mutated = true;
+                }
+                else if (item.tokenFile) {
+                    cur.tokenFile = item.tokenFile;
+                    mutated = true;
+                }
+            }
+            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;
+        byUrl.set(key, merged.length);
+        existingNames.add(profile.name);
+        merged.push(profile);
+        added.push(profile);
+    }
+    if (added.length === 0 && !mutated)
+        return { cfg, changed: false, added };
+    return {
+        cfg: { ...cfg, openclawGateways: merged },
+        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);
+    // Prefer OpenClaw's native shape: `gateway.port` + `gateway.auth.token`.
+    // The legacy `acp.url` shape is also supported for explicit user-authored configs.
+    const native = pickOpenclawGatewayValues(obj?.gateway);
+    if (native)
+        return native;
+    const acp = obj?.acp ?? obj?.gateway?.acp ?? obj?.gateway ?? obj;
+    return pickConfigValues(acp);
+}
+function pickOpenclawGatewayValues(gw) {
+    if (!gw || typeof gw !== "object")
+        return null;
+    const port = typeof gw.port === "number" ? gw.port : undefined;
+    if (!port)
+        return null;
+    // Local discovery always targets the loopback interface, regardless of how
+    // the gateway is bound — the daemon is on the same machine.
+    const url = `ws://127.0.0.1:${port}`;
+    const auth = gw.auth;
+    const out = { url };
+    if (auth && typeof auth === "object" && auth.mode === "token") {
+        if (typeof auth.token === "string" && auth.token.trim())
+            out.token = auth.token.trim();
+        else if (typeof auth.tokenFile === "string" && auth.tokenFile.trim()) {
+            out.tokenFile = auth.tokenFile.trim();
+        }
+    }
+    return out;
+}
+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

@@ -28,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
@@ -70,6 +90,27 @@ export type WsEndpointProbeFn = (args: {
     }>;
     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