@agentbean/daemon 0.1.3 → 0.1.4

package/dist/adapters/factory.js

@@ -0,0 +1,38 @@
+import { CodexAdapter } from './codex.js';
+import { ClaudeCodeAdapter } from './claude-code.js';
+import { OpenClawAdapter } from './openclaw.js';
+import { HermesAdapter } from './hermes.js';
+export function pickAdapter(cfg) {
+    switch (cfg.kind) {
+        case 'codex':
+            return new CodexAdapter({
+                command: cfg.command,
+                args: cfg.args,
+                cwd: cfg.cwd,
+                systemPrompt: cfg.systemPrompt,
+            });
+        case 'claude-code':
+            return new ClaudeCodeAdapter({
+                command: cfg.command,
+                args: cfg.args,
+                cwd: cfg.cwd,
+                systemPrompt: cfg.systemPrompt,
+            });
+        case 'openclaw':
+            return new OpenClawAdapter({
+                command: cfg.command,
+                args: cfg.args,
+                cwd: cfg.cwd,
+                systemPrompt: cfg.systemPrompt,
+            });
+        case 'hermes':
+            return new HermesAdapter({
+                command: cfg.command,
+                args: cfg.args,
+                cwd: cfg.cwd,
+                systemPrompt: cfg.systemPrompt,
+            });
+        default:
+            throw new Error(`adapter '${cfg.kind}' not yet implemented`);
+    }
+}

package/dist/adapters/hermes.js

@@ -1,4 +1,20 @@
 import { spawn } from 'node:child_process';
