@agentbean/daemon 0.1.0

package/dist/scanner.js

@@ -0,0 +1,296 @@
+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) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            const path = stdout.trim();
+            resolve(path.length > 0 ? path : null);
+        });
+        child.on('error', () => resolve(null));
+    });
+}
+function run(bin, args) {
+    return new Promise((resolve) => {
+        const child = execFile(bin, args, { timeout: 10_000 }, (err, stdout) => {
+            resolve(stdout?.trim() ?? '');
+        });
+        child.on('error', () => resolve(''));
+    });
+}
+// --- Machine ID (stable per-device identifier) ---
+const MACHINE_ID_FILE = join(os.homedir(), '.agentbean', 'device-id');
+function getFirstMacAddress() {
+    const ifaces = os.networkInterfaces();
+    for (const [name, addrs] of Object.entries(ifaces)) {
+        if (!addrs)
+            continue;
+        for (const addr of addrs) {
+            // Skip internal (loopback) and zero MAC
+            if (addr.internal)
+                continue;
+            if (addr.mac === '00:00:00:00:00:00')
+                continue;
+            return addr.mac;
+        }
+    }
+    return null;
+}
+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;
+            }
+        }
+        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']);
+            const match = output.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+            if (match)
+                return match[1] ?? null;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+/**
+ * Get a stable device ID unique to this machine.
+ * Priority: cached file > platform machine-id > MAC address > random UUID
+ * Result is cached to ~/.agentbean/device-id
+ */
+export async function getDeviceId() {
+    // 1. Read cached ID
+    if (existsSync(MACHINE_ID_FILE)) {
+        const cached = readFileSync(MACHINE_ID_FILE, 'utf-8').trim();
+        if (cached)
+            return cached;
+    }
+    // 2. Collect hardware fingerprint
+    const parts = [];
+    const platformId = await readPlatformMachineId();
+    if (platformId)
+        parts.push(`platform:${platformId}`);
+    const mac = getFirstMacAddress();
+    if (mac)
+        parts.push(`mac:${mac}`);
+    parts.push(`hostname:${os.hostname()}`);
+    parts.push(`arch:${os.arch()}`);
+    parts.push(`platform:${os.platform()}`);
+    let deviceId;
+    if (parts.length > 2) {
+        // We have enough hardware info — generate deterministic ID
+        const hash = createHash('sha256').update(parts.join('|')).digest('hex');
+        // Format as UUID: 8-4-4-4-12
+        deviceId = [
+            hash.slice(0, 8),
+            hash.slice(8, 12),
+            hash.slice(12, 16),
+            hash.slice(16, 20),
+            hash.slice(20, 32),
+        ].join('-');
+    }
+    else {
+        // Fallback: random UUID
+        const { randomUUID } = await import('node:crypto');
+        deviceId = randomUUID();
+    }
+    // 3. Cache to file
+    try {
+        const dir = join(os.homedir(), '.agentbean');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(MACHINE_ID_FILE, deviceId);
+    }
+    catch {
+        // non-fatal
+    }
+    return deviceId;
+}
+// --- 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' },
+    ];
+    const results = [];
+    for (const s of checks) {
+        const path = await which(s.bin);
+        results.push({
+            name: s.name,
+            adapterKind: s.adapterKind,
+            command: path ?? '',
+            installed: path !== null,
+        });
+    }
+    return results;
+}
+// --- Scan AgentOS Gateways (Hermes, OpenClaw) ---
+async function checkHermesGateway() {
+    const path = await which('hermes');
+    if (!path)
+        return null;
+    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',
+            command: path,
+            args: ['gateway', 'run'],
+            source: 'gateway',
+        };
+    }
+    return null;
+}
+async function checkOpenClawGateway() {
+    const path = await which('openclaw');
+    if (!path)
+        return null;
+    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',
+            command: path,
+            args: ['gateway', 'run'],
+            source: 'gateway',
+        };
+    }
+    return null;
+}
+export async function scanAgentOSAgents() {
+    const [hermes, openclaw] = await Promise.all([
+        checkHermesGateway(),
+        checkOpenClawGateway(),
+    ]);
+    return [hermes, openclaw].filter((a) => a !== null);
+}
+// --- Scan local agent definitions from filesystem ---
+export async function scanLocalAgents(scanDir = join(os.homedir(), '.agentbean', 'agents')) {
+    if (!existsSync(scanDir)) {
+        return [];
+    }
+    const results = [];
+    let entries;
+    try {
+        entries = readdirSync(scanDir);
+    }
+    catch (err) {
+        logger?.warn?.({ err: err?.message }, 'scan failed');
+        return [];
+    }
+    for (const entry of entries) {
+        const subdir = join(scanDir, entry);
+        let st;
+        try {
+            st = statSync(subdir);
+        }
+        catch {
+            continue;
+        }
+        if (!st.isDirectory())
+            continue;
+        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';
+        }
+        else if (existsSync(yamlPath)) {
+            raw = readFileSync(yamlPath, 'utf8');
+            ext = 'yaml';
+        }
+        else if (existsSync(ymlPath)) {
+            raw = readFileSync(ymlPath, 'utf8');
+            ext = 'yaml';
+        }
+        if (raw === null || ext === null)
+            continue;
+        let parsed = null;
+        try {
+            if (ext === 'json') {
+                parsed = JSON.parse(raw);
+            }
+            else {
+                const { load: parseYaml } = await import('js-yaml');
+                parsed = parseYaml(raw);
+            }
+        }
+        catch {
+            continue;
+        }
+        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) : [];
+        let category;
+        if (typeof parsed.category === 'string' && ['executor-hosted', 'agentos-hosted', 'standalone-cli'].includes(parsed.category)) {
+            category = parsed.category;
+        }
+        else if ('executor' in parsed) {
+            category = 'executor-hosted';
+        }
+        else {
+            category = 'standalone-cli';
+        }
+        const adapterKind = typeof parsed.adapterKind === 'string' && ['codex', 'claude-code', 'openclaw', 'hermes', 'standalone'].includes(parsed.adapterKind)
+            ? parsed.adapterKind
+            : 'standalone';
+        results.push({
+            category,
+            name,
+            adapterKind,
+            command,
+            args,
+            source: 'filesystem',
+        });
+    }
+    return results;
+}
+export function collectSystemInfo() {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const cpus = os.cpus();
+    const platform = os.platform();
+    let osVersion = `${os.type()} ${os.release()}`;
+    if (platform === 'darwin') {
+        osVersion = `macOS ${os.release()}`;
+    }
+    return {
+        platform,
+        arch: os.arch(),
+        osVersion,
+        hostname: os.hostname(),
+        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,
+        nodeVersion: process.version,
+    };
+}

