@botcord/daemon 0.2.6 → 0.2.9

package/src/__tests__/openclaw-discovery.test.ts

@@ -0,0 +1,198 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  discoverLocalOpenclawGateways,
+  mergeOpenclawGateways,
+} from "../openclaw-discovery.js";
+import type { DaemonConfig } from "../config.js";
+import type { WsEndpointProbeFn } from "../provision.js";
+
+let tmp: string | null = null;
+
+afterEach(() => {
+  if (tmp) rmSync(tmp, { recursive: true, force: true });
+  tmp = null;
+});
+
+function tempDir(): string {
+  tmp = mkdtempSync(path.join(tmpdir(), "openclaw-discovery-"));
+  return tmp;
+}
+
+function baseConfig(): DaemonConfig {
+  return {
+    defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+    routes: [],
+    streamBlocks: true,
+  };
+}
+
+describe("discoverLocalOpenclawGateways", () => {
+  it("discovers JSON and TOML acp config files", async () => {
+    const dir = tempDir();
+    writeFileSync(
+      path.join(dir, "one.json"),
+      JSON.stringify({ acp: { url: "ws://127.0.0.1:18789/acp", tokenFile: "/tmp/token" } }),
+    );
+    writeFileSync(
+      path.join(dir, "two.toml"),
+      ['[acp]', 'url = "ws://127.0.0.1:18790/acp"', 'token = "secret"'].join("\n"),
+    );
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [dir],
+      defaultPorts: [],
+    });
+
+    expect(found).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          url: "ws://127.0.0.1:18789/acp",
+          tokenFile: "/tmp/token",
+          source: "config-file",
+        }),
+        expect.objectContaining({
+          url: "ws://127.0.0.1:18790/acp",
+          token: "secret",
+          source: "config-file",
+        }),
+      ]),
+    );
+  });
+
+  it("parses OpenClaw's native gateway.port + auth.token shape", async () => {
+    const dir = tempDir();
+    writeFileSync(
+      path.join(dir, "openclaw.json"),
+      JSON.stringify({
+        gateway: {
+          port: 18789,
+          bind: "loopback",
+          auth: { mode: "token", token: "native-token" },
+        },
+      }),
+    );
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [dir],
+      defaultPorts: [],
+    });
+
+    expect(found).toEqual([
+      expect.objectContaining({
+        url: "ws://127.0.0.1:18789",
+        token: "native-token",
+        source: "config-file",
+      }),
+    ]);
+  });
+
+  it("uses OPENCLAW_ACP_URL and token env vars", async () => {
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [],
+      defaultPorts: [],
+      env: {
+        OPENCLAW_ACP_URL: "ws://127.0.0.1:18888/acp",
+        OPENCLAW_ACP_TOKEN: "env-token",
+      },
+    });
+
+    expect(found).toEqual([
+      expect.objectContaining({
+        url: "ws://127.0.0.1:18888/acp",
+        token: "env-token",
+        source: "env",
+      }),
+    ]);
+  });
+
+  it("adds default-port candidates only when the probe succeeds", async () => {
+    const probe = vi.fn<WsEndpointProbeFn>(async ({ url }) => ({
+      ok: url.includes("18789"),
+      agents: [],
+    }));
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [],
+      defaultPorts: [18789, 18790],
+      probe,
+      timeoutMs: 10,
+    });
+
+    expect(probe).toHaveBeenCalledTimes(2);
+    expect(found.map((g) => g.url)).toEqual(["ws://127.0.0.1:18789"]);
+  });
+
+  it("prefers config-file auth details over lower-priority duplicate sources", async () => {
+    const dir = tempDir();
+    writeFileSync(
+      path.join(dir, "one.json"),
+      JSON.stringify({ acp: { url: "ws://127.0.0.1:18789", token: "file-token" } }),
+    );
+    const probe = vi.fn<WsEndpointProbeFn>(async () => ({ ok: true }));
+
+    const found = await discoverLocalOpenclawGateways({
+      searchPaths: [dir],
+      defaultPorts: [18789],
+      probe,
+      env: {
+        OPENCLAW_ACP_URL: "ws://127.0.0.1:18789",
+        OPENCLAW_ACP_TOKEN: "env-token",
+      },
+    });
+
+    expect(found).toHaveLength(1);
+    expect(found[0]).toEqual(
+      expect.objectContaining({ source: "config-file", token: "file-token" }),
+    );
+  });
+});
+
+describe("mergeOpenclawGateways", () => {
+  it("backfills token onto an existing profile that lacks one", () => {
+    const cfg = baseConfig();
+    cfg.openclawGateways = [
+      { name: "openclaw-127-0-0-1-18789", url: "ws://127.0.0.1:18789" },
+    ];
+    const merged = mergeOpenclawGateways(cfg, [
+      {
+        name: "openclaw-127-0-0-1-18789",
+        url: "ws://127.0.0.1:18789",
+        token: "discovered",
+        source: "config-file",
+      },
+    ]);
+
+    expect(merged.changed).toBe(true);
+    expect(merged.added).toEqual([]);
+    expect(merged.cfg.openclawGateways).toEqual([
+      { name: "openclaw-127-0-0-1-18789", url: "ws://127.0.0.1:18789", token: "discovered" },
+    ]);
+  });
+
+  it("appends new URLs and keeps existing profiles untouched", () => {
+    const cfg = baseConfig();
+    cfg.openclawGateways = [{ name: "local", url: "ws://127.0.0.1:18789/acp", token: "user-token" }];
+    const merged = mergeOpenclawGateways(cfg, [
+      {
+        name: "openclaw-127-0-0-1-18789",
+        url: "ws://127.0.0.1:18789/acp",
+        token: "discovered-token",
+        source: "env",
+      },
+      {
+        name: "openclaw-127-0-0-1-18790",
+        url: "ws://127.0.0.1:18790/acp",
+        source: "default-port",
+      },
+    ]);
+
+    expect(merged.changed).toBe(true);
+    expect(merged.cfg.openclawGateways).toEqual([
+      { name: "local", url: "ws://127.0.0.1:18789/acp", token: "user-token" },
+      { name: "openclaw-127-0-0-1-18790", url: "ws://127.0.0.1:18790/acp" },
+    ]);
+  });
+});