+function runtimeArgs(args = []) {
+    if (args[0] === 'gateway' && args[1] === 'run') {
+        return args.slice(2);
+    }
+    return args;
+}
+function buildArgs(baseArgs, prompt) {
+    // If user already configured args with chat -q, just append the prompt
+    // Otherwise default to: hermes chat -q "<prompt>"
+    const hasChat = baseArgs.includes('chat');
+    const hasQ = baseArgs.includes('-q');
+    if (hasChat && hasQ) {
+        return [...baseArgs, prompt];
+    }
+    return [...baseArgs, 'chat', '-q', prompt];
+}
 function buildPrompt(input, systemPrompt) {
     const parts = [];
     if (systemPrompt)
@@ -19,7 +35,7 @@ export class HermesAdapter {
         return new Promise((resolve, reject) => {
             const prompt = buildPrompt(input, this.opts.systemPrompt ?? input.systemPrompt);
             const cwd = input.workspace ?? this.opts.cwd ?? process.cwd();
-            const child = spawn(this.opts.command, ['-z', prompt, ...(this.opts.args ?? [])], {
+            const child = spawn(this.opts.command, buildArgs(runtimeArgs(this.opts.args), prompt), {
                 cwd,
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
@@ -63,10 +79,17 @@ export class HermesAdapter {
                     return reject(new Error('aborted'));
                 const out = Buffer.concat(stdoutChunks).toString('utf8');
                 const err = Buffer.concat(stderrChunks).toString('utf8');
-                if (code !== 0 && out.length === 0) {
-                    return reject(new Error(`hermes exit ${code}: ${err.slice(0, 400)}`));
+                const stdout = out.trim();
+                const stderr = err.trim();
+                if (code !== 0 && stdout.length === 0) {
+                    const detail = stderr.length > 0 ? stderr.slice(0, 400) : 'no stderr';
+                    return reject(new Error(`hermes exit ${code}: ${detail}`));
+                }
+                const reply = stdout || stderr;
+                if (!reply) {
+                    return reject(new Error('hermes produced empty output'));
                 }
-                resolve(out.trim() || err.trim());
+                resolve(reply);
             });
         });
     }

package/dist/adapters/openclaw.js

@@ -1,4 +1,24 @@
 import { spawn } from 'node:child_process';
+function buildArgs(baseArgs, prompt) {
+    // If user already configured args with chat send --message, just append the prompt
+    // Otherwise default to: openclaw chat send --message "<prompt>"
+    const hasSend = baseArgs.includes('send');
+    const hasMessage = baseArgs.includes('--message');
+    if (hasSend && hasMessage) {
+        return [...baseArgs, prompt];
+    }
+    return [...baseArgs, 'chat', 'send', '--message', prompt];
+}
+function buildPrompt(input, systemPrompt) {
+    const parts = [];
+    if (systemPrompt)
+        parts.push(systemPrompt);
+    for (const h of input.history.slice(-10)) {
+        parts.push(`${h.speaker} (${h.role}): ${h.body}`);
+    }
+    parts.push(input.prompt);
+    return parts.join('\n\n---\n\n');
+}
 export class OpenClawAdapter {
     opts;
     kind = 'openclaw';
@@ -7,31 +27,37 @@ export class OpenClawAdapter {
     }
     async ask(input, signal) {
         return new Promise((resolve, reject) => {
-            const payload = JSON.stringify({
-                system: this.opts.systemPrompt ?? input.systemPrompt,
-                history: input.history.slice(-10),
-                user: input.prompt,
-            });
-            const child = spawn(this.opts.command, this.opts.args ?? [], {
-                cwd: this.opts.cwd,
-                stdio: ['pipe', 'pipe', 'pipe'],
+            const prompt = buildPrompt(input, this.opts.systemPrompt ?? input.systemPrompt);
+            const cwd = input.workspace ?? this.opts.cwd ?? process.cwd();
+            const child = spawn(this.opts.command, buildArgs(this.opts.args ?? [], prompt), {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
             });
             const stdoutChunks = [];
             const stderrChunks = [];
+            let finished = false;
             const MAX_EXEC_MS = 600_000;
             const onAbort = () => {
+                if (finished)
+                    return;
+                finished = true;
                 child.kill('SIGTERM');
-                setTimeout(() => child.kill('SIGKILL'), 2_000).unref();
+                setTimeout(() => { try {
+                    child.kill('SIGKILL');
+                }
+                catch { } }, 2_000).unref();
             };
             signal.addEventListener('abort', onAbort);
             const maxTimer = setTimeout(() => {
+                if (finished)
+                    return;
+                finished = true;
                 child.kill('SIGKILL');
                 signal.removeEventListener('abort', onAbort);
                 reject(new Error('openclaw adapter timeout'));
             }, MAX_EXEC_MS).unref();
             child.stdout.on('data', (b) => stdoutChunks.push(b));
             child.stderr.on('data', (b) => stderrChunks.push(b));
-            child.stdin.end(payload);
             child.on('error', (err) => {
                 clearTimeout(maxTimer);
                 signal.removeEventListener('abort', onAbort);
@@ -40,23 +66,24 @@ export class OpenClawAdapter {
             child.on('exit', (code) => {
                 clearTimeout(maxTimer);
                 signal.removeEventListener('abort', onAbort);
+                if (finished)
+                    return;
+                finished = true;
                 if (signal.aborted)
                     return reject(new Error('aborted'));
                 const out = Buffer.concat(stdoutChunks).toString('utf8');
                 const err = Buffer.concat(stderrChunks).toString('utf8');
-                if (code !== 0) {
-                    return reject(new Error(`openclaw exit ${code}: ${err.slice(0, 400)}`));
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(out);
+                const stdout = out.trim();
+                const stderr = err.trim();
+                if (code !== 0 && stdout.length === 0) {
+                    const detail = stderr.length > 0 ? stderr.slice(0, 400) : 'no stderr';
+                    return reject(new Error(`openclaw exit ${code}: ${detail}`));
                 }
-                catch {
-                    return reject(new Error(`openclaw produced non-JSON output: ${out.slice(0, 200)}`));
+                const reply = stdout || stderr;
+                if (!reply) {
+                    return reject(new Error('openclaw produced empty output'));
                 }
-                if (parsed.error)
-                    return reject(new Error(parsed.error));
-                resolve((parsed.reply ?? '').trim());
+                resolve(reply);
             });
         });
     }

package/dist/agent-instance.js

@@ -2,6 +2,19 @@ import { logger } from './log.js';
 import { uploadArtifact } from './uploader.js';
 import { postProcess } from './post-process.js';
 import { generateSandboxProfile, getWorkspaceDir, isSandboxAvailable } from './sandbox.js';
+function errorMessage(err) {
+    if (err instanceof Error && err.message)
+        return err.message;
+    if (typeof err === 'string' && err.trim())
+        return err;
+    try {
+        const serialized = JSON.stringify(err);
+        if (serialized && serialized !== '{}')
+            return serialized;
+    }
+    catch { }
+    return 'unknown error';
+}
 export class AgentInstance {
     config;
     adapter;
@@ -71,11 +84,12 @@ export class AgentInstance {
             });
         }
         catch (err) {
-            logger.error({ err: err.message, requestId: req.requestId, agentId: this.id }, 'dispatch failed');
+            const message = errorMessage(err);
+            logger.error({ err: message, requestId: req.requestId, agentId: this.id }, 'dispatch failed');
             socket.emit('error_event', {
                 agentId: this.id,
                 at: Date.now(),
-                message: err.message ?? 'unknown',
+                message,
                 scope: 'reply',
                 requestId: req.requestId,
             });

package/dist/config.js

@@ -46,9 +46,8 @@ export function loadConfig(path) {
         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)
+        'agentos-hosted';
+    const category = typeof interp.category === 'string' && ['executor-hosted', 'agentos-hosted'].includes(interp.category)
         ? interp.category
         : inferredCategory;
     return {
@@ -106,9 +105,8 @@ export function loadDeviceConfig(path) {
             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)
+            'agentos-hosted';
+        const category = typeof a.category === 'string' && ['executor-hosted', 'agentos-hosted'].includes(a.category)
             ? a.category
             : inferredCategory;
         parsedAgents.push({

package/dist/connection.js

@@ -2,6 +2,19 @@ import { io } from 'socket.io-client';
 import { logger } from './log.js';
 import { uploadArtifact } from './uploader.js';
 import { postProcess } from './post-process.js';
+function errorMessage(err) {
+    if (err instanceof Error && err.message)
+        return err.message;
+    if (typeof err === 'string' && err.trim())
+        return err;
+    try {
+        const serialized = JSON.stringify(err);
+        if (serialized && serialized !== '{}')
+            return serialized;
+    }
+    catch { }
+    return 'unknown error';
+}
 export function createConnection(cfg, adapter) {
     let socket = null;
     let heartbeatTimer = null;
@@ -81,10 +94,11 @@ export function createConnection(cfg, adapter) {
                         });
                     }
                     catch (err) {
-                        logger.error({ err: err.message, requestId: req.requestId }, 'dispatch failed');
+                        const message = errorMessage(err);
+                        logger.error({ err: message, requestId: req.requestId }, 'dispatch failed');
                         currentSocket.emit('error_event', {
                             at: Date.now(),
-                            message: err.message ?? 'unknown',
+                            message,
                             scope: 'reply',
                             requestId: req.requestId,
                         });

package/dist/device-daemon.js

@@ -3,24 +3,73 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { logger } from './log.js';
+import { AgentInstance } from './agent-instance.js';
+import { pickAdapter } from './adapters/factory.js';
 import { scanRuntimes, scanAgentOSAgents, scanLocalAgents, collectSystemInfo } from './scanner.js';
+function errorMessage(err) {
+    if (err instanceof Error && err.message)
+        return err.message;
+    if (typeof err === 'string' && err.trim())
+        return err;
+    try {
+        const serialized = JSON.stringify(err);
+        if (serialized && serialized !== '{}')
+            return serialized;
+    }
+    catch { }
+    return 'unknown error';
+}
+function agentSlug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function scannedAgentId(deviceId, name) {
+    return `scan-${deviceId}-${agentSlug(name)}`;
+}
 const CACHE_DIR = join(homedir(), '.agentbean');
 const CACHE_FILE = join(CACHE_DIR, 'scanned-agents.json');
+function isRuntimeEntry(entry) {
+    return entry.category === 'executor-hosted' &&
+        ['codex', 'claude-code', 'kimi-cli', 'Kimi-cli'].includes(entry.adapterKind);
+}
+function splitLegacyCache(entries) {
+    const agents = [];
+    const runtimes = [];
+    for (const entry of entries) {
+        if (isRuntimeEntry(entry)) {
+            runtimes.push({
+                name: entry.name,
+                adapterKind: entry.adapterKind,
+                command: entry.command,
+                installed: Boolean(entry.command),
+            });
+        }
+        else {
+            agents.push(entry);
+        }
+    }
+    return { agents, runtimes };
+}
 function loadCache() {
     try {
         if (!existsSync(CACHE_FILE))
             return null;
-        return JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+        const parsed = JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+        if (Array.isArray(parsed))
+            return splitLegacyCache(parsed);
+        return {
+            agents: parsed.agents ?? [],
+            runtimes: parsed.runtimes ?? [],
+        };
     }
     catch {
         return null;
     }
 }
-function saveCache(agents) {
+function saveCache(payload) {
     try {
         if (!existsSync(CACHE_DIR))
             mkdirSync(CACHE_DIR, { recursive: true });
-        writeFileSync(CACHE_FILE, JSON.stringify(agents, null, 2));
+        writeFileSync(CACHE_FILE, JSON.stringify(payload, null, 2));
     }
     catch (err) {
         logger.warn({ err: err?.message }, 'failed to save scan cache');
@@ -32,39 +81,29 @@ async function scanAll() {
         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',
-            });
-        }
-    }
+    const agents = [];
+    const runtimeResults = runtimes.filter((rt) => rt.installed);
     // 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' });
+            agents.push({ ...ag, source: 'scanned' });
         }
     }
     for (const ag of local) {
         if (!seen.has(ag.command)) {
             seen.add(ag.command);
-            results.push({ ...ag, source: 'scanned' });
+            agents.push({ ...ag, source: 'scanned' });
         }
     }
-    return results;
+    return { agents, runtimes: runtimeResults };
 }
 export function createDeviceDaemon(cfg, agents) {
     let socket = null;
     let heartbeatTimer = null;
+    let rescanTimer = null;
+    const RESCAN_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
     const queues = new Map();
     const httpBase = cfg.server.url.replace(/\/agent$/, '');
     let firstConnect = true;
@@ -72,10 +111,41 @@ export function createDeviceDaemon(cfg, agents) {
     const publicAgents = Array.from(agents.values())
         .filter((a) => a.visibility === 'public')
         .map((a) => a.publicMeta);
-    function emitRegister(sock, scanned) {
-        if (scanned.length === 0)
+    function emitRegister(sock, payload) {
+        if (payload.runtimes.length > 0) {
+            sock.emit('device:register-runtimes', { runtimes: payload.runtimes }, (ack) => {
+                if (!ack?.ok)
+                    logger.warn({ error: ack?.error }, 'failed to register runtimes');
+            });
+        }
+        if (payload.agents.length === 0)
             return;
-        sock.emit('device:register-agents', { agents: scanned }, (ack) => {
+        for (const ag of payload.agents) {
+            const id = scannedAgentId(cfg.deviceId, ag.name);
+            if (agents.has(id))
+                continue;
+            const entry = {
+                id,
+                name: ag.name,
+                role: ag.category === 'executor-hosted' ? 'executor-agent' : 'gateway-agent',
+                category: ag.category,
+                adapter: {
+                    kind: ag.adapterKind,
+                    command: ag.command,
+                    args: ag.args ?? [],
+                    cwd: ag.cwd,
+                },
+                visibility: 'public',
+            };
+            try {
+                agents.set(id, new AgentInstance(entry, pickAdapter(entry.adapter)));
+                logger.info({ id, kind: entry.adapter.kind }, 'scanned agent instance created');
+            }
+            catch (err) {
+                logger.warn({ id, err: errorMessage(err) }, 'failed to create scanned agent instance');
+            }
+        }
+        sock.emit('device:register-agents', { agents: payload.agents }, (ack) => {
             if (ack?.ok) {
                 logger.info({ count: ack.agents?.length }, 'scanned agents registered');
             }
@@ -88,15 +158,21 @@ export function createDeviceDaemon(cfg, agents) {
         if (useCache) {
             const cached = loadCache();
             if (cached) {
-                logger.info({ count: cached.length }, 'using cached scan results');
+                logger.info({ count: cached.agents.length + cached.runtimes.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());
+                    const cachedKey = JSON.stringify([
+                        ...cached.agents.map((a) => a.command),
+                        ...cached.runtimes.map((rt) => rt.command),
+                    ].sort());
+                    const freshKey = JSON.stringify([
+                        ...fresh.agents.map((a) => a.command),
+                        ...fresh.runtimes.map((rt) => rt.command),
+                    ].sort());
                     if (cachedKey !== freshKey) {
-                        logger.info({ count: fresh.length }, 'scan results changed, updating');
+                        logger.info({ count: fresh.agents.length + fresh.runtimes.length }, 'scan results changed, updating');
                         emitRegister(sock, fresh);
                     }
                 }).catch((err) => {
@@ -145,6 +221,14 @@ export function createDeviceDaemon(cfg, agents) {
                 heartbeatTimer = setInterval(() => {
                     socket?.emit('heartbeat');
                 }, cfg.heartbeatIntervalMs);
+                // Periodic re-scan to update agent availability
+                if (rescanTimer)
+                    clearInterval(rescanTimer);
+                rescanTimer = setInterval(() => {
+                    if (!socket?.connected)
+                        return;
+                    scanAndRegister(socket, false);
+                }, RESCAN_INTERVAL_MS);
             });
             socket.on('connect_error', (err) => {
                 logger.error({ err: err.message }, 'connect_error');
@@ -178,11 +262,12 @@ export function createDeviceDaemon(cfg, agents) {
                         networkId: cfg.networkId,
                     });
                 }).catch((err) => {
-                    logger.error({ err: err?.message, agentId: req.agentId }, 'dispatch queue error');
+                    const message = errorMessage(err);
+                    logger.error({ err: message, agentId: req.agentId }, 'dispatch queue error');
                     currentSocket.emit('error_event', {
                         agentId: req.agentId,
                         at: Date.now(),
-                        message: err?.message ?? 'unknown',
+                        message,
                         scope: 'reply',
                         requestId: req.requestId,
                     });
@@ -198,6 +283,10 @@ export function createDeviceDaemon(cfg, agents) {
                     clearInterval(heartbeatTimer);
                     heartbeatTimer = null;
                 }
+                if (rescanTimer) {
+                    clearInterval(rescanTimer);
+                    rescanTimer = null;
+                }
             });
         },
         async stop() {
@@ -205,6 +294,10 @@ export function createDeviceDaemon(cfg, agents) {
                 clearInterval(heartbeatTimer);
                 heartbeatTimer = null;
             }
+            if (rescanTimer) {
+                clearInterval(rescanTimer);
+                rescanTimer = null;
+            }
             socket?.close();
             socket = null;
         },

package/dist/index.js

@@ -3,48 +3,11 @@ import { loadConfig, loadDeviceConfig } from './config.js';
 import { createConnection } from './connection.js';
 import { createDeviceDaemon } from './device-daemon.js';
 import { AgentInstance } from './agent-instance.js';
-import { CodexAdapter } from './adapters/codex.js';
-import { ClaudeCodeAdapter } from './adapters/claude-code.js';
-import { OpenClawAdapter } from './adapters/openclaw.js';
-import { HermesAdapter } from './adapters/hermes.js';
+import { pickAdapter } from './adapters/factory.js';
 import { logger } from './log.js';
 import { scanRuntimes, scanAgentOSAgents, scanLocalAgents, getDeviceId } from './scanner.js';
 import { loadAuth, saveAuth } from './auth-store.js';
-function pickAdapter(cfg) {
-    switch (cfg.kind) {
-        case 'codex':
-            return new CodexAdapter({
-                command: cfg.command,
-                args: cfg.args,
-                cwd: cfg.cwd,
-                systemPrompt: cfg.systemPrompt,
-            });
-        case 'claude-code':
-            return new ClaudeCodeAdapter({
-                command: cfg.command,
-                args: cfg.args,
-                cwd: cfg.cwd,
-                systemPrompt: cfg.systemPrompt,
-            });
-        case 'openclaw':
-            return new OpenClawAdapter({
-                command: cfg.command,
-                args: cfg.args,
-                cwd: cfg.cwd,
-                systemPrompt: cfg.systemPrompt,
-            });
-        case 'hermes':
-            return new HermesAdapter({
-                command: cfg.command,
-                args: cfg.args,
-                cwd: cfg.cwd,
-                systemPrompt: cfg.systemPrompt,
-            });
-        default:
-            throw new Error(`adapter '${cfg.kind}' not yet implemented`);
-    }
-}
-async function discoverAgents() {
+async function discoverAgents(deviceId) {
     const [_runtimes, agentos, local] = await Promise.all([
         scanRuntimes(),
         scanAgentOSAgents(),
@@ -56,11 +19,10 @@ async function discoverAgents() {
         if (seen.has(s.command))
             continue;
         seen.add(s.command);
-        const id = s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
         results.push({
-            id,
+            id: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
             name: s.name,
-            role: s.category === 'executor-hosted' ? 'executor-agent' : s.category === 'agentos-hosted' ? 'gateway-agent' : 'standalone-agent',
+            role: s.category === 'executor-hosted' ? 'executor-agent' : 'gateway-agent',
             category: s.category,
             adapter: {
                 kind: s.adapterKind,
@@ -102,10 +64,6 @@ async function runDeviceMode(cfgPath) {
         const shouldScan = err.message?.includes('agents array is required');
         if (!shouldScan)
             throw err;
-        scannedEntries = await discoverAgents();
-        if (scannedEntries.length === 0) {
-            throw new Error('device config missing and no agents discovered via scanning');
-        }
         let fileSettings = {};
         try {
             const { readFileSync } = await import('node:fs');
@@ -119,8 +77,13 @@ async function runDeviceMode(cfgPath) {
             };
         }
         catch { /* ignore */ }
+        const deviceId = fileSettings.deviceId ?? process.env.DEVICE_ID ?? await getDeviceId();
+        scannedEntries = await discoverAgents(deviceId);
+        if (scannedEntries.length === 0) {
+            throw new Error('device config missing and no agents discovered via scanning');
+        }
         cfg = {
-            deviceId: fileSettings.deviceId ?? process.env.DEVICE_ID ?? await getDeviceId(),
+            deviceId,
             networkId: fileSettings.networkId ?? process.env.NETWORK_ID ?? 'default',
             server: fileSettings.server ?? {
                 url: process.env.SERVER_URL ?? 'http://localhost:3000/agent',
@@ -131,7 +94,7 @@ async function runDeviceMode(cfgPath) {
         };
     }
     if (cfg.scan === true) {
-        scannedEntries = await discoverAgents();
+        scannedEntries = await discoverAgents(cfg.deviceId);
         if (scannedEntries.length > 0) {
             cfg = { ...cfg, agents: scannedEntries };
         }
@@ -203,7 +166,7 @@ Options:
     }
     const deviceId = values['device-id'] ?? await getDeviceId();
     logger.info({ serverUrl, deviceId, networkId }, 'CLI mode: auto-discovering agents');
-    const agents = await discoverAgents();
+    const agents = await discoverAgents(deviceId);
     if (agents.length === 0) {
         logger.warn('no agents discovered on this machine. Daemon will start with no agents.');
     }

package/dist/scanner.js

@@ -1,12 +1,17 @@
-import { execFile } from 'node:child_process';
-import { readdirSync, readFileSync, statSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import * as os from 'node:os';
-import { logger } from './log.js';
+import { execFile } from "node:child_process";
+import { readdirSync, readFileSync, statSync, existsSync, writeFileSync, mkdirSync, } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import * as os from "node:os";
+import { logger } from "./log.js";
 function which(bin) {
     return new Promise((resolve) => {
-        const child = execFile('which', [bin], { timeout: 5_000 }, (err, stdout) => {
+        const child = execFile('which', [bin], { timeout: 5_000, env: { ...process.env, PATH: [
+                    process.env.PATH,
+                    '/usr/local/bin',
+                    '/opt/homebrew/bin',
+                    join(os.homedir(), '.nvm/versions/node', ...getAllNodeVersions(), 'bin'),
+                ].filter(Boolean).join(':') } }, (err, stdout) => {
             if (err) {
                 resolve(null);
                 return;
@@ -17,16 +22,27 @@ function which(bin) {
         child.on('error', () => resolve(null));
     });
 }
+function getAllNodeVersions() {
+    try {
+        const nvmDir = join(os.homedir(), '.nvm/versions/node');
+        if (!existsSync(nvmDir))
+            return [];
+        return readdirSync(nvmDir);
+    }
+    catch {
+        return [];
+    }
+}
 function run(bin, args) {
     return new Promise((resolve) => {
         const child = execFile(bin, args, { timeout: 10_000 }, (err, stdout) => {
-            resolve(stdout?.trim() ?? '');
+            resolve(stdout?.trim() ?? "");
         });
-        child.on('error', () => resolve(''));
+        child.on("error", () => resolve(""));
     });
 }
 // --- Machine ID (stable per-device identifier) ---
-const MACHINE_ID_FILE = join(os.homedir(), '.agentbean', 'device-id');
+const MACHINE_ID_FILE = join(os.homedir(), ".agentbean", "device-id");
 function getFirstMacAddress() {
     const ifaces = os.networkInterfaces();
     for (const [name, addrs] of Object.entries(ifaces)) {
@@ -36,7 +52,7 @@ function getFirstMacAddress() {
             // Skip internal (loopback) and zero MAC
             if (addr.internal)
                 continue;
-            if (addr.mac === '00:00:00:00:00:00')
+            if (addr.mac === "00:00:00:00:00:00")
                 continue;
             return addr.mac;
         }
@@ -46,19 +62,28 @@ function getFirstMacAddress() {
 async function readPlatformMachineId() {
     const platform = os.platform();
     try {
-        if (platform === 'linux') {
-            if (existsSync('/etc/machine-id')) {
-                return readFileSync('/etc/machine-id', 'utf-8').trim() || null;
+        if (platform === "linux") {
+            if (existsSync("/etc/machine-id")) {
+                return readFileSync("/etc/machine-id", "utf-8").trim() || null;
             }
         }
-        else if (platform === 'darwin') {
-            const output = await run('ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice']);
+        else if (platform === "darwin") {
+            const output = await run("ioreg", [
+                "-rd1",
+                "-c",
+                "IOPlatformExpertDevice",
+            ]);
             const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
             if (match)
                 return match[1] ?? null;
         }
-        else if (platform === 'win32') {
-            const output = await run('reg', ['query', 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid']);
+        else if (platform === "win32") {
+            const output = await run("reg", [
+                "query",
+                "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography",
+                "/v",
+                "MachineGuid",
+            ]);
             const match = output.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
             if (match)
                 return match[1] ?? null;
@@ -77,7 +102,7 @@ async function readPlatformMachineId() {
 export async function getDeviceId() {
     // 1. Read cached ID
     if (existsSync(MACHINE_ID_FILE)) {
-        const cached = readFileSync(MACHINE_ID_FILE, 'utf-8').trim();
+        const cached = readFileSync(MACHINE_ID_FILE, "utf-8").trim();
         if (cached)
             return cached;
     }
@@ -95,7 +120,7 @@ export async function getDeviceId() {
     let deviceId;
     if (parts.length > 2) {
         // We have enough hardware info — generate deterministic ID
-        const hash = createHash('sha256').update(parts.join('|')).digest('hex');
+        const hash = createHash("sha256").update(parts.join("|")).digest("hex");
         // Format as UUID: 8-4-4-4-12
         deviceId = [
             hash.slice(0, 8),
@@ -103,16 +128,16 @@ export async function getDeviceId() {
             hash.slice(12, 16),
             hash.slice(16, 20),
             hash.slice(20, 32),
-        ].join('-');
+        ].join("-");
     }
     else {
         // Fallback: random UUID
-        const { randomUUID } = await import('node:crypto');
+        const { randomUUID } = await import("node:crypto");
         deviceId = randomUUID();
     }
     // 3. Cache to file
     try {
-        const dir = join(os.homedir(), '.agentbean');
+        const dir = join(os.homedir(), ".agentbean");
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         writeFileSync(MACHINE_ID_FILE, deviceId);
@@ -125,19 +150,25 @@ export async function getDeviceId() {
 // --- Scan Coding Agent Runtimes (Claude Code, Codex, Kimi) ---
 export async function scanRuntimes() {
     const checks = [
-        { bin: 'claude', name: 'Claude Code', adapterKind: 'claude-code' },
-        { bin: 'codex', name: 'Codex CLI', adapterKind: 'codex' },
-        { bin: 'kimi-cli', name: 'Kimi CLI', adapterKind: 'codex' },
-        { bin: 'manus', name: 'Manus', adapterKind: 'standalone' },
-        { bin: 'anygen', name: 'Anygen', adapterKind: 'standalone' },
+        {
+            bin: "claude",
+            name: "Claude Code",
+            adapterKind: "claude-code",
+        },
+        { bin: "codex", name: "Codex CLI", adapterKind: "codex" },
+        {
+            bin: "kimi-cli",
+            name: "Kimi CLI",
+            adapterKind: "Kimi-cli",
+        },
     ];
     const results = [];
     for (const s of checks) {
         const path = await which(s.bin);
         results.push({
-            name: s.name,
+            name: s.name.replace(/\s+/g, "-"),
             adapterKind: s.adapterKind,
-            command: path ?? '',
+            command: path ?? "",
             installed: path !== null,
         });
     }
@@ -145,37 +176,37 @@ export async function scanRuntimes() {
 }
 // --- Scan AgentOS Gateways (Hermes, OpenClaw) ---
 async function checkHermesGateway() {
-    const path = await which('hermes');
+    const path = await which("hermes");
     if (!path)
         return null;
-    const status = await run('hermes', ['gateway', 'status']);
-    const running = status.includes('running') || status.includes('✓');
+    const status = await run("hermes", ["gateway", "status"]);
+    const running = status.includes("running") || status.includes("✓");
     if (running) {
         return {
-            category: 'agentos-hosted',
-            name: 'Hermes Agent',
-            adapterKind: 'hermes',
+            category: "agentos-hosted",
+            name: "Hermes-Agent",
+            adapterKind: "hermes",
             command: path,
-            args: ['gateway', 'run'],
-            source: 'gateway',
+            args: [],
+            source: "gateway",
         };
     }
     return null;
 }
 async function checkOpenClawGateway() {
-    const path = await which('openclaw');
+    const path = await which("openclaw");
     if (!path)
         return null;
-    const status = await run('openclaw', ['gateway', 'status']);
-    const running = status.includes('running') || status.includes('✓');
+    const status = await run("openclaw", ["gateway", "status"]);
+    const running = status.includes("running") || status.includes("✓");
     if (running) {
         return {
-            category: 'agentos-hosted',
-            name: 'OpenClaw Agent',
-            adapterKind: 'openclaw',
+            category: "agentos-hosted",
+            name: "OpenClaw-Agent",
+            adapterKind: "openclaw",
             command: path,
-            args: ['gateway', 'run'],
-            source: 'gateway',
+            args: ["gateway", "run"],
+            source: "gateway",
         };
     }
     return null;
@@ -188,7 +219,7 @@ export async function scanAgentOSAgents() {
     return [hermes, openclaw].filter((a) => a !== null);
 }
 // --- Scan local agent definitions from filesystem ---
-export async function scanLocalAgents(scanDir = join(os.homedir(), '.agentbean', 'agents')) {
+export async function scanLocalAgents(scanDir = join(os.homedir(), ".agentbean", "agents")) {
     if (!existsSync(scanDir)) {
         return [];
     }
@@ -198,7 +229,7 @@ export async function scanLocalAgents(scanDir = join(os.homedir(), '.agentbean',
         entries = readdirSync(scanDir);
     }
     catch (err) {
-        logger?.warn?.({ err: err?.message }, 'scan failed');
+        logger?.warn?.({ err: err?.message }, "scan failed");
         return [];
     }
     for (const entry of entries) {
@@ -212,63 +243,67 @@ export async function scanLocalAgents(scanDir = join(os.homedir(), '.agentbean',
         }
         if (!st.isDirectory())
             continue;
-        const jsonPath = join(subdir, 'agent.json');
-        const yamlPath = join(subdir, 'agent.yaml');
-        const ymlPath = join(subdir, 'agent.yml');
+        const jsonPath = join(subdir, "agent.json");
+        const yamlPath = join(subdir, "agent.yaml");
+        const ymlPath = join(subdir, "agent.yml");
         let raw = null;
         let ext = null;
         if (existsSync(jsonPath)) {
-            raw = readFileSync(jsonPath, 'utf8');
-            ext = 'json';
+            raw = readFileSync(jsonPath, "utf8");
+            ext = "json";
         }
         else if (existsSync(yamlPath)) {
-            raw = readFileSync(yamlPath, 'utf8');
-            ext = 'yaml';
+            raw = readFileSync(yamlPath, "utf8");
+            ext = "yaml";
         }
         else if (existsSync(ymlPath)) {
-            raw = readFileSync(ymlPath, 'utf8');
-            ext = 'yaml';
+            raw = readFileSync(ymlPath, "utf8");
+            ext = "yaml";
         }
         if (raw === null || ext === null)
             continue;
         let parsed = null;
         try {
-            if (ext === 'json') {
+            if (ext === "json") {
                 parsed = JSON.parse(raw);
             }
             else {
-                const { load: parseYaml } = await import('js-yaml');
+                const { load: parseYaml } = await import("js-yaml");
                 parsed = parseYaml(raw);
             }
         }
         catch {
             continue;
         }
-        if (!parsed || typeof parsed !== 'object')
+        if (!parsed || typeof parsed !== "object")
             continue;
-        const name = typeof parsed.name === 'string' ? parsed.name : entry;
-        const command = typeof parsed.command === 'string' ? parsed.command : '';
-        const args = Array.isArray(parsed.args) ? parsed.args.map(String) : [];
+        const name = (typeof parsed.name === "string" ? parsed.name : entry).replace(/\s+/g, "-");
+        const command = typeof parsed.command === "string" ? parsed.command : "";
+        const args = Array.isArray(parsed.args)
+            ? parsed.args.map(String)
+            : [];
         let category;
-        if (typeof parsed.category === 'string' && ['executor-hosted', 'agentos-hosted', 'standalone-cli'].includes(parsed.category)) {
+        if (typeof parsed.category === "string" &&
+            ["executor-hosted", "agentos-hosted"].includes(parsed.category)) {
             category = parsed.category;
         }
-        else if ('executor' in parsed) {
-            category = 'executor-hosted';
+        else if ("executor" in parsed) {
+            category = "executor-hosted";
         }
         else {
-            category = 'standalone-cli';
+            category = "executor-hosted";
         }
-        const adapterKind = typeof parsed.adapterKind === 'string' && ['codex', 'claude-code', 'openclaw', 'hermes', 'standalone'].includes(parsed.adapterKind)
+        const adapterKind = typeof parsed.adapterKind === "string" &&
+            ["codex", "claude-code", "openclaw", "hermes"].includes(parsed.adapterKind)
             ? parsed.adapterKind
-            : 'standalone';
+            : "codex";
         results.push({
             category,
             name,
             adapterKind,
             command,
             args,
-            source: 'filesystem',
+            source: "filesystem",
         });
     }
     return results;
@@ -279,7 +314,7 @@ export function collectSystemInfo() {
     const cpus = os.cpus();
     const platform = os.platform();
     let osVersion = `${os.type()} ${os.release()}`;
-    if (platform === 'darwin') {
+    if (platform === "darwin") {
         osVersion = `macOS ${os.release()}`;
     }
     return {
@@ -287,10 +322,10 @@ export function collectSystemInfo() {
         arch: os.arch(),
         osVersion,
         hostname: os.hostname(),
-        cpuModel: cpus[0]?.model ?? 'unknown',
+        cpuModel: cpus[0]?.model ?? "unknown",
         cpuCores: cpus.length,
-        totalMemoryGB: Math.round(totalMem / 1024 / 1024 / 1024 * 10) / 10,
-        freeMemoryGB: Math.round(freeMem / 1024 / 1024 / 1024 * 10) / 10,
+        totalMemoryGB: Math.round((totalMem / 1024 / 1024 / 1024) * 10) / 10,
+        freeMemoryGB: Math.round((freeMem / 1024 / 1024 / 1024) * 10) / 10,
         nodeVersion: process.version,
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentbean/daemon",
   "private": false,
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {