@agentbean/daemon 0.1.0

package/dist/config.js

@@ -0,0 +1,138 @@
+import { readFileSync } from 'node:fs';
+import { load as parseYaml } from 'js-yaml';
+const KINDS = ['codex', 'claude-code', 'openclaw', 'hermes', 'standalone'];
+const ENV_PATTERN = /\$\{([A-Z0-9_]+)\}/g;
+function interpolate(value) {
+    return value.replace(ENV_PATTERN, (_match, name) => {
+        const v = process.env[name];
+        if (v === undefined)
+            throw new Error(`config references missing env var: ${name}`);
+        return v;
+    });
+}
+function deepInterpolate(node) {
+    if (typeof node === 'string')
+        return interpolate(node);
+    if (Array.isArray(node))
+        return node.map(deepInterpolate);
+    if (node && typeof node === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(node))
+            out[k] = deepInterpolate(v);
+        return out;
+    }
+    return node;
+}
+export function loadConfig(path) {
+    const raw = parseYaml(readFileSync(path, 'utf8'));
+    if (!raw || typeof raw !== 'object')
+        throw new Error('config: top-level must be a mapping');
+    const interp = deepInterpolate(raw);
+    const need = ['id', 'name', 'role'];
+    for (const k of need) {
+        if (typeof interp[k] !== 'string' || interp[k].length === 0) {
+            throw new Error(`config: ${k} is required (non-empty string)`);
+        }
+    }
+    const a = interp.adapter ?? {};
+    if (!KINDS.includes(a.kind)) {
+        throw new Error(`config: adapter.kind must be one of ${KINDS.join(', ')}`);
+    }
+    if (typeof a.command !== 'string') {
+        throw new Error('config: adapter.command is required');
+    }
+    const s = interp.server ?? {};
+    if (typeof s.url !== 'string' || typeof s.token !== 'string') {
+        throw new Error('config: server.url and server.token are required');
+    }
+    const inferredCategory = a.kind === 'codex' || a.kind === 'claude-code' ? 'executor-hosted' :
+        a.kind === 'openclaw' || a.kind === 'hermes' ? 'agentos-hosted' :
+            'standalone-cli';
+    const category = typeof interp.category === 'string' && ['executor-hosted', 'agentos-hosted', 'standalone-cli'].includes(interp.category)
+        ? interp.category
+        : inferredCategory;
+    return {
+        id: interp.id,
+        name: interp.name,
+        role: interp.role,
+        category,
+        adapter: {
+            kind: a.kind,
+            command: a.command,
+            args: Array.isArray(a.args) ? a.args.map(String) : [],
+            cwd: typeof a.cwd === 'string' ? a.cwd : undefined,
+            workspace: typeof a.workspace === 'string' ? a.workspace : undefined,
+            systemPrompt: typeof a.systemPrompt === 'string' ? a.systemPrompt : undefined,
+        },
+        server: { url: s.url, token: s.token },
+        heartbeatIntervalMs: isValidHeartbeat(interp.heartbeatIntervalMs) ? interp.heartbeatIntervalMs : 10_000,
+    };
+}
+function isValidHeartbeat(v) {
+    return typeof v === 'number' && v > 0 && Number.isFinite(v);
+}
+export function loadDeviceConfig(path) {
+    const raw = parseYaml(readFileSync(path, 'utf8'));
+    if (!raw || typeof raw !== 'object')
+        throw new Error('config: top-level must be a mapping');
+    const interp = deepInterpolate(raw);
+    if (typeof interp.deviceId !== 'string' || interp.deviceId.length === 0) {
+        throw new Error('config: deviceId is required (non-empty string)');
+    }
+    if (typeof interp.networkId !== 'string' || interp.networkId.length === 0) {
+        throw new Error('config: networkId is required (non-empty string)');
+    }
+    const s = interp.server ?? {};
+    if (typeof s.url !== 'string' || typeof s.token !== 'string') {
+        throw new Error('config: server.url and server.token are required');
+    }
+    const agents = interp.agents ?? [];
+    if (!Array.isArray(agents) || agents.length === 0) {
+        throw new Error('config: agents array is required (at least one agent)');
+    }
+    const parsedAgents = [];
+    for (const a of agents) {
+        if (typeof a.id !== 'string' || a.id.length === 0) {
+            throw new Error('config: each agent must have an id (non-empty string)');
+        }
+        if (typeof a.name !== 'string' || a.name.length === 0) {
+            throw new Error('config: each agent must have a name (non-empty string)');
+        }
+        const ad = a.adapter ?? {};
+        if (!KINDS.includes(ad.kind)) {
+            throw new Error(`config: adapter.kind must be one of ${KINDS.join(', ')}`);
+        }
+        if (typeof ad.command !== 'string') {
+            throw new Error('config: adapter.command is required');
+        }
+        const inferredCategory = ad.kind === 'codex' || ad.kind === 'claude-code' ? 'executor-hosted' :
+            ad.kind === 'openclaw' || ad.kind === 'hermes' ? 'agentos-hosted' :
+                'standalone-cli';
+        const category = typeof a.category === 'string' && ['executor-hosted', 'agentos-hosted', 'standalone-cli'].includes(a.category)
+            ? a.category
+            : inferredCategory;
+        parsedAgents.push({
+            id: a.id,
+            name: a.name,
+            role: typeof a.role === 'string' ? a.role : '',
+            category,
+            adapter: {
+                kind: ad.kind,
+                command: ad.command,
+                args: Array.isArray(ad.args) ? ad.args.map(String) : [],
+                cwd: typeof ad.cwd === 'string' ? ad.cwd : undefined,
+                workspace: typeof ad.workspace === 'string' ? ad.workspace : undefined,
+                systemPrompt: typeof ad.systemPrompt === 'string' ? ad.systemPrompt : undefined,
+            },
+            visibility: a.visibility === 'public' ? 'public' : 'private',
+            sandboxed: a.sandboxed === true,
+        });
+    }
+    return {
+        deviceId: interp.deviceId,
+        networkId: interp.networkId,
+        server: { url: s.url, token: s.token },
+        heartbeatIntervalMs: isValidHeartbeat(interp.heartbeatIntervalMs) ? interp.heartbeatIntervalMs : 10_000,
+        agents: parsedAgents,
+    };
+}