package/src/__tests__/provision.test.ts

@@ -26,6 +26,7 @@ vi.mock("../config.js", async () => {
 
 const {
   addAgentToConfig,
+  adoptDiscoveredOpenclawAgents,
   removeAgentFromConfig,
   reloadConfig,
   setRoute,
@@ -779,6 +780,110 @@ describe("provision_agent seeds workspace + hot-adds managed route", () => {
   });
 });
 
+describe("adoptDiscoveredOpenclawAgents", () => {
+  it("registers unbound OpenClaw agents and writes the routing binding", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      const credDir = nodePath.join(tmp, ".botcord", "credentials");
+      fs.mkdirSync(credDir, { recursive: true });
+      fs.writeFileSync(
+        nodePath.join(credDir, "ag_seed.json"),
+        JSON.stringify({
+          version: 1,
+          hubUrl: "https://hub.example",
+          agentId: "ag_seed",
+          keyId: "k_seed",
+          privateKey: Buffer.alloc(32, 5).toString("base64"),
+          savedAt: new Date().toISOString(),
+        }),
+      );
+      mockState.cfg = {
+        defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+        routes: [],
+        streamBlocks: true,
+        agents: ["ag_seed"],
+        openclawGateways: [{ name: "local", url: "ws://127.0.0.1:18789" }],
+      };
+
+      const gw = makeFakeGateway(["ag_seed"]);
+      const register = vi.fn(async () => ({
+        agentId: "ag_adopted",
+        keyId: "k_adopted",
+        privateKey: Buffer.alloc(32, 31).toString("base64"),
+        publicKey: Buffer.alloc(32, 32).toString("base64"),
+        hubUrl: "https://hub.example",
+        token: "tok",
+        expiresAt: Date.now() + 60_000,
+      }));
+
+      const res = await adoptDiscoveredOpenclawAgents({
+        gateway: gw as unknown as Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["gateway"],
+        register: register as unknown as Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["register"],
+        cfg: mockState.cfg as unknown as DaemonConfig,
+        probe: async () => ({ ok: true, agents: [{ id: "main", name: "Main Agent" }] }),
+      });
+
+      expect(res.adopted).toEqual(["ag_adopted"]);
+      expect(register).toHaveBeenCalledWith("https://hub.example", "Main Agent", undefined);
+      const saved = JSON.parse(
+        fs.readFileSync(nodePath.join(credDir, "ag_adopted.json"), "utf8"),
+      ) as Record<string, unknown>;
+      expect(saved.runtime).toBe("openclaw-acp");
+      expect(saved.openclawGateway).toBe("local");
+      expect(saved.openclawAgent).toBe("main");
+      expect((mockState.cfg.agents as string[])).toContain("ag_adopted");
+      expect(gw.addChannel).toHaveBeenCalledWith(
+        expect.objectContaining({ id: "ag_adopted", type: "botcord" }),
+      );
+      const route = gw.listManagedRoutes().find((r) => r.match?.accountId === "ag_adopted");
+      expect(route?.runtime).toBe("openclaw-acp");
+      expect(route?.gateway?.name).toBe("local");
+      expect(route?.gateway?.openclawAgent).toBe("main");
+    });
+  });
+
+  it("skips an OpenClaw agent that is already bound in credentials", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      const credDir = nodePath.join(tmp, ".botcord", "credentials");
+      fs.mkdirSync(credDir, { recursive: true });
+      fs.writeFileSync(
+        nodePath.join(credDir, "ag_existing.json"),
+        JSON.stringify({
+          version: 1,
+          hubUrl: "https://hub.example",
+          agentId: "ag_existing",
+          keyId: "k_existing",
+          privateKey: Buffer.alloc(32, 6).toString("base64"),
+          savedAt: new Date().toISOString(),
+          runtime: "openclaw-acp",
+          openclawGateway: "local",
+          openclawAgent: "main",
+        }),
+      );
+      mockState.cfg = {
+        defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+        routes: [],
+        streamBlocks: true,
+        agents: ["ag_existing"],
+        openclawGateways: [{ name: "local", url: "ws://127.0.0.1:18789" }],
+      };
+      const register = vi.fn();
+
+      const res = await adoptDiscoveredOpenclawAgents({
+        gateway: makeFakeGateway(["ag_existing"]) as unknown as Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["gateway"],
+        register: register as unknown as Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["register"],
+        cfg: mockState.cfg as unknown as DaemonConfig,
+        probe: async () => ({ ok: true, agents: [{ id: "main" }] }),
+      });
+
+      expect(res.adopted).toEqual([]);
+      expect(res.skipped).toEqual([
+        { gateway: "local", openclawAgent: "main", reason: "already_bound" },
+      ]);
+      expect(register).not.toHaveBeenCalled();
+    });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // revoke_agent — new flag semantics (plan §11.3)
 // ---------------------------------------------------------------------------

