@agentbean/daemon 0.1.9 → 0.1.10

package/dist/adapters/claude-code.js

@@ -32,6 +32,7 @@ export class ClaudeCodeAdapter {
             const child = spawn(command, args, {
                 cwd,
                 stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, ...(input.env ?? {}) },
             });
             const stdoutChunks = [];
             const stderrChunks = [];

package/dist/adapters/codex.js

@@ -57,7 +57,7 @@ export class CodexAdapter {
                 cols: 80,
                 rows: 30,
                 cwd,
-                env: process.env,
+                env: { ...process.env, ...(input.env ?? {}) },
             });
             const chunks = [];
             let finished = false;

package/dist/adapters/hermes.js

@@ -72,6 +72,7 @@ export class HermesAdapter {
             const child = spawn(this.opts.command, buildArgs(runtimeArgs(this.opts.args), prompt), {
                 cwd,
                 stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env, ...(input.env ?? {}) },
             });
             const stdoutChunks = [];
             const stderrChunks = [];

package/dist/adapters/openclaw.js

@@ -32,6 +32,7 @@ export class OpenClawAdapter {
             const child = spawn(this.opts.command, buildArgs(this.opts.args ?? [], prompt), {
                 cwd,
                 stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env, ...(input.env ?? {}) },
             });
             const stdoutChunks = [];
             const stderrChunks = [];

package/dist/agent-instance.js

@@ -2,6 +2,7 @@ import { logger } from './log.js';
 import { uploadArtifact } from './uploader.js';
 import { postProcess } from './post-process.js';
 import { generateSandboxProfile, getWorkspaceDir, isSandboxAvailable } from './sandbox.js';
+import { archiveOutputFiles, beginAgentWorkspaceRun, finishAgentWorkspaceRun, workspaceEnv, } from './workspace-manager.js';
 function errorMessage(err) {
     if (err instanceof Error && err.message)
         return err.message;
@@ -41,37 +42,65 @@ export class AgentInstance {
         };
     }
     async handleDispatch(opts) {
-        const { socket, req, serverUrl, token, networkId } = opts;
+        const { socket, req, serverUrl, token, networkId, deviceId } = opts;
         const ctl = new AbortController();
         const dispatchStart = Date.now();
+        const teamId = req.teamId ?? req.networkId ?? networkId;
+        const projectWorkspace = req.sandboxed ? getWorkspaceDir(this.id) : this.config.adapter.workspace;
+        const run = beginAgentWorkspaceRun({
+            teamId,
+            teamName: req.teamName,
+            agentId: this.id,
+            agentName: this.name,
+            runId: req.requestId,
+            prompt: req.prompt,
+            projectDir: projectWorkspace,
+        });
+        let archivedFiles = [];
         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,
+                workspace: projectWorkspace,
                 sandboxProfilePath: req.sandboxed && isSandboxAvailable()
                     ? generateSandboxProfile(this.id, this.config.adapter.command)
                     : undefined,
+                env: workspaceEnv(run),
             }, ctl.signal);
-            const processed = await postProcess(rawBody, req.sandboxed ? getWorkspaceDir(this.id) : this.config.adapter.workspace, this.adapter.kind, dispatchStart);
+            const processed = await postProcess(rawBody, projectWorkspace, this.adapter.kind, dispatchStart, {
+                outputDirs: [run.outputDir, run.intermediateDir],
+            });
+            archivedFiles = archiveOutputFiles(run, processed.outputFiles);
+            finishAgentWorkspaceRun(run, { replyText: processed.replyText, files: archivedFiles, status: 'completed' });
             const artifactIds = [];
