@agentbean/daemon 0.1.0

package/README.md

@@ -0,0 +1,158 @@
+# AgentBean Device Daemon
+
+Agent 适配器层 —— 运行在用户机器上，将真实 Coding Agent 接入 AgentBean Server。
+
+## 启动
+
+```bash
+npm install
+npm run dev    # 开发模式（tsx watch）
+npm start      # 运行（tsx）
+npm test       # 运行测试
+```
+
+### 带配置文件启动
+
+```bash
+npx tsx src/index.ts ~/.agentbean/device-agent.yaml
+```
+
+### 自动扫描模式
+
+如果不提供配置文件，或配置文件中 `agents` 数组为空，Daemon 会自动扫描本机 Agent：
+
+```bash
+npx tsx src/index.ts
+# 扫描 Coding Agent (which claude-code, codex, kimi...)
+# 扫描 AgentOS Gateway (localhost:PORT)
+# 扫描 ~/.agentbean/agents/ 目录
+```
+
+## 配置文件格式
+
+`device-agent.yaml`：
+
+```yaml
+deviceId: my-macbook-pro      # 设备标识
+networkId: default            # 所属网络
+server:
+  url: http://localhost:3000/agent    # Server Socket.IO 地址
+  token: default:default:dev-token-change-me    # 三截 token
+heartbeatIntervalMs: 10000    # 心跳间隔（默认 10s）
+
+agents:                       # Agent 配置列表
+  - id: claude-shaw
+    name: Claude
+    role: 高级编程助手
+    category: coding          # coding | executor-hosted | agentos-hosted | standalone-cli
+    visibility: public        # public | private
+    adapter:
+      kind: claude-code       # claude-code | codex | openclaw | hermes | standalone
+      command: claude         # 可执行命令
+      args: []                # 命令参数
+      cwd: ~/projects          # 工作目录（可选）
+      systemPrompt: |          # 系统提示词（可选）
+        You are a helpful coding assistant.
+```
+
+支持环境变量插值：`${SERVER_URL}`
+
+## 核心模块
+
+### 设备守护进程 (`device-daemon.ts`)
+
+`DeviceDaemon` 类：
+- 维护与 Server 的 Socket.IO 连接
+- 管理多个 `AgentInstance`
+- 定期发送心跳
+- 处理 Server 下发的 `dispatch` 任务
+
+### Agent 实例 (`agent-instance.ts`)
+
+`AgentInstance` 封装单个 Agent：
+- 持有 `CliAdapter`（适配器实例）
+- 管理 Agent 生命周期（启动、运行、停止）
+- 将 Server 的 `dispatch` 转换为适配器输入
+- 将适配器输出包装为 `reply` 发送回 Server
+
+### 扫描器 (`scanner.ts`)
+
+三类自动发现：
+
+**`scanCodingAgents()`** — 通过 `which` 发现本机 Coding Agent：
+```typescript
+const CODING_BINARIES = ['claude-code', 'codex', 'kimi'];
+// 对每个执行 which，存在的加入结果
+```
+
+**`scanAgentOSAgents()`** — 扫描 OpenClaw / Hermes gateway：
+- 尝试连接 `http://localhost:PORT/openclaw/agents`
+- 如果 gateway 未运行，返回空数组
+
+**`scanLocalAgents(scanDir)`** — 扫描约定目录：
+- 扫描 `~/.agentbean/agents/` 或指定目录
+- 查找 `agent.json` / `agent.yaml` 配置文件
+- 识别执行器承载型（有 `executor` 字段）和独立 CLI Agent
+
+### 连接管理 (`connection.ts`)
+
+`createConnection()`：
+- 建立 Socket.IO 连接到 Server `/agent` 命名空间
+- 发送 `register` 事件进行认证
+- 自动重连和心跳
+- 处理 `dispatch` 事件并路由到对应 Agent
+
+### CLI 适配器 (`adapters/`)
+
+| 适配器 | 说明 | 命令 |
+|--------|------|------|
+| `ClaudeCodeAdapter` | Anthropic Claude Code | `claude` |
+| `CodexAdapter` | OpenAI Codex CLI | `codex` |
+| `OpenClawAdapter` | OpenClaw gateway | `openclaw` |
+| `HermesAdapter` | Hermes gateway | `hermes` |
+
+所有适配器实现 `CliAdapter` 接口：
+```typescript
+interface CliAdapter {
+  start(): void;
+  stop(): void;
+  send(input: string): void;
+  onOutput(handler: (text: string) => void): void;
+  onExit(handler: (code: number | null) => void): void;
+}
+```
+
+底层使用 `node-pty` 创建伪终端与 CLI 工具交互，支持实时流式输出。
+
+### 配置解析 (`config.ts`)
+
+- `loadConfig()` — 解析单 Agent 配置
+- `loadDeviceConfig()` — 解析设备级多 Agent 配置
+- `AgentCategory` — 四类 Agent 分类
+- `AdapterKind` — 五种适配器类型
+- 支持 YAML 环境变量插值
+
+## 启动流程
+
+```
+1. 解析命令行参数（配置文件路径）
+2. 尝试 loadDeviceConfig() — 静态配置优先
+3. 如果无静态配置或 agents 数组为空：
+   a. scanCodingAgents() — 扫描本机 CLI 工具
+   b. scanAgentOSAgents() — 扫描 gateway
+   c. scanLocalAgents() — 扫描约定目录
+   d. 合并去重，生成 AgentConfigEntry 列表
+4. 对每个 entry 创建 AgentInstance + 适配器
+5. 创建 DeviceDaemon，连接 Server
+6. 发送 register + 定期 heartbeat
+7. 等待 dispatch 任务
+```
+
+## 环境变量
+
+| 变量 | 说明 |
+|------|------|
+| `SERVER_URL` | Server WebSocket 地址 |
+| `SERVER_TOKEN` | 接入令牌 |
+| `DEVICE_ID` | 设备标识 |
+| `NETWORK_ID` | 所属网络 |

