@agentbean/daemon 0.1.0

package/dist/index.js

@@ -0,0 +1,302 @@
+import { parseArgs } from 'node:util';
+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 { 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() {
+    const [_runtimes, agentos, local] = await Promise.all([
+        scanRuntimes(),
+        scanAgentOSAgents(),
+        scanLocalAgents(),
+    ]);
+    const seen = new Set();
+    const results = [];
+    for (const s of [...agentos, ...local]) {
+        if (seen.has(s.command))
+            continue;
+        seen.add(s.command);
+        const id = s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+        results.push({
+            id,
+            name: s.name,
+            role: s.category === 'executor-hosted' ? 'executor-agent' : s.category === 'agentos-hosted' ? 'gateway-agent' : 'standalone-agent',
+            category: s.category,
+            adapter: {
+                kind: s.adapterKind,
+                command: s.command,
+                args: s.args,
+            },
+            visibility: 'public',
+        });
+    }
+    logger.info({ discovered: results.map((r) => r.name) }, 'agents discovered via scanning');
+    return results;
+}
+async function startDeviceDaemon(cfg) {
+    const agents = new Map();
+    for (const entry of cfg.agents) {
+        const adapter = pickAdapter(entry.adapter);
+        const instance = new AgentInstance(entry, adapter);
+        agents.set(entry.id, instance);
+        logger.info({ id: entry.id, kind: entry.adapter.kind, visibility: entry.visibility }, 'agent instance created');
+    }
+    logger.info({ deviceId: cfg.deviceId, agentCount: agents.size }, 'device daemon starting');
+    const daemon = createDeviceDaemon(cfg, agents);
+    await daemon.start();
+    const shutdown = async (signal) => {
+        logger.info({ signal }, 'shutting down device daemon');
+        await daemon.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+async function runDeviceMode(cfgPath) {
+    let cfg;
+    let scannedEntries;
+    try {
+        cfg = loadDeviceConfig(cfgPath);
+    }
+    catch (err) {
+        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');
+            const { load: parseYaml } = await import('js-yaml');
+            const raw = parseYaml(readFileSync(cfgPath, 'utf8'));
+            fileSettings = {
+                deviceId: raw.deviceId,
+                networkId: raw.networkId,
+                server: raw.server,
+                heartbeatIntervalMs: raw.heartbeatIntervalMs,
+            };
+        }
+        catch { /* ignore */ }
+        cfg = {
+            deviceId: fileSettings.deviceId ?? process.env.DEVICE_ID ?? await getDeviceId(),
+            networkId: fileSettings.networkId ?? process.env.NETWORK_ID ?? 'default',
+            server: fileSettings.server ?? {
+                url: process.env.SERVER_URL ?? 'http://localhost:3000/agent',
+                token: process.env.SERVER_TOKEN ?? '',
+            },
+            heartbeatIntervalMs: fileSettings.heartbeatIntervalMs ?? 10_000,
+            agents: scannedEntries,
+        };
+    }
+    if (cfg.scan === true) {
+        scannedEntries = await discoverAgents();
+        if (scannedEntries.length > 0) {
+            cfg = { ...cfg, agents: scannedEntries };
+        }
+    }
+    await startDeviceDaemon(cfg);
+}
+async function runSingleAgentMode(cfgPath) {
+    const cfg = loadConfig(cfgPath);
+    const adapter = pickAdapter(cfg.adapter);
+    logger.info({ id: cfg.id, kind: cfg.adapter.kind }, 'agent daemon starting (single-agent mode)');
+    const conn = createConnection(cfg, adapter);
+    await conn.start();
+    const shutdown = async (signal) => {
+        logger.info({ signal }, 'shutting down');
+        await conn.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+async function runCliMode() {
+    const { values } = parseArgs({
+        options: {
+            'server-url': { type: 'string' },
+            'token': { type: 'string' },
+            'invite': { type: 'string' },
+            'device-id': { type: 'string' },
+            'network-id': { type: 'string' },
+            'help': { type: 'boolean' },
+        },
+        strict: true,
+    });
+    if (values.help) {
+        console.log(`Usage: agentbean-daemon --server-url <url> --token <token> [--device-id <id>] [--network-id <id>]
+
+Options:
+  --server-url   AgentBean Server URL (required)
+  --token        Authentication token (required)
+  --device-id    Device ID (default: auto-detected from hardware)
+  --network-id   Network ID (default: default)
+`);
+        process.exit(0);
+    }
+    let serverUrl = values['server-url'] ?? process.env.AGENT_BEAN_SERVER_URL;
+    let token = values['token'] ?? process.env.AGENT_BEAN_AGENT_TOKEN;
+    let networkId = values['network-id'] ?? 'default';
+    if (values.invite) {
+        if (!serverUrl) {
+            console.error('Error: --server-url is required with --invite.');
+            process.exit(1);
+        }
+        const auth = await runInviteMode(serverUrl, values.invite);
+        serverUrl = auth.serverUrl;
+        token = auth.token;
+        networkId = auth.networkId ?? networkId;
+    }
+    else if (!token) {
+        const saved = loadAuth();
+        if (saved) {
+            serverUrl = serverUrl ?? saved.serverUrl;
+            token = saved.token;
+            networkId = saved.networkId ?? networkId;
+        }
+    }
+    if (!serverUrl || !token) {
+        console.error('Error: --server-url and --token are required.');
+        console.error('Usage: agentbean-daemon --server-url <url> --token <token>');
+        process.exit(1);
+    }
+    const deviceId = values['device-id'] ?? await getDeviceId();
+    logger.info({ serverUrl, deviceId, networkId }, 'CLI mode: auto-discovering agents');
+    const agents = await discoverAgents();
+    if (agents.length === 0) {
+        logger.warn('no agents discovered on this machine. Daemon will start with no agents.');
+    }
+    const cfg = {
+        deviceId,
+        networkId,
+        server: { url: serverUrl, token },
+        heartbeatIntervalMs: 10_000,
+        agents,
+    };
+    await startDeviceDaemon(cfg);
+}
+function normalizeBaseUrl(serverUrl) {
+    return serverUrl.replace(/\/agent\/?$/, '').replace(/\/web\/?$/, '');
+}
+function normalizeAgentUrl(serverUrl) {
+    const base = normalizeBaseUrl(serverUrl);
+    return `${base}/agent`;
+}
+async function runInviteMode(serverUrl, inviteCode) {
+    const { io } = await import('socket.io-client');
+    const { execFile } = await import('node:child_process');
+    const baseUrl = normalizeBaseUrl(serverUrl);
+    const webSocketUrl = `${baseUrl}/web`;
+    logger.info({ serverUrl: baseUrl, inviteCode }, 'invite mode: connecting to server');
+    const socket = io(webSocketUrl, {
+        auth: { invite: true },
+        transports: ['websocket'],
+        reconnection: false,
+    });
+    return new Promise((resolve, reject) => {
+        const fail = (err) => {
+            socket.disconnect();
+            reject(err);
+        };
+        socket.on('connect_error', (err) => {
+            logger.error({ err: err.message }, 'invite mode: connection failed');
+            fail(new Error(`connection failed: ${err.message}`));
+        });
+        socket.on('connect', () => {
+            logger.info('invite mode: connected, validating invite code');
+            socket.emit('auth:invite:validate', { code: inviteCode }, (res) => {
+                if (!res?.ok) {
+                    fail(new Error(res?.error ?? 'invalid invite code'));
+                    return;
+                }
+                const registerUrl = res.registerUrl;
+                logger.info({ registerUrl }, 'invite mode: opening browser');
+                console.log(`\nOpen this URL to finish joining AgentBean:\n${registerUrl}\n`);
+                execFile('open', [registerUrl], (err) => {
+                    if (err) {
+                        logger.info({ registerUrl }, 'invite mode: could not open browser automatically');
+                    }
+                });
+                console.log('Waiting for registration to complete...');
+            });
+        });
+        socket.on('auth:token:deliver', (payload) => {
+            if (!payload?.token)
+                return;
+            const auth = {
+                token: payload.token,
+                serverUrl: normalizeAgentUrl(serverUrl),
+                userId: payload.userId,
+                networkId: payload.networkId,
+            };
+            saveAuth(auth);
+            logger.info({ networkId: auth.networkId }, 'invite mode: token received and saved');
+            console.log('Registration complete! Starting daemon...');
+            socket.disconnect();
+            resolve(auth);
+        });
+    });
+}
+export async function main() {
+    // Check for CLI flags first (npx mode)
+    const hasCliFlags = process.argv.some((a) => a === '--server-url' || a === '--token' || a === '--invite' || a === '--help');
+    if (hasCliFlags) {
+        await runCliMode();
+        return;
+    }
+    // Fallback: YAML config mode
+    const cfgPath = process.env.DEVICE_CONFIG ?? process.env.AGENT_CONFIG ?? './agent.config.yaml';
+    try {
+        await runDeviceMode(cfgPath);
+    }
+    catch (deviceErr) {
+        if (deviceErr.message?.includes('deviceId') || deviceErr.message?.includes('agents')) {
+            logger.info({ reason: deviceErr.message }, 'not a device config, falling back to single-agent mode');
+            await runSingleAgentMode(cfgPath);
+        }
+        else {
+            throw deviceErr;
+        }
+    }
+}

package/dist/log.js

@@ -0,0 +1,7 @@
+import pino from 'pino';
+export const logger = pino({
+    level: process.env.LOG_LEVEL ?? 'info',
+    transport: process.env.NODE_ENV === 'production'
+        ? undefined
+        : { target: 'pino-pretty', options: { colorize: true } },
+});

package/dist/post-process.js

@@ -0,0 +1,71 @@
+import { readdirSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { logger } from './log.js';
+const CODE_BLOCK_RE = /```python\n([\s\S]*?)```/g;
+const CODEX_IMG_DIR = join(homedir(), '.codex', 'generated_images');
+export function listAllFiles(dir, maxDepth = 10, depth = 0) {
+    if (!existsSync(dir) || depth > maxDepth)
+        return [];
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory())
+            results.push(...listAllFiles(full, maxDepth, depth + 1));
+        else
+            results.push(full);
+    }
+    return results;
+}
+export async function postProcess(reply, workspace, kind, dispatchStart) {
+    const outputFiles = [];
+    // Codex native image detection
+    if (kind === 'codex') {
+        const allCodexFiles = listAllFiles(CODEX_IMG_DIR);
+        for (const f of allCodexFiles) {
+            try {
+                const st = statSync(f);
+                if (st.mtimeMs > dispatchStart) {
+                    outputFiles.push(f);
+                }
+            }
+            catch { }
+        }
+    }
+    // Detect files created during this dispatch
+    if (workspace) {
+        for (const entry of readdirSync(workspace, { withFileTypes: true })) {
+            if (entry.isDirectory())
+                continue;
+            const f = join(workspace, entry.name);
+            if (entry.name.startsWith('.agentbean-exec-'))
+                continue;
+            try {
+                const st = statSync(f);
+                if (st.mtimeMs > dispatchStart) {
+                    outputFiles.push(f);
+                }
+            }
+            catch { }
+        }
+    }
+    // Extract code blocks for logging but do NOT auto-execute (security)
+    if (workspace) {
+        const codeBlocks = [];
+        let m;
+        const re = new RegExp(CODE_BLOCK_RE.source, 'g');
+        while ((m = re.exec(reply)) !== null) {
+            codeBlocks.push(m[1]);
+        }
+        if (codeBlocks.length > 0) {
+            logger.info({ count: codeBlocks.length }, 'code blocks detected but not executed (auto-exec disabled)');
+        }
+    }
+    let replyText = reply;
+    if (outputFiles.length > 0) {
+        replyText += '\n\n已生成文件:\n' + outputFiles.map((f) => `- ${f}`).join('\n');
+    }
+    return { replyText, outputFiles };
+}

package/dist/sandbox.js

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+function escapeSchemeString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export function getWorkspaceDir(agentId) {
+    const dir = join(homedir(), '.agentbean', 'workspaces', agentId);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function isSandboxAvailable() {
+    return process.platform === 'darwin';
+}
+export function generateSandboxProfile(agentId, runtimePath) {
+    const workspaceDir = getWorkspaceDir(agentId);
+    const runtimeDir = runtimePath.includes('/') ? dirname(runtimePath) : '/usr/bin';
+    const profilePath = `/tmp/agentbean-sandbox-${agentId}.sb`;
+    const profile = `(version 1)
+(allow file-read* file-write*
+  (subpath "${escapeSchemeString(workspaceDir)}"))
+(allow file-read* file-write*
+  (subpath "/tmp"))
+(allow file-read*
+  (subpath "${escapeSchemeString(runtimeDir)}"))
+(allow file-read*
+  (subpath "/bin")
+  (subpath "/usr/bin")
+  (subpath "/usr/local/bin")
+  (subpath "/opt/homebrew/bin"))
+(allow network-outbound
+  (remote tcp "api.anthropic.com" 443))
+(allow network-outbound
+  (remote tcp "api.openai.com" 443))
+(deny default)
+`;
+    writeFileSync(profilePath, profile);
+    return profilePath;
+}