package/dist/connection.js

@@ -0,0 +1,113 @@
+import { io } from 'socket.io-client';
+import { logger } from './log.js';
+import { uploadArtifact } from './uploader.js';
+import { postProcess } from './post-process.js';
+export function createConnection(cfg, adapter) {
+    let socket = null;
+    let heartbeatTimer = null;
+    let queue = Promise.resolve();
+    return {
+        async start() {
+            const agentUrl = cfg.server.url.endsWith('/agent') ? cfg.server.url : cfg.server.url + '/agent';
+            socket = io(agentUrl, {
+                auth: {
+                    token: cfg.server.token,
+                    agentId: cfg.id,
+                    name: cfg.name,
+                    role: cfg.role,
+                    adapterKind: cfg.adapter.kind,
+                },
+                reconnection: true,
+                reconnectionDelay: 1_000,
+            });
+            socket.on('connect', () => {
+                logger.info({ id: cfg.id }, 'connected to server');
+                socket.emit('register', {
+                    id: cfg.id, name: cfg.name, role: cfg.role,
+                    adapterKind: cfg.adapter.kind,
+                });
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                heartbeatTimer = setInterval(() => {
+                    socket?.emit('heartbeat', { at: Date.now() });
+                }, cfg.heartbeatIntervalMs);
+            });
+            socket.on('connect_error', (err) => {
+                logger.error({ err: err.message }, 'connect_error');
+            });
+            socket.on('dispatch', (req) => {
+                const currentSocket = socket;
+                if (!currentSocket) {
+                    logger.warn({ requestId: req.requestId }, 'dispatch received but socket is null');
+                    return;
+                }
+                queue = queue.then(async () => {
+                    const ctl = new AbortController();
+                    const dispatchStart = Date.now();
+                    try {
+                        const rawBody = await adapter.ask({
+                            prompt: req.prompt,
+                            history: req.history ?? [],
+                            systemPrompt: cfg.adapter.systemPrompt,
+                            workspace: cfg.adapter.workspace,
+                        }, ctl.signal);
+                        const processed = await postProcess(rawBody, cfg.adapter.workspace, cfg.adapter.kind, dispatchStart);
+                        const artifactIds = [];
+                        if (processed.outputFiles.length > 0) {
+                            const httpBase = cfg.server.url.replace(/\/agent$/, '');
+                            for (const filePath of processed.outputFiles) {
+                                try {
+                                    const result = await uploadArtifact({
+                                        serverUrl: httpBase,
+                                        token: cfg.server.token,
+                                        networkId: 'default',
+                                        filePath,
+                                        channelId: req.channelId,
+                                        uploaderId: cfg.id,
+                                    });
+                                    if (result)
+                                        artifactIds.push(result.id);
+                                }
+                                catch (err) {
+                                    logger.warn({ err: err.message, filePath }, 'artifact upload failed');
+                                }
+                            }
+                        }
+                        currentSocket.emit('reply', {
+                            channelId: req.channelId,
+                            body: processed.replyText,
+                            requestId: req.requestId,
+                            artifactIds: artifactIds.length > 0 ? artifactIds : undefined,
+                        });
+                    }
+                    catch (err) {
+                        logger.error({ err: err.message, requestId: req.requestId }, 'dispatch failed');
+                        currentSocket.emit('error_event', {
+                            at: Date.now(),
+                            message: err.message ?? 'unknown',
+                            scope: 'reply',
+                            requestId: req.requestId,
+                        });
+                    }
+                }).catch((err) => {
+                    logger.error({ err: err?.message, requestId: req.requestId }, 'dispatch queue error');
+                });
+            });
+            socket.on('disconnect', (reason) => {
+                logger.warn({ reason }, 'disconnected');
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+            });
+        },
+        async stop() {
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
+            }
+            socket?.close();
+            socket = null;
+        },
+    };
+}