package/dist/uploader.js

@@ -0,0 +1,46 @@
+import { readFileSync, statSync } from 'node:fs';
+import { basename } from 'node:path';
+import { logger } from './log.js';
+export async function uploadArtifact(input) {
+    const { serverUrl, token, networkId, filePath, channelId, uploaderId, metaJson } = input;
+    const filename = basename(filePath);
+    let buffer;
+    let size;
+    try {
+        const st = statSync(filePath);
+        size = st.size;
+        buffer = readFileSync(filePath);
+    }
+    catch (err) {
+        logger.warn({ err: err.message, filePath }, 'artifact read failed');
+        return null;
+    }
+    // Node Buffer is a Uint8Array; cast to satisfy strict DOM types
+    const blob = new Blob([buffer]);
+    const form = new FormData();
+    form.append('channelId', channelId);
+    form.append('file', blob, filename);
+    if (uploaderId)
+        form.append('uploaderId', uploaderId);
+    if (metaJson)
+        form.append('metaJson', metaJson);
+    try {
+        const resp = await fetch(`${serverUrl}/api/networks/${networkId}/artifacts/upload`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${token}` },
+            body: form,
+        });
+        if (!resp.ok) {
+            const text = await resp.text();
+            logger.warn({ status: resp.status, body: text, filePath }, 'artifact upload rejected');
+            return null;
+        }
+        const result = (await resp.json());
+        logger.info({ id: result.id, filename, sizeBytes: size }, 'artifact uploaded');
+        return result;
+    }
+    catch (err) {
+        logger.warn({ err: err.message, filePath }, 'artifact upload failed');
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@agentbean/daemon",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "agentbean-daemon": "./dist/bin.js",
+    "@agentbean/daemon": "./dist/bin.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/bin.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0",
+    "node-pty": "^1.1.0",
+    "pino": "^9.4.0",
+    "pino-pretty": "^11.2.2",
+    "socket.io-client": "^4.7.5",
+    "ulid": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.16.5",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.2",
+    "vitest": "^2.0.5"
+  }
+}