package/dist/adapters/adapter.js

@@ -0,0 +1,9 @@
+export class StubAdapter {
+    kind = 'codex';
+    async ask() {
+        throw new Error('stub adapter: real adapter wiring lands in M2');
+    }
+    async health() {
+        return { ok: false, detail: 'stub adapter — connect a real CLI in M2' };
+    }
+}

package/dist/adapters/claude-code.js

@@ -0,0 +1,79 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+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 ClaudeCodeAdapter {
+    opts;
+    kind = 'claude-code';
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async ask(input, signal) {
+        return new Promise((resolve, reject) => {
+            const prompt = buildPrompt(input, this.opts.systemPrompt ?? input.systemPrompt);
+            const cwd = input.workspace ?? this.opts.cwd ?? process.cwd();
+            const baseArgs = ['-p', '--bare', ...(this.opts.args ?? [])];
+            if (input.workspace)
+                baseArgs.push('--add-dir', input.workspace);
+            baseArgs.push('--add-dir', join(homedir(), '.codex', 'generated_images'));
+            const command = input.sandboxProfilePath ? 'sandbox-exec' : this.opts.command;
+            const args = input.sandboxProfilePath
+                ? ['-f', input.sandboxProfilePath, '--', this.opts.command, ...baseArgs]
+                : baseArgs;
+            const child = spawn(command, args, {
+                cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            const MAX_EXEC_MS = 600_000;
+            const onAbort = () => {
+                child.kill('SIGTERM');
+                setTimeout(() => child.kill('SIGKILL'), 2_000).unref();
+            };
+            signal.addEventListener('abort', onAbort);
+            const maxTimer = setTimeout(() => {
+                child.kill('SIGKILL');
+                signal.removeEventListener('abort', onAbort);
+                reject(new Error('claude-code adapter timeout'));
+            }, MAX_EXEC_MS).unref();
+            child.stdout.on('data', (b) => stdoutChunks.push(b));
+            child.stderr.on('data', (b) => stderrChunks.push(b));
+            child.on('error', (err) => {
+                clearTimeout(maxTimer);
+                signal.removeEventListener('abort', onAbort);
+                reject(err);
+            });
+            child.on('exit', (code) => {
+                clearTimeout(maxTimer);
+                signal.removeEventListener('abort', onAbort);
+                if (signal.aborted)
+                    return reject(new Error('aborted'));
+                const out = Buffer.concat(stdoutChunks).toString('utf8').trim();
+                const err = Buffer.concat(stderrChunks).toString('utf8').trim();
+                if (code !== 0 && out.length === 0) {
+                    return reject(new Error(`claude-code exit ${code}: ${err.slice(0, 200)}`));
+                }
+                resolve(out);
+            });
+            child.stdin.write(prompt);
+            child.stdin.end();
+        });
+    }
+    async health() {
+        return new Promise((resolve) => {
+            const child = spawn(this.opts.command, ['--version'], { stdio: 'ignore' });
+            child.on('error', (err) => resolve({ ok: false, detail: err.message }));
+            child.on('exit', (code) => resolve({ ok: code === 0, detail: code === 0 ? undefined : `exit ${code}` }));
+        });
+    }
+}

package/dist/adapters/codex.js

@@ -0,0 +1,114 @@
+import { spawn } from 'node-pty';
+function renderPayload(input, systemPrompt) {
+    const parts = [];
+    if (systemPrompt)
+        parts.push(`# system\n${systemPrompt}`);
+    for (const turn of input.history) {
+        parts.push(`# ${turn.role}: ${turn.speaker}\n${turn.body}`);
+    }
+    parts.push(`# user\n${input.prompt}`);
+    return parts.join('\n\n');
+}
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function extractReply(output) {
+    const clean = stripAnsi(output).replace(/\r\n/g, '\n');
+    // Match "codex" label followed by reply content, ending before next hook or end
+    const match = clean.match(/\ncodex\n([\s\S]*?)(?:\nhook:|$)/i);
+    if (match)
+        return match[1].trim();
+    // Fallback: everything after last "user" prompt
+    const userIdx = clean.lastIndexOf('\nuser\n');
+    if (userIdx > 0) {
+        const after = clean.slice(userIdx).split('\n').slice(2).join('\n').trim();
+        if (after)
+            return after;
+    }
+    return clean.trim();
+}
+export class CodexAdapter {
+    opts;
+    kind = 'codex';
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async ask(input, signal) {
+        return new Promise((resolve, reject) => {
+            const payload = renderPayload(input, this.opts.systemPrompt ?? input.systemPrompt);
+            const cwd = input.workspace ?? this.opts.cwd ?? process.cwd();
+            const baseCommand = this.opts.command || 'codex';
+            const baseArgs = [...(this.opts.args ?? ['exec']), payload];
+            const command = input.sandboxProfilePath ? 'sandbox-exec' : baseCommand;
+            const args = input.sandboxProfilePath
+                ? ['-f', input.sandboxProfilePath, '--', baseCommand, ...baseArgs]
+                : baseArgs;
+            const pty = spawn(command, args, {
+                name: 'xterm-color',
+                cols: 80,
+                rows: 30,
+                cwd,
+                env: process.env,
+            });
+            const chunks = [];
+            let finished = false;
+            const MAX_EXEC_MS = 600_000;
+            const onAbort = () => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(maxTimer);
+                signal.removeEventListener('abort', onAbort);
+                pty.kill('SIGTERM');
+                setTimeout(() => {
+                    try {
+                        pty.kill('SIGKILL');
+                    }
+                    catch { }
+                }, 2_000).unref();
+                reject(new Error('aborted'));
+            };
+            signal.addEventListener('abort', onAbort);
+            const maxTimer = setTimeout(() => {
+                if (finished)
+                    return;
+                finished = true;
+                pty.kill('SIGKILL');
+                signal.removeEventListener('abort', onAbort);
+                reject(new Error('codex adapter timeout'));
+            }, MAX_EXEC_MS).unref();
+            pty.onData((data) => chunks.push(data));
+            pty.onExit(({ exitCode }) => {
+                clearTimeout(maxTimer);
+                signal.removeEventListener('abort', onAbort);
+                if (finished)
+                    return;
+                finished = true;
+                if (signal.aborted)
+                    return reject(new Error('aborted'));
+                const raw = chunks.join('');
+                if (exitCode !== 0) {
+                    const detail = stripAnsi(raw).trim();
+                    return reject(new Error(detail ? `codex exit ${exitCode}: ${detail}` : `codex exit ${exitCode}`));
+                }
+                const reply = extractReply(raw);
+                resolve(reply || '(Codex 已完成处理)');
+            });
+        });
+    }
+    async health() {
+        return new Promise((resolve) => {
+            try {
+                const pty = spawn('bash', ['-c', 'codex --version'], {
+                    name: 'xterm-color', cols: 80, rows: 30,
+                    cwd: this.opts.cwd ?? process.cwd(),
+                    env: process.env,
+                });
+                pty.onExit(({ exitCode }) => resolve({ ok: exitCode === 0, detail: exitCode === 0 ? undefined : `exit ${exitCode}` }));
+            }
+            catch (err) {
+                resolve({ ok: false, detail: err.message });
+            }
+        });
+    }
+}

package/dist/adapters/hermes.js

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process';
+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 HermesAdapter {
+    opts;
+    kind = 'hermes';
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async ask(input, signal) {
+        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 ?? [])], {
+                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(() => { 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('hermes adapter timeout'));
+            }, MAX_EXEC_MS).unref();
+            child.stdout.on('data', (b) => stdoutChunks.push(b));
+            child.stderr.on('data', (b) => stderrChunks.push(b));
+            child.on('error', (err) => {
+                clearTimeout(maxTimer);
+                signal.removeEventListener('abort', onAbort);
+                reject(err);
+            });
+            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 && out.length === 0) {
+                    return reject(new Error(`hermes exit ${code}: ${err.slice(0, 400)}`));
+                }
+                resolve(out.trim() || err.trim());
+            });
+        });
+    }
+    async health() {
+        return new Promise((resolve) => {
+            const child = spawn(this.opts.command, ['--version'], { stdio: 'ignore' });
+            child.on('error', (err) => resolve({ ok: false, detail: err.message }));
+            child.on('exit', (code) => resolve({ ok: code === 0, detail: code === 0 ? undefined : `exit ${code}` }));
+        });
+    }
+}

