@agentbean/daemon 0.1.29 → 0.1.32

package/dist/adapters/claude-code.js

@@ -11,6 +11,9 @@ function buildPrompt(input, systemPrompt) {
     parts.push(input.prompt);
     return parts.join('\n\n---\n\n');
 }
+function normalizeClaudeArgs(args) {
+    return ['-p', ...(args ?? [])];
+}
 export class ClaudeCodeAdapter {
     opts;
     kind = 'claude-code';
@@ -21,7 +24,7 @@ export class ClaudeCodeAdapter {
         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 ?? [])];
+            const baseArgs = normalizeClaudeArgs(this.opts.args);
             if (input.workspace)
                 baseArgs.push('--add-dir', input.workspace);
             baseArgs.push('--add-dir', join(homedir(), '.codex', 'generated_images'));

package/dist/adapters/codex.js

@@ -1,4 +1,8 @@
-import { spawn } from 'node-pty';
+import { spawn as spawnChild } from 'node:child_process';
+import { spawn as spawnPty } from 'node-pty';
+import { accessSync, constants, existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
 function renderPayload(input, systemPrompt) {
     const parts = [];
     if (systemPrompt)
@@ -40,18 +44,147 @@ export function extractCodexReply(output, payload) {
     }
     return clean.trim();
 }
-function normalizeExecArgs(args) {
+function hasFlag(args, ...flags) {
+    return args.some((arg) => flags.some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
+}
+function flagValue(args, ...flags) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        for (const flag of flags) {
+            if (arg === flag)
+                return args[i + 1];
+            if (arg.startsWith(`${flag}=`))
+                return arg.slice(flag.length + 1);
+        }
+    }
+    return undefined;
+}
+function createOutputLastMessagePath() {
+    return join(mkdtempSync(join(tmpdir(), 'agentbean-codex-')), 'last-message.txt');
+}
+function normalizeExecArgs(args, outputLastMessagePath) {
     const baseArgs = args && args.length > 0 ? args : ['exec'];
     const subcommand = baseArgs[0];
-    if ((subcommand === 'exec' || subcommand === 'e') && !baseArgs.includes('--skip-git-repo-check')) {
-        return [subcommand, '--skip-git-repo-check', ...baseArgs.slice(1)];
+    if (subcommand === 'exec' || subcommand === 'e') {
+        const rest = baseArgs.slice(1);
+        const normalized = [subcommand];
+        if (!hasFlag(rest, '--skip-git-repo-check')) {
+            normalized.push('--skip-git-repo-check');
+        }
+        const configuredOutputPath = flagValue(rest, '--output-last-message', '-o');
+        if (!configuredOutputPath) {
+            normalized.push('--output-last-message', outputLastMessagePath);
+        }
+        if (!hasFlag(rest, '--json', '--experimental-json')) {
+            normalized.push('--json');
+        }
+        return {
+            args: [...normalized, ...rest],
+            outputLastMessagePath: configuredOutputPath ?? outputLastMessagePath,
+        };
     }
-    return baseArgs;
+    return { args: baseArgs };
 }
 function adapterTimeoutMs() {
     const fromEnv = Number.parseInt(process.env.AGENTBEAN_CODEX_TIMEOUT_MS ?? '', 10);
     return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 900_000;
 }
+function buildRuntimeEnv(extra) {
+    const pathEntries = [
+        process.env.PATH,
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+        join(homedir(), '.local/bin'),
+        join(homedir(), '.bun/bin'),
+        join(homedir(), '.npm-global/bin'),
+        join(homedir(), '.asdf/shims'),
+        join(homedir(), '.local/share/mise/shims'),
+    ].filter(Boolean).join(':');
+    return { ...process.env, PATH: pathEntries, ...(extra ?? {}) };
+}
+function assertExecutable(command, env, label) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        throw new Error(`${label} command is empty`);
+    }
+    if (trimmed.includes('/')) {
+        try {
+            accessSync(trimmed, constants.X_OK);
+            return;
+        }
+        catch {
+            throw new Error(`${label} command is not executable: ${trimmed}`);
+        }
+    }
+    const pathEntries = (env.PATH ?? '').split(delimiter).filter(Boolean);
+    for (const dir of pathEntries) {
+        try {
+            accessSync(join(dir, trimmed), constants.X_OK);
+            return;
+        }
+        catch { }
+    }
+    throw new Error(`${label} command was not found on PATH: ${trimmed}. PATH=${env.PATH ?? ''}`);
+}
+function readOutputLastMessage(path) {
+    if (!path || !existsSync(path))
+        return null;
+    const text = readFileSync(path, 'utf8').trim();
+    return text || null;
+}
+function spawnRuntimeProcess(command, args, opts) {
+    try {
+        const pty = spawnPty(command, args, {
+            name: 'xterm-color',
+            cols: 80,
+            rows: 30,
+            cwd: opts.cwd,
+            env: opts.env,
+        });
+        return {
+            onData: (cb) => pty.onData(cb),
+            onExit: (cb) => pty.onExit(({ exitCode }) => cb({ exitCode })),
+            kill: (signal) => pty.kill(signal),
+        };
+    }
+    catch (err) {
+        const child = spawnChild(command, args, {
+            cwd: opts.cwd,
+            env: opts.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const dataHandlers = [];
+        const exitHandlers = [];
+        let exited = false;
+        const emitExit = (exitCode) => {
+            if (exited)
+                return;
+            exited = true;
+            for (const handler of exitHandlers)
+                handler({ exitCode });
+        };
+        child.stdout?.on('data', (data) => {
+            for (const handler of dataHandlers)
+                handler(String(data));
+        });
+        child.stderr?.on('data', (data) => {
+            for (const handler of dataHandlers)
+                handler(String(data));
+        });
+        child.on('error', (childErr) => {
+            const message = childErr instanceof Error ? childErr.message : String(childErr);
+            for (const handler of dataHandlers)
+                handler(message);
+            emitExit(1);
+        });
+        child.on('exit', (code) => emitExit(code ?? 1));
+        return {
+            onData: (cb) => { dataHandlers.push(cb); },
+            onExit: (cb) => { exitHandlers.push(cb); },
+            kill: (signal) => { child.kill(signal); },
+        };
+    }
+}
 export class CodexAdapter {
     opts;
     kind = 'codex';
@@ -63,19 +196,26 @@ export class CodexAdapter {
             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 configuredArgs = normalizeExecArgs(this.opts.args);
+            const defaultOutputLastMessagePath = createOutputLastMessagePath();
+            const normalizedExec = normalizeExecArgs(this.opts.args, defaultOutputLastMessagePath);
+            const configuredArgs = normalizedExec.args;
             const baseArgs = [...configuredArgs, 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, ...(input.env ?? {}) },
-            });
+            const env = buildRuntimeEnv(input.env);
+            try {
+                assertExecutable(command, env, input.sandboxProfilePath ? 'Sandbox launcher' : 'Codex runtime');
+                if (input.sandboxProfilePath) {
+                    assertExecutable(baseCommand, env, 'Codex runtime');
+                }
+            }
+            catch (err) {
+                reject(err);
+                return;
+            }
+            const runtime = spawnRuntimeProcess(command, args, { cwd, env });
             const chunks = [];
             let finished = false;
             const MAX_EXEC_MS = adapterTimeoutMs();
@@ -85,10 +225,10 @@ export class CodexAdapter {
                 finished = true;
                 clearTimeout(maxTimer);
                 signal.removeEventListener('abort', onAbort);
-                pty.kill('SIGTERM');
+                runtime.kill('SIGTERM');
                 setTimeout(() => {
                     try {
-                        pty.kill('SIGKILL');
+                        runtime.kill('SIGKILL');
                     }
                     catch { }
                 }, 2_000).unref();
@@ -99,12 +239,12 @@ export class CodexAdapter {
                 if (finished)
                     return;
                 finished = true;
-                pty.kill('SIGKILL');
+                runtime.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 }) => {
+            runtime.onData((data) => chunks.push(data));
+            runtime.onExit(({ exitCode }) => {
                 clearTimeout(maxTimer);
                 signal.removeEventListener('abort', onAbort);
                 if (finished)
@@ -117,7 +257,7 @@ export class CodexAdapter {
                     const detail = stripAnsi(raw).trim();
                     return reject(new Error(detail ? `codex exit ${exitCode}: ${detail}` : `codex exit ${exitCode}`));
                 }
-                const reply = extractCodexReply(raw, payload);
+                const reply = readOutputLastMessage(normalizedExec.outputLastMessagePath) ?? extractCodexReply(raw, payload);
                 resolve(reply || '(Codex 已完成处理)');
             });
         });
@@ -125,10 +265,10 @@ export class CodexAdapter {
     async health() {
         return new Promise((resolve) => {
             try {
-                const pty = spawn('bash', ['-c', 'codex --version'], {
+                const pty = spawnPty('bash', ['-c', 'codex --version'], {
                     name: 'xterm-color', cols: 80, rows: 30,
                     cwd: this.opts.cwd ?? process.cwd(),
-                    env: process.env,
+                    env: buildRuntimeEnv(),
                 });
                 pty.onExit(({ exitCode }) => resolve({ ok: exitCode === 0, detail: exitCode === 0 ? undefined : `exit ${exitCode}` }));
             }

package/dist/agent-instance.js

@@ -108,7 +108,7 @@ export class AgentInstance {
                 sandboxProfilePath: req.sandboxed && isSandboxAvailable()
                     ? generateSandboxProfile(this.id, this.config.adapter.command)
                     : undefined,
-                env: workspaceEnv(run),
+                env: { ...(this.config.adapter.env ?? {}), ...workspaceEnv(run) },
             }, ctl.signal);
             const processed = await postProcess(rawBody, projectWorkspace, this.adapter.kind, dispatchStart, {
                 outputDirs: [run.outputDir, run.intermediateDir],

package/dist/config.js

@@ -23,6 +23,16 @@ function deepInterpolate(node) {
     }
     return node;
 }
+function parseEnvMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (key.trim())
+            out[key.trim()] = String(raw ?? '');
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 export function loadConfig(path) {
     const raw = parseYaml(readFileSync(path, 'utf8'));
     if (!raw || typeof raw !== 'object')
@@ -62,6 +72,7 @@ export function loadConfig(path) {
             cwd: typeof a.cwd === 'string' ? a.cwd : undefined,
             workspace: typeof a.workspace === 'string' ? a.workspace : undefined,
             systemPrompt: typeof a.systemPrompt === 'string' ? a.systemPrompt : undefined,
+            env: parseEnvMap(a.env),
         },
         server: { url: s.url, token: s.token },
         heartbeatIntervalMs: isValidHeartbeat(interp.heartbeatIntervalMs) ? interp.heartbeatIntervalMs : 10_000,
@@ -121,6 +132,7 @@ export function loadDeviceConfig(path) {
                 cwd: typeof ad.cwd === 'string' ? ad.cwd : undefined,
                 workspace: typeof ad.workspace === 'string' ? ad.workspace : undefined,
                 systemPrompt: typeof ad.systemPrompt === 'string' ? ad.systemPrompt : undefined,
+                env: parseEnvMap(ad.env),
             },
             visibility: a.visibility === 'public' ? 'public' : 'private',
             sandboxed: a.sandboxed === true,

package/dist/device-daemon.js

@@ -71,6 +71,14 @@ export function resolveCustomAgentRuntime(custom, runtimes) {
     if (bestRuntime?.command?.trim()) {
         return { command: bestRuntime.command.trim(), runtime: bestRuntime };
     }
+    if (configured && isAbsolute(configured) && !configuredAbsoluteExists) {
+        const fallback = basename(configured).trim();
+        if (fallback)
+            return { command: fallback };
+    }
+    if (!configured && normalizeAdapterKind(custom.adapterKind) === 'codex') {
+        return { command: 'codex' };
+    }
     return { command: configured };
 }
 export function nativeDirectoryPickerCommands(platform = process.platform) {
@@ -383,6 +391,7 @@ export function createDeviceDaemon(cfg, agents) {
                             args: custom.args ?? [],
                             cwd: custom.cwd ?? undefined,
                             workspace: custom.cwd ?? undefined,
+                            env: custom.env ?? undefined,
                             systemPrompt: custom.description ?? undefined,
                         },
                         visibility: 'public',

package/dist/sandbox.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { accessSync, constants, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 function escapeSchemeString(value) {
@@ -11,7 +11,15 @@ export function getWorkspaceDir(agentId) {
     return dir;
 }
 export function isSandboxAvailable() {
-    return process.platform === 'darwin';
+    if (process.platform !== 'darwin')
+        return false;
+    try {
+        accessSync('/usr/bin/sandbox-exec', constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 export function generateSandboxProfile(agentId, runtimePath) {
     const workspaceDir = getWorkspaceDir(agentId);

package/dist/scanner.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { readdirSync, readFileSync, statSync, existsSync, writeFileSync, mkdirSync, } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
 import * as os from "node:os";
 import { logger } from "./log.js";
@@ -274,6 +274,7 @@ async function checkHermesGateway() {
             adapterKind: "hermes",
             command: path,
             args: [],
+            cwd: dirname(path),
             source: "gateway",
         };
     }
@@ -293,6 +294,7 @@ async function checkOpenClawGateway() {
             adapterKind: "openclaw",
             command: path,
             args: ["agent", "--agent", agentId ?? "main"],
+            cwd: dirname(path),
             source: "gateway",
         };
     }

package/package.json

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