-            if (processed.outputFiles.length > 0) {
-                for (const filePath of processed.outputFiles) {
+            if (archivedFiles.length > 0) {
+                for (const file of archivedFiles) {
                     try {
                         const result = await uploadArtifact({
                             serverUrl,
                             token,
-                            networkId,
-                            filePath,
+                            networkId: teamId,
+                            filePath: file.archivedPath,
                             channelId: req.channelId,
                             uploaderId: this.id,
+                            metaJson: JSON.stringify({
+                                kind: 'agent-workspace-file',
+                                teamId,
+                                agentId: this.id,
+                                runId: req.requestId,
+                                deviceId: deviceId ?? null,
+                                pathKind: file.pathKind,
+                                relativePath: file.relativePath,
+                                originalPath: file.originalPath,
+                                sha256: file.sha256,
+                            }),
                         });
                         if (result)
                             artifactIds.push(result.id);
                     }
                     catch (err) {
-                        logger.warn({ err: err.message, filePath }, 'artifact upload failed');
+                        logger.warn({ err: err.message, filePath: file.archivedPath }, 'artifact upload failed');
                     }
                 }
             }
@@ -85,6 +114,7 @@ export class AgentInstance {
         }
         catch (err) {
             const message = errorMessage(err);
+            finishAgentWorkspaceRun(run, { files: archivedFiles, status: 'failed', error: message });
             logger.error({ err: message, requestId: req.requestId, agentId: this.id }, 'dispatch failed');
             socket.emit('error_event', {
                 agentId: this.id,

package/dist/connection.js

@@ -2,6 +2,7 @@ import { io } from 'socket.io-client';
 import { logger } from './log.js';
 import { uploadArtifact } from './uploader.js';
 import { postProcess } from './post-process.js';
+import { archiveOutputFiles, beginAgentWorkspaceRun, finishAgentWorkspaceRun, workspaceEnv, } from './workspace-manager.js';
 function errorMessage(err) {
     if (err instanceof Error && err.message)
         return err.message;
@@ -57,32 +58,57 @@ export function createConnection(cfg, adapter) {
                 queue = queue.then(async () => {
                     const ctl = new AbortController();
                     const dispatchStart = Date.now();
+                    const teamId = 'default';
+                    const run = beginAgentWorkspaceRun({
+                        teamId,
+                        agentId: cfg.id,
+                        agentName: cfg.name,
+                        runId: req.requestId,
+                        prompt: req.prompt,
+                        projectDir: cfg.adapter.workspace,
+                    });
+                    let archivedFiles = [];
                     try {
                         const rawBody = await adapter.ask({
                             prompt: req.prompt,
                             history: req.history ?? [],
                             systemPrompt: cfg.adapter.systemPrompt,
                             workspace: cfg.adapter.workspace,
+                            env: workspaceEnv(run),
                         }, ctl.signal);
-                        const processed = await postProcess(rawBody, cfg.adapter.workspace, cfg.adapter.kind, dispatchStart);
+                        const processed = await postProcess(rawBody, cfg.adapter.workspace, cfg.adapter.kind, dispatchStart, {
+                            outputDirs: [run.outputDir, run.intermediateDir],
+                        });
+                        archivedFiles = archiveOutputFiles(run, processed.outputFiles);
+                        finishAgentWorkspaceRun(run, { replyText: processed.replyText, files: archivedFiles, status: 'completed' });
                         const artifactIds = [];
-                        if (processed.outputFiles.length > 0) {
+                        if (archivedFiles.length > 0) {
                             const httpBase = cfg.server.url.replace(/\/agent$/, '');
-                            for (const filePath of processed.outputFiles) {
+                            for (const file of archivedFiles) {
                                 try {
                                     const result = await uploadArtifact({
                                         serverUrl: httpBase,
                                         token: cfg.server.token,
-                                        networkId: 'default',
-                                        filePath,
+                                        networkId: teamId,
+                                        filePath: file.archivedPath,
                                         channelId: req.channelId,
                                         uploaderId: cfg.id,
+                                        metaJson: JSON.stringify({
+                                            kind: 'agent-workspace-file',
+                                            teamId,
+                                            agentId: cfg.id,
+                                            runId: req.requestId,
+                                            pathKind: file.pathKind,
+                                            relativePath: file.relativePath,
+                                            originalPath: file.originalPath,
+                                            sha256: file.sha256,
+                                        }),
                                     });
                                     if (result)
                                         artifactIds.push(result.id);
                                 }
                                 catch (err) {
-                                    logger.warn({ err: err.message, filePath }, 'artifact upload failed');
+                                    logger.warn({ err: err.message, filePath: file.archivedPath }, 'artifact upload failed');
                                 }
                             }
                         }
@@ -95,6 +121,7 @@ export function createConnection(cfg, adapter) {
                     }
                     catch (err) {
                         const message = errorMessage(err);
+                        finishAgentWorkspaceRun(run, { files: archivedFiles, status: 'failed', error: message });
                         logger.error({ err: message, requestId: req.requestId }, 'dispatch failed');
                         currentSocket.emit('error_event', {
                             at: Date.now(),

package/dist/device-daemon.js

@@ -6,6 +6,7 @@ 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';
+import { syncWorkspaceArtifacts } from './workspace-sync.js';
 function errorMessage(err) {
     if (err instanceof Error && err.message)
         return err.message;
@@ -103,7 +104,9 @@ export function createDeviceDaemon(cfg, agents) {
     let socket = null;
     let heartbeatTimer = null;
     let rescanTimer = null;
+    let workspaceSyncTimer = null;
     const RESCAN_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+    const WORKSPACE_SYNC_INTERVAL_MS = 2 * 60 * 1000;
     const queues = new Map();
     const httpBase = cfg.server.url.replace(/\/agent$/, '');
     let firstConnect = true;
@@ -232,6 +235,14 @@ export function createDeviceDaemon(cfg, agents) {
                         return;
                     scanAndRegister(socket, false);
                 }, RESCAN_INTERVAL_MS);
+                syncWorkspaceArtifacts({ serverUrl: httpBase, token: cfg.server.token, networkId: cfg.networkId });
+                if (workspaceSyncTimer)
+                    clearInterval(workspaceSyncTimer);
+                workspaceSyncTimer = setInterval(() => {
+                    if (!socket?.connected)
+                        return;
+                    syncWorkspaceArtifacts({ serverUrl: httpBase, token: cfg.server.token, networkId: cfg.networkId });
+                }, WORKSPACE_SYNC_INTERVAL_MS);
             });
             socket.on('connect_error', (err) => {
                 logger.error({ err: err.message }, 'connect_error');
@@ -288,7 +299,8 @@ export function createDeviceDaemon(cfg, agents) {
                         req,
                         serverUrl: httpBase,
                         token: cfg.server.token,
-                        networkId: cfg.networkId,
+                        networkId: req.teamId ?? req.networkId ?? cfg.networkId,
+                        deviceId: cfg.deviceId,
                     });
                 }).catch((err) => {
                     const message = errorMessage(err);
@@ -316,6 +328,10 @@ export function createDeviceDaemon(cfg, agents) {
                     clearInterval(rescanTimer);
                     rescanTimer = null;
                 }
+                if (workspaceSyncTimer) {
+                    clearInterval(workspaceSyncTimer);
+                    workspaceSyncTimer = null;
+                }
             });
         },
         async stop() {
@@ -327,6 +343,10 @@ export function createDeviceDaemon(cfg, agents) {
                 clearInterval(rescanTimer);
                 rescanTimer = null;
             }
+            if (workspaceSyncTimer) {
+                clearInterval(workspaceSyncTimer);
+                workspaceSyncTimer = null;
+            }
             socket?.close();
             socket = null;
         },

package/dist/workspace-manager.js

@@ -0,0 +1,134 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+function rootDir() {
+    return resolve(process.env.AGENTBEAN_HOME ?? join(homedir(), '.agentbean'));
+}
+function safeSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/^-+|-+$/g, '') || 'unknown';
+}
+function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function getAgentWorkspaceDir(teamId, agentId) {
+    return ensureDir(join(rootDir(), 'teams', safeSegment(teamId), 'agents', safeSegment(agentId)));
+}
+function writeJson(path, value) {
+    ensureDir(dirname(path));
+    writeFileSync(path, JSON.stringify(value, null, 2));
+}
+function fileHash(path) {
+    return createHash('sha256').update(readFileSync(path)).digest('hex');
+}
+function uniqueDestination(dir, filename) {
+    const ext = extname(filename);
+    const stem = ext ? filename.slice(0, -ext.length) : filename;
+    let candidate = join(dir, filename);
+    let index = 1;
+    while (existsSync(candidate)) {
+        candidate = join(dir, `${stem}-${index}${ext}`);
+        index += 1;
+    }
+    return candidate;
+}
+export function beginAgentWorkspaceRun(input) {
+    const teamId = safeSegment(input.teamId);
+    const agentId = safeSegment(input.agentId);
+    const runId = safeSegment(input.runId);
+    const teamDir = ensureDir(join(rootDir(), 'teams', teamId));
+    const agentDir = ensureDir(join(teamDir, 'agents', agentId));
+    const runDir = ensureDir(join(agentDir, 'runs', runId));
+    const outputDir = ensureDir(join(runDir, 'outputs'));
+    const intermediateDir = ensureDir(join(runDir, 'intermediates'));
+    const logDir = ensureDir(join(runDir, 'logs'));
+    writeJson(join(teamDir, 'team.json'), {
+        id: input.teamId,
+        name: input.teamName ?? input.teamId,
+        updatedAt: new Date().toISOString(),
+    });
+    writeJson(join(agentDir, 'agent.json'), {
+        id: input.agentId,
+        name: input.agentName ?? input.agentId,
+        projectDir: input.projectDir ?? null,
+        updatedAt: new Date().toISOString(),
+    });
+    writeFileSync(join(runDir, 'prompt.md'), input.prompt);
+    writeJson(join(runDir, 'manifest.json'), {
+        teamId: input.teamId,
+        agentId: input.agentId,
+        runId: input.runId,
+        status: 'running',
+        createdAt: new Date().toISOString(),
+        files: [],
+    });
+    return { teamId: input.teamId, agentId: input.agentId, runId: input.runId, agentDir, runDir, outputDir, intermediateDir, logDir };
+}
+export function workspaceEnv(run) {
+    return {
+        AGENTBEAN_TEAM_ID: run.teamId,
+        AGENTBEAN_AGENT_ID: run.agentId,
+        AGENTBEAN_RUN_ID: run.runId,
+        AGENTBEAN_WORKSPACE: run.agentDir,
+        AGENTBEAN_OUTPUT_DIR: run.outputDir,
+        AGENTBEAN_INTERMEDIATE_DIR: run.intermediateDir,
+        AGENT_BEAN_OUTPUT_DIRS: [run.outputDir, run.intermediateDir].join(','),
+    };
+}
+export function archiveOutputFiles(run, files) {
+    const archived = [];
+    const seen = new Set();
+    for (const file of files) {
+        const abs = isAbsolute(file) ? file : resolve(file);
+        if (seen.has(abs))
+            continue;
+        seen.add(abs);
+        let st;
+        try {
+            st = statSync(abs);
+            if (!st.isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const alreadyInRun = relative(run.runDir, abs);
+        const archivedPath = alreadyInRun && !alreadyInRun.startsWith('..') && !isAbsolute(alreadyInRun)
+            ? abs
+            : uniqueDestination(run.outputDir, basename(abs));
+        if (archivedPath !== abs)
+            copyFileSync(abs, archivedPath);
+        const sizeBytes = statSync(archivedPath).size;
+        archived.push({
+            originalPath: abs,
+            archivedPath,
+            relativePath: relative(run.agentDir, archivedPath),
+            pathKind: 'output',
+            sha256: fileHash(archivedPath),
+            sizeBytes,
+        });
+    }
+    return archived;
+}
+export function finishAgentWorkspaceRun(run, input) {
+    if (input.replyText !== undefined) {
+        writeFileSync(join(run.runDir, 'response.md'), input.replyText);
+    }
+    writeJson(join(run.runDir, 'manifest.json'), {
+        teamId: run.teamId,
+        agentId: run.agentId,
+        runId: run.runId,
+        status: input.status,
+        updatedAt: new Date().toISOString(),
+        error: input.error,
+        files: input.files.map((file) => ({
+            path: file.relativePath,
+            sha256: file.sha256,
+            sizeBytes: file.sizeBytes,
+            kind: file.pathKind,
+            originalPath: file.originalPath,
+        })),
+    });
+}

package/dist/workspace-sync.js

@@ -0,0 +1,69 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, normalize } from 'node:path';
+import { logger } from './log.js';
+import { getAgentWorkspaceDir } from './workspace-manager.js';
+function hashFile(path) {
+    try {
+        return createHash('sha256').update(readFileSync(path)).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+function safeRelativePath(value) {
+    const normalized = normalize(value).replace(/^(\.\.(\/|\\|$))+/, '');
+    if (!normalized || isAbsolute(normalized) || normalized.startsWith('..'))
+        return null;
+    return normalized;
+}
+export async function syncWorkspaceArtifacts(input) {
+    const base = input.serverUrl.replace(/\/agent$/, '');
+    let payload;
+    try {
+        const resp = await fetch(`${base}/api/networks/${encodeURIComponent(input.networkId)}/workspace`, {
+            headers: { Authorization: `Bearer ${input.token}` },
+        });
+        if (!resp.ok) {
+            logger.warn({ status: resp.status, body: await resp.text() }, 'workspace sync manifest rejected');
+            return;
+        }
+        payload = await resp.json();
+    }
+    catch (err) {
+        logger.warn({ err: err?.message }, 'workspace sync manifest failed');
+        return;
+    }
+    if (!payload.ok || !payload.agents?.length)
+        return;
+    let downloaded = 0;
+    for (const agent of payload.agents) {
+        const agentDir = getAgentWorkspaceDir(input.networkId, agent.id);
+        for (const run of agent.runs) {
+            for (const file of run.files) {
+                const rel = safeRelativePath(file.relativePath);
+                if (!rel)
+                    continue;
+                const dest = join(agentDir, rel);
+                if (file.sha256 && existsSync(dest) && hashFile(dest) === file.sha256)
+                    continue;
+                try {
+                    const resp = await fetch(`${base}${file.downloadUrl}`, {
+                        headers: { Authorization: `Bearer ${input.token}` },
+                    });
+                    if (!resp.ok)
+                        continue;
+                    const bytes = Buffer.from(await resp.arrayBuffer());
+                    mkdirSync(dirname(dest), { recursive: true });
+                    writeFileSync(dest, bytes);
+                    downloaded += 1;
+                }
+                catch (err) {
+                    logger.warn({ err: err?.message, fileId: file.id }, 'workspace artifact download failed');
+                }
+            }
+        }
+    }
+    if (downloaded > 0)
+        logger.info({ downloaded }, 'workspace artifacts synced');
+}

package/package.json

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