package/dist/adapters/openclaw.js

@@ -0,0 +1,70 @@
+import { spawn } from 'node:child_process';
+export class OpenClawAdapter {
+    opts;
+    kind = 'openclaw';
+    constructor(opts) {
+        this.opts = opts;
+    }
+    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 stdoutChunks = [];
+            const stderrChunks = [];
+            const MAX_EXEC_MS = 600_000;
+            const onAbort = () => {
+                child.kill('SIGTERM');
+                setTimeout(() => child.kill('SIGKILL'), 2_000).unref();
+            };
+            signal.addEventListener('abort', onAbort);
+            const maxTimer = setTimeout(() => {
+                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);
+                reject(err);
+            });
+            child.on('exit', (code) => {
+                clearTimeout(maxTimer);
+                signal.removeEventListener('abort', onAbort);
+                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);
+                }
+                catch {
+                    return reject(new Error(`openclaw produced non-JSON output: ${out.slice(0, 200)}`));
+                }
+                if (parsed.error)
+                    return reject(new Error(parsed.error));
+                resolve((parsed.reply ?? '').trim());
+            });
+        });
+    }
+    async health() {
+        return new Promise((resolve) => {
+            const child = spawn(this.opts.command, ['--version'], { stdio: 'ignore' });
+            child.on('error', (err) => resolve({ ok: false, detail: err.message }));
+            child.on('exit', (code) => resolve({ ok: code === 0, detail: code === 0 ? undefined : `exit ${code}` }));
+        });
+    }
+}

