@botcord/daemon 0.2.35 → 0.2.37

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, readdirSync, readFileSync, rmSync, unlinkSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readFileSync, rmSync, statSync, 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";
@@ -12,6 +12,7 @@ import { loadConfig, resolveConfiguredAgentIds, saveConfig, } from "./config.js"
 import { BOTCORD_CHANNEL_TYPE, buildManagedRoutes, prepareGatewayProfile, } from "./daemon-config-map.js";
 import { agentHomeDir, agentStateDir, agentWorkspaceDir, applyAgentIdentity, ensureAttachedHermesProfileSkills, ensureAgentWorkspace, } from "./agent-workspace.js";
 import { detectRuntimes, getAdapterModule } from "./adapters/runtimes.js";
+import { createGatewayControl } from "./gateway-control.js";
 import { hermesProfileHomeDir, isValidHermesProfileName, listHermesProfiles, } from "./gateway/runtimes/hermes-agent.js";
 import { log as daemonLog } from "./log.js";
 import { discoverAgentCredentials } from "./agent-discovery.js";
@@ -25,6 +26,10 @@ export function createProvisioner(opts) {
     const register = opts.register ?? BotCordClient.register;
     const policyResolver = opts.policyResolver;
     const onAgentInstalled = opts.onAgentInstalled;
+    const gatewayControl = createGatewayControl({
+        gateway,
+        ...(opts.loginSessions ? { loginSessions: opts.loginSessions } : {}),
+    });
     return async (frame) => {
         daemonLog.debug("provision.dispatch", { type: frame.type, id: frame.id });
         switch (frame.type) {
@@ -196,6 +201,60 @@ export function createProvisioner(opts) {
                 daemonLog.debug("list_runtimes", { count: snapshot.runtimes.length });
                 return { ok: true, result: snapshot };
             }
+            case CONTROL_FRAME_TYPES.LIST_GATEWAYS:
+                return gatewayControl.handleList();
+            case CONTROL_FRAME_TYPES.UPSERT_GATEWAY: {
+                const v = validateGatewayParams(frame.params, {
+                    required: ["id", "type", "accountId"],
+                });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleUpsert(v.params);
+            }
+            case CONTROL_FRAME_TYPES.REMOVE_GATEWAY: {
+                const v = validateGatewayParams(frame.params, { required: ["id"] });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleRemove(v.params);
+            }
+            case CONTROL_FRAME_TYPES.TEST_GATEWAY: {
+                const v = validateGatewayParams(frame.params, { required: ["id"] });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleTest(v.params);
+            }
+            case CONTROL_FRAME_TYPES.GATEWAY_LOGIN_START: {
+                const v = validateGatewayParams(frame.params, {
+                    required: ["provider", "accountId"],
+                });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleLoginStart(v.params);
+            }
+            case CONTROL_FRAME_TYPES.GATEWAY_LOGIN_STATUS: {
+                const v = validateGatewayParams(frame.params, {
+                    required: ["provider", "loginId"],
+                });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleLoginStatus(v.params);
+            }
+            case "list_agent_files": {
+                const params = (frame.params ?? {});
+                if (!params.agentId) {
+                    return {
+                        ok: false,
+                        error: { code: "bad_params", message: "list_agent_files requires params.agentId" },
+                    };
+                }
+                const result = listAgentRuntimeFiles(params);
+                daemonLog.debug("list_agent_files", {
+                    agentId: params.agentId,
+                    fileId: params.fileId ?? null,
+                    count: result.files.length,
+                });
+                return { ok: true, result };
+            }
             default:
                 daemonLog.warn("provision.dispatch: unknown frame type", {
                     type: frame.type,
@@ -208,7 +267,165 @@ export function createProvisioner(opts) {
         }
     };
 }
+function validateGatewayParams(raw, spec) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            ok: false,
+            ack: { ok: false, error: { code: "bad_params", message: "params must be an object" } },
+        };
+    }
+    const params = raw;
+    for (const key of spec.required) {
+        const v = params[key];
+        if (typeof v !== "string" || v.length === 0) {
+            return {
+                ok: false,
+                ack: {
+                    ok: false,
+                    error: { code: "bad_params", message: `params.${key} must be a non-empty string` },
+                },
+            };
+        }
+    }
+    return { ok: true, params };
+}
 const openclawProvisionLocks = new Map();