package/dist/device-daemon.js

@@ -0,0 +1,212 @@
+import { io } from 'socket.io-client';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { logger } from './log.js';
+import { scanRuntimes, scanAgentOSAgents, scanLocalAgents, collectSystemInfo } from './scanner.js';
+const CACHE_DIR = join(homedir(), '.agentbean');
+const CACHE_FILE = join(CACHE_DIR, 'scanned-agents.json');
+function loadCache() {
+    try {
+        if (!existsSync(CACHE_FILE))
+            return null;
+        return JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveCache(agents) {
+    try {
+        if (!existsSync(CACHE_DIR))
+            mkdirSync(CACHE_DIR, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify(agents, null, 2));
+    }
+    catch (err) {
+        logger.warn({ err: err?.message }, 'failed to save scan cache');
+    }
+}
+async function scanAll() {
+    const [runtimes, agentos, local] = await Promise.all([
+        scanRuntimes(),
+        scanAgentOSAgents(),
+        scanLocalAgents(),
+    ]);
+    const results = [];
+    // Runtimes (executor-hosted) — only installed ones
+    for (const rt of runtimes) {
+        if (rt.installed) {
+            results.push({
+                name: rt.name,
+                category: 'executor-hosted',
+                adapterKind: rt.adapterKind,
+                command: rt.command,
+                args: [],
+                source: 'scanned',
+            });
+        }
+    }
+    // AgentOS + standalone (from gateway and filesystem scans)
+    const seen = new Set();
+    for (const ag of agentos) {
+        if (!seen.has(ag.command)) {
+            seen.add(ag.command);
+            results.push({ ...ag, source: 'scanned' });
+        }
+    }
+    for (const ag of local) {
+        if (!seen.has(ag.command)) {
+            seen.add(ag.command);
+            results.push({ ...ag, source: 'scanned' });
+        }
+    }
+    return results;
+}
+export function createDeviceDaemon(cfg, agents) {
+    let socket = null;
+    let heartbeatTimer = null;
+    const queues = new Map();
+    const httpBase = cfg.server.url.replace(/\/agent$/, '');
+    let firstConnect = true;
+    const systemInfo = collectSystemInfo();
+    const publicAgents = Array.from(agents.values())
+        .filter((a) => a.visibility === 'public')
+        .map((a) => a.publicMeta);
+    function emitRegister(sock, scanned) {
+        if (scanned.length === 0)
+            return;
+        sock.emit('device:register-agents', { agents: scanned }, (ack) => {
+            if (ack?.ok) {
+                logger.info({ count: ack.agents?.length }, 'scanned agents registered');
+            }
+            else {
+                logger.warn({ error: ack?.error }, 'failed to register scanned agents');
+            }
+        });
+    }
+    async function scanAndRegister(sock, useCache) {
+        if (useCache) {
+            const cached = loadCache();
+            if (cached) {
+                logger.info({ count: cached.length }, 'using cached scan results');
+                emitRegister(sock, cached);
+                // Background refresh — only emit if results differ
+                scanAll().then((fresh) => {
+                    saveCache(fresh);
+                    const cachedKey = JSON.stringify(cached.map((a) => a.command).sort());
+                    const freshKey = JSON.stringify(fresh.map((a) => a.command).sort());
+                    if (cachedKey !== freshKey) {
+                        logger.info({ count: fresh.length }, 'scan results changed, updating');
+                        emitRegister(sock, fresh);
+                    }
+                }).catch((err) => {
+                    logger.warn({ err: err?.message }, 'background scan failed');
+                });
+                return;
+            }
+        }
+        // Full scan (no cache or cache miss)
+        try {
+            const scanned = await scanAll();
+            saveCache(scanned);
+            emitRegister(sock, scanned);
+        }
+        catch (err) {
+            logger.error({ err: err?.message }, 'scan failed');
+        }
+    }
+    return {
+        async start() {
+            const agentUrl = cfg.server.url.endsWith('/agent') ? cfg.server.url : cfg.server.url + '/agent';
+            socket = io(agentUrl, {
+                auth: {
+                    token: cfg.server.token,
+                    deviceId: cfg.deviceId,
+                    networkId: cfg.networkId,
+                    agents: publicAgents,
+                    systemInfo,
+                },
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionDelay: 1_000,
+            });
+            socket.on('connect', () => {
+                const reconnecting = !firstConnect;
+                firstConnect = false;
+                logger.info({ deviceId: cfg.deviceId, sid: socket.id, reconnecting }, 'device daemon connected');
+                socket.emit('register');
+                // Reconnect: skip scan entirely (server already has our agents)
+                // First connect: use cache if available, otherwise full scan
+                if (!reconnecting) {
+                    scanAndRegister(socket, true);
+                }
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                heartbeatTimer = setInterval(() => {
+                    socket?.emit('heartbeat');
+                }, cfg.heartbeatIntervalMs);
+            });
+            socket.on('connect_error', (err) => {
+                logger.error({ err: err.message }, 'connect_error');
+            });
+            socket.on('dispatch', (req) => {
+                const agent = agents.get(req.agentId);
+                if (!agent) {
+                    logger.warn({ agentId: req.agentId, requestId: req.requestId }, 'dispatch for unknown agent');
+                    socket?.emit('error_event', {
+                        agentId: req.agentId,
+                        at: Date.now(),
+                        message: `agent ${req.agentId} not found on this device`,
+                        scope: 'dispatch',
+                        requestId: req.requestId,
+                    });
+                    return;
+                }
+                // Serialize dispatches per agent to avoid concurrent adapter usage
+                const currentSocket = socket;
+                if (!currentSocket) {
+                    logger.warn({ agentId: req.agentId, requestId: req.requestId }, 'dispatch received but socket is null');
+                    return;
+                }
+                const prev = queues.get(req.agentId) ?? Promise.resolve();
+                const next = prev.then(async () => {
+                    await agent.handleDispatch({
+                        socket: currentSocket,
+                        req,
+                        serverUrl: httpBase,
+                        token: cfg.server.token,
+                        networkId: cfg.networkId,
+                    });
+                }).catch((err) => {
+                    logger.error({ err: err?.message, agentId: req.agentId }, 'dispatch queue error');
+                    currentSocket.emit('error_event', {
+                        agentId: req.agentId,
+                        at: Date.now(),
+                        message: err?.message ?? 'unknown',
+                        scope: 'reply',
+                        requestId: req.requestId,
+                    });
+                });
+                queues.set(req.agentId, next);
+            });
+            socket.on('agents:discover', async () => {
+                await scanAndRegister(socket, false);
+            });
+            socket.on('disconnect', (reason) => {
+                logger.warn({ reason }, 'device daemon disconnected');
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+            });
+        },
+        async stop() {
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
+            }
+            socket?.close();
+            socket = null;
+        },
+    };
+}