package/dist/agent-instance.js

@@ -0,0 +1,84 @@
+import { logger } from './log.js';
+import { uploadArtifact } from './uploader.js';
+import { postProcess } from './post-process.js';
+import { generateSandboxProfile, getWorkspaceDir, isSandboxAvailable } from './sandbox.js';
+export class AgentInstance {
+    config;
+    adapter;
+    id;
+    name;
+    role;
+    visibility;
+    constructor(config, adapter) {
+        this.config = config;
+        this.adapter = adapter;
+        this.id = config.id;
+        this.name = config.name;
+        this.role = config.role;
+        this.visibility = config.visibility;
+    }
+    get publicMeta() {
+        return {
+            id: this.id,
+            name: this.name,
+            role: this.role,
+            category: this.config.category ?? 'executor-hosted',
+            adapterKind: this.adapter.kind,
+            visibility: this.visibility,
+        };
+    }
+    async handleDispatch(opts) {
+        const { socket, req, serverUrl, token, networkId } = opts;
+        const ctl = new AbortController();
+        const dispatchStart = Date.now();
+        try {
+            const rawBody = await this.adapter.ask({
+                prompt: req.prompt,
+                history: req.history ?? [],
+                systemPrompt: this.config.adapter.systemPrompt,
+                workspace: req.sandboxed ? getWorkspaceDir(this.id) : this.config.adapter.workspace,
+                sandboxProfilePath: req.sandboxed && isSandboxAvailable()
+                    ? generateSandboxProfile(this.id, this.config.adapter.command)
+                    : undefined,
+            }, ctl.signal);
+            const processed = await postProcess(rawBody, req.sandboxed ? getWorkspaceDir(this.id) : this.config.adapter.workspace, this.adapter.kind, dispatchStart);
+            const artifactIds = [];
+            if (processed.outputFiles.length > 0) {
+                for (const filePath of processed.outputFiles) {
+                    try {
+                        const result = await uploadArtifact({
+                            serverUrl,
+                            token,
+                            networkId,
+                            filePath,
+                            channelId: req.channelId,
+                            uploaderId: this.id,
+                        });
+                        if (result)
+                            artifactIds.push(result.id);
+                    }
+                    catch (err) {
+                        logger.warn({ err: err.message, filePath }, 'artifact upload failed');
+                    }
+                }
+            }
+            socket.emit('reply', {
+                agentId: this.id,
+                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, agentId: this.id }, 'dispatch failed');
+            socket.emit('error_event', {
+                agentId: this.id,
+                at: Date.now(),
+                message: err.message ?? 'unknown',
+                scope: 'reply',
+                requestId: req.requestId,
+            });
+        }
+    }
+}

package/dist/auth-store.js

@@ -0,0 +1,24 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const AUTH_DIR = join(homedir(), '.agentbean');
+const AUTH_FILE = join(AUTH_DIR, 'auth.json');
+export function loadAuth() {
+    if (!existsSync(AUTH_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(AUTH_FILE, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveAuth(data) {
+    if (!existsSync(AUTH_DIR))
+        mkdirSync(AUTH_DIR, { recursive: true });
+    writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2));
+}
+export function clearAuth() {
+    if (existsSync(AUTH_FILE))
+        unlinkSync(AUTH_FILE);
+}

package/dist/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from './index.js';
+main().catch((err) => {
+    console.error('fatal:', err.message);
+    process.exit(1);
+});