+const RUNTIME_FILE_READ_CAP_BYTES = 128 * 1024;
+function listAgentRuntimeFiles(params) {
+    const agentId = params.agentId;
+    const credentials = loadStoredCredentials(defaultCredentialsFile(agentId));
+    const candidates = runtimeFileCandidates(credentials);
+    const selected = params.fileId
+        ? candidates.filter((candidate) => candidate.id === params.fileId)
+        : candidates;
+    return {
+        agentId,
+        ...(credentials.runtime ? { runtime: credentials.runtime } : {}),
+        files: selected.map(readRuntimeFileCandidate).filter(Boolean),
+    };
+}
+function runtimeFileCandidates(credentials) {
+    const agentId = credentials.agentId;
+    const runtime = credentials.runtime;
+    const out = [];
+    addWorkspaceFiles(out, agentId, runtime);
+    if (runtime === "hermes-agent") {
+        addHermesFiles(out, credentials);
+    }
+    if (runtime === "openclaw-acp") {
+        addOpenclawFiles(out, credentials);
+    }
+    return out;
+}
+function addWorkspaceFiles(out, agentId, runtime) {
+    const root = agentWorkspaceDir(agentId);
+    for (const file of ["AGENTS.md", "CLAUDE.md", "identity.md", "memory.md", "task.md"]) {
+        out.push({
+            id: `workspace:${file}`,
+            name: `workspace/${file}`,
+            scope: "workspace",
+            root,
+            relativePath: file,
+            ...(runtime ? { runtime } : {}),
+        });
+    }
+}
+function addHermesFiles(out, credentials) {
+    if (credentials.hermesProfile) {
+        const profile = credentials.hermesProfile;
+        const root = hermesProfileHomeDir(profile);
+        for (const file of ["SOUL.md", "AGENTS.md", "memories/MEMORY.md"]) {
+            out.push({
+                id: `hermes-profile:${profile}:${file}`,
+                name: `hermes/${profile}/${file}`,
+                scope: "hermes",
+                root,
+                relativePath: file,
+                runtime: "hermes-agent",
+                profile,
+            });
+        }
+    }
+    else {
+        const root = path.join(agentHomeDir(credentials.agentId), "hermes-home");
+        for (const file of ["SOUL.md", "AGENTS.md", "memories/MEMORY.md"]) {
+            out.push({
+                id: `hermes-home:${file}`,
+                name: `hermes-home/${file}`,
+                scope: "hermes",
+                root,
+                relativePath: file,
+                runtime: "hermes-agent",
+            });
+        }
+    }
+    out.push({
+        id: "hermes-workspace:AGENTS.md",
+        name: "hermes-workspace/AGENTS.md",
+        scope: "hermes",
+        root: path.join(agentHomeDir(credentials.agentId), "hermes-workspace"),
+        relativePath: "AGENTS.md",
+        runtime: "hermes-agent",
+        ...(credentials.hermesProfile ? { profile: credentials.hermesProfile } : {}),
+    });
+}
+function addOpenclawFiles(out, credentials) {
+    if (!credentials.openclawAgent)
+        return;
+    const local = readLocalOpenclawAgents();
+    if (!local)
+        return;
+    const profile = local.find((entry) => entry.id === credentials.openclawAgent);
+    if (!profile?.workspace)
+        return;
+    for (const file of ["SOUL.md", "MEMORY.md", "AGENTS.md"]) {
+        out.push({
+            id: `openclaw:${credentials.openclawAgent}:${file}`,
+            name: `openclaw/${credentials.openclawAgent}/${file}`,
+            scope: "openclaw",
+            root: profile.workspace,
+            relativePath: file,
+            runtime: "openclaw-acp",
+            profile: credentials.openclawAgent,
+        });
+    }
+}
+function readRuntimeFileCandidate(candidate) {
+    const resolved = path.resolve(candidate.root, candidate.relativePath);
+    const root = path.resolve(candidate.root);
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+        return null;
+    }
+    const base = {
+        id: candidate.id,
+        name: candidate.name,
+        scope: candidate.scope,
+        ...(candidate.runtime ? { runtime: candidate.runtime } : {}),
+        ...(candidate.profile ? { profile: candidate.profile } : {}),
+    };
+    try {
+        const lst = lstatSync(resolved);
+        if (lst.isSymbolicLink() || !lst.isFile())
+            return null;
+        const st = statSync(resolved);
+        base.size = st.size;
+        base.mtimeMs = st.mtimeMs;
+        if (st.size > RUNTIME_FILE_READ_CAP_BYTES) {
+            base.truncated = true;
+            return base;
+        }
+        base.content = readFileSync(resolved, "utf8");
+        return base;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        return {
+            ...base,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
 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
@@ -1290,10 +1507,14 @@ function readLocalOpenclawAgents() {
     try {
         const file = path.join(homedir(), ".openclaw", "openclaw.json");
         if (!existsSync(file))
-            return [{ id: "default" }];
+            return readLocalOpenclawAgentDirs() ?? [{ id: "default" }];
         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 explicitDefaultId = typeof cfg?.agents?.defaults?.id === "string" && cfg.agents.defaults.id
+            ? cfg.agents.defaults.id
+            : null;
+        const dirAgents = readLocalOpenclawAgentDirs();
+        const defaultId = explicitDefaultId ?? (list.length === 0 && !dirAgents ? "default" : null);
         const seen = new Set();
         const out = [];
         const push = (raw, fallbackId) => {
@@ -1323,16 +1544,45 @@ function readLocalOpenclawAgents() {
             }
             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);
+        // Explicit default agent first so it surfaces at the top of the dropdown.
+        if (defaultId)
+            push({ id: defaultId, workspace: cfg?.agents?.defaults?.workspace, model: cfg?.agents?.defaults?.model }, defaultId);
         for (const entry of list)
             push(entry);
+        for (const entry of dirAgents ?? [])
+            push(entry);
         return out;
     }
     catch {
         return null;
     }
 }
+function readLocalOpenclawAgentDirs() {
+    try {
+        const dir = path.join(homedir(), ".openclaw", "agents");
+        if (!existsSync(dir))
+            return null;
+        const agents = readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && entry.name.length > 0)
+            .map((entry) => ({
+            id: entry.name,
+            workspace: path.join(dir, entry.name),
+        }));
+        if (agents.length === 0)
+            return null;
+        agents.sort((a, b) => {
+            if (a.id === "main")
+                return -1;
+            if (b.id === "main")
+                return 1;
+            return a.id.localeCompare(b.id);
+        });
+        return agents;
+    }
+    catch {
+        return null;
+    }
+}
 function resolveOpenclawIdentityName(agentId, workspace, cfg) {
     const root = workspace ?? resolveOpenclawWorkspace(agentId, cfg);
     if (!root)

package/package.json

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