package/src/config.ts

@@ -88,6 +88,17 @@ export interface AgentDiscoveryConfig {
   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.
@@ -131,6 +142,12 @@ 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;
 }
 
 /**
@@ -357,6 +374,25 @@ export function loadConfig(): DaemonConfig {
     }
     out.agentDiscovery = copy;
   }
+  const openclawDiscovery = parsed.openclawDiscovery;
+  if (openclawDiscovery && typeof openclawDiscovery === "object") {
+    const copy: OpenclawDiscoveryConfig = {};
+    if (typeof openclawDiscovery.enabled === "boolean") copy.enabled = openclawDiscovery.enabled;
+    if (Array.isArray(openclawDiscovery.searchPaths)) {
+      copy.searchPaths = openclawDiscovery.searchPaths.filter(
+        (p): p is string => typeof p === "string" && p.length > 0,
+      );
+    }
+    if (Array.isArray(openclawDiscovery.defaultPorts)) {
+      copy.defaultPorts = openclawDiscovery.defaultPorts.filter(
+        (p): p is number => Number.isInteger(p) && p > 0 && p < 65536,
+      );
+    }
+    if (typeof openclawDiscovery.autoProvision === "boolean") {
+      copy.autoProvision = openclawDiscovery.autoProvision;
+    }
+    out.openclawDiscovery = copy;
+  }
   return out;
 }
 

package/src/daemon.ts

@@ -23,7 +23,12 @@ 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";
@@ -422,6 +427,30 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
   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/src/index.ts

@@ -57,6 +57,11 @@ import {
   updateWorkingMemory,
   DEFAULT_SECTION,
 } from "./working-memory.js";
+import {
+  discoverLocalOpenclawGateways,
+  mergeOpenclawGateways,
+  openclawDiscoveryConfigEnabled,
+} from "./openclaw-discovery.js";
 
 const ADAPTER_LIST = listAdapterIds().join("|");
 
@@ -402,7 +407,28 @@ async function ensureUserAuthForStart(args: ParsedArgs): Promise<UserAuthRecord
 }
 
 async function cmdStart(args: ParsedArgs): Promise<void> {
-  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.