@agentbean/daemon 0.1.33 → 0.1.35

package/dist/adapters/hermes.js

@@ -27,11 +27,22 @@ function buildPrompt(input, systemPrompt) {
 }
 const ANSI_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 const BOX_ONLY_RE = /^[\s─━═╭╮╰╯│┃┌┐└┘├┤┬┴┼]+$/;
+function stripEchoedQueryPreamble(lines) {
+    const initIdx = lines.findIndex((line) => {
+        const trimmed = line.trim();
+        return trimmed === 'Initializing agent...' || trimmed === 'Initializing agent…';
+    });
+    if (initIdx < 0)
+        return lines;
+    if (!lines.slice(0, initIdx).some((line) => line.trim().startsWith('Query:')))
+        return lines;
+    return lines.slice(initIdx + 1);
+}
 export function extractHermesReply(output) {
-    const lines = output
+    const lines = stripEchoedQueryPreamble(output
         .replace(ANSI_RE, '')
         .replace(/\r\n?/g, '\n')
-        .split('\n');
+        .split('\n'));
     let boxStart = -1;
     for (let i = lines.length - 1; i >= 0; i -= 1) {
         if (lines[i]?.trim().startsWith('╭')) {

package/dist/agent-instance.js

@@ -106,7 +106,7 @@ export class AgentInstance {
                 systemPrompt: this.config.adapter.systemPrompt,
                 workspace: projectWorkspace,
                 sandboxProfilePath: req.sandboxed && isSandboxAvailable()
-                    ? generateSandboxProfile(this.id, this.config.adapter.command)
+                    ? generateSandboxProfile(this.id, this.config.adapter.command, [run.runDir])
                     : undefined,
                 env: { ...(this.config.adapter.env ?? {}), ...workspaceEnv(run) },
             }, ctl.signal);

package/dist/auth-store.js

@@ -1,24 +1,44 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { existsSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 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))
+import { agentbeanHome, authFile, ensureProfileRoot, profileIdForNetwork } from './profile-paths.js';
+export function loadAuth(options = {}) {
+    const file = authFile(options.profileId);
+    if (!existsSync(file))
         return null;
     try {
-        return JSON.parse(readFileSync(AUTH_FILE, 'utf8'));
+        return JSON.parse(readFileSync(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 saveAuth(data, options = {}) {
+    const profileId = options.profileId ?? null;
+    ensureProfileRoot(profileId);
+    writeFileSync(authFile(profileId), JSON.stringify(data, null, 2));
 }
-export function clearAuth() {
-    if (existsSync(AUTH_FILE))
-        unlinkSync(AUTH_FILE);
+export function clearAuth(options = {}) {
+    const file = authFile(options.profileId);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+export function listAuthProfiles() {
+    const profiles = [];
+    const teamsDir = join(agentbeanHome(), 'teams');
+    if (existsSync(teamsDir)) {
+        for (const entry of readdirSync(teamsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const auth = loadAuth({ profileId: entry.name });
+            if (auth?.networkId)
+                profiles.push({ ...auth, profileId: entry.name });
+        }
+    }
+    const legacy = loadAuth();
+    if (legacy?.networkId) {
+        const profileId = profileIdForNetwork(legacy.networkId);
+        if (!profiles.some((profile) => profile.profileId === profileId))
+            profiles.push({ ...legacy, profileId });
+    }
+    return profiles;
 }

package/dist/device-daemon.js

@@ -1,14 +1,14 @@
 import { io } from 'socket.io-client';
 import { execFile } from 'node:child_process';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { basename, isAbsolute, join } from 'node:path';
-import { homedir } from 'node:os';
+import { basename, isAbsolute, dirname } from 'node:path';
 import { promisify } from 'node:util';
 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';
+import { scanCacheFile } from './profile-paths.js';
 const execFileAsync = promisify(execFile);
 function errorMessage(err) {
     if (err instanceof Error && err.message)
@@ -86,10 +86,6 @@ export function nativeDirectoryPickerCommands(platform = process.platform) {
         return [{
                 command: 'osascript',
                 args: [
-                    '-e',
-                    'tell application "Finder" to activate',
-                    '-e',
-                    'delay 0.2',
                     '-e',
                     'POSIX path of (choose folder with prompt "选择项目目录" default location (path to home folder))',
                 ],
@@ -140,8 +136,6 @@ export async function selectNativeDirectory(commands = nativeDirectoryPickerComm
     }
     throw new Error(lastError ? `directory picker command not available: ${errorMessage(lastError)}` : 'directory picker command not available');
 }
-const CACHE_DIR = join(homedir(), '.agentbean');
-const CACHE_FILE = join(CACHE_DIR, 'scanned-agents.json');
 function isRuntimeEntry(entry) {
     return entry.category === 'executor-hosted' &&
         ['codex', 'claude-code', 'kimi-cli', 'Kimi-cli'].includes(entry.adapterKind);
@@ -164,11 +158,12 @@ function splitLegacyCache(entries) {
     }
     return { agents, runtimes };
 }
-function loadCache() {
+function loadCache(profileId) {
     try {
-        if (!existsSync(CACHE_FILE))
+        const cacheFile = scanCacheFile(profileId);
+        if (!existsSync(cacheFile))
             return null;
-        const parsed = JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+        const parsed = JSON.parse(readFileSync(cacheFile, 'utf-8'));
         if (Array.isArray(parsed))
             return splitLegacyCache(parsed);
         return {
@@ -180,11 +175,13 @@ function loadCache() {
         return null;
     }
 }
-function saveCache(payload) {
+function saveCache(payload, profileId) {
     try {
-        if (!existsSync(CACHE_DIR))
-            mkdirSync(CACHE_DIR, { recursive: true });
-        writeFileSync(CACHE_FILE, JSON.stringify(payload, null, 2));
+        const cacheFile = scanCacheFile(profileId);
+        const cacheDir = dirname(cacheFile);
+        if (!existsSync(cacheDir))
+            mkdirSync(cacheDir, { recursive: true });
+        writeFileSync(cacheFile, JSON.stringify(payload, null, 2));
     }
     catch (err) {
         logger.warn({ err: err?.message }, 'failed to save scan cache');
@@ -195,6 +192,8 @@ export function createDeviceSocketOptions(input) {
         auth: {
             token: input.token,
             deviceId: input.deviceId,
+            machineId: input.machineId,
+            profileId: input.profileId,
             networkId: input.networkId,
             agents: input.agents,
             systemInfo: input.systemInfo,
@@ -205,6 +204,8 @@ export function createDeviceSocketOptions(input) {
                 directoryPicker: true,
             },
         },
+        transports: ['websocket', 'polling'],
+        rememberUpgrade: true,
         reconnection: true,
         reconnectionDelay: 1_000,
         reconnectionDelayMax: 10_000,
@@ -296,13 +297,13 @@ export function createDeviceDaemon(cfg, agents) {
     }
     async function scanAndRegister(sock, useCache) {
         if (useCache) {
-            const cached = loadCache();
+            const cached = loadCache(cfg.profileId);
             if (cached) {
                 logger.info({ count: cached.agents.length + cached.runtimes.length }, 'using cached scan results');
                 emitRegister(sock, cached);
                 // Background refresh — only emit if results differ
                 scanAll().then((fresh) => {
-                    saveCache(fresh);
+                    saveCache(fresh, cfg.profileId);
                     const cachedKey = JSON.stringify([
                         ...cached.agents.map((a) => a.command),
                         ...cached.runtimes.map((rt) => rt.command),
@@ -324,7 +325,7 @@ export function createDeviceDaemon(cfg, agents) {
         // Full scan (no cache or cache miss)
         try {
             const scanned = await scanAll();
-            saveCache(scanned);
+            saveCache(scanned, cfg.profileId);
             emitRegister(sock, scanned);
         }
         catch (err) {
@@ -337,6 +338,8 @@ export function createDeviceDaemon(cfg, agents) {
             socket = io(agentUrl, createDeviceSocketOptions({
                 token: cfg.server.token,
                 deviceId: cfg.deviceId,
+                machineId: cfg.machineId,
+                profileId: cfg.profileId,
                 networkId: cfg.networkId,
                 agents: publicAgents,
                 systemInfo,

package/dist/index.js

@@ -7,16 +7,17 @@ import { AgentInstance } from './agent-instance.js';
 import { pickAdapter } from './adapters/factory.js';
 import { logger } from './log.js';
 import { scanRuntimes, scanAgentOSAgents, scanLocalAgents, getDeviceId } from './scanner.js';
-import { loadAuth, saveAuth } from './auth-store.js';
+import { listAuthProfiles, loadAuth, saveAuth } from './auth-store.js';
+import { deviceInstanceId, localAgentsDir, profileIdForNetwork } from './profile-paths.js';
 export function discoveredAgentId(name, deviceId) {
     const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
     return deviceId ? `scan-${deviceId}-${slug}` : slug;
 }
-async function discoverAgents(deviceId) {
+async function discoverAgents(deviceId, profileId) {
     const [_runtimes, agentos, local] = await Promise.all([
         scanRuntimes(),
         scanAgentOSAgents(),
-        scanLocalAgents(),
+        scanLocalAgents(profileId ? localAgentsDir(profileId) : undefined),
     ]);
     const seen = new Set();
     const results = [];
@@ -60,6 +61,24 @@ async function startDeviceDaemon(cfg) {
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
 }
+async function buildCliDeviceConfig(input) {
+    const machineId = input.machineId ?? await getDeviceId();
+    const deviceId = input.explicitDeviceId ?? deviceInstanceId(machineId, input.networkId);
+    logger.info({ serverUrl: input.serverUrl, deviceId, machineId, networkId: input.networkId, profileId: input.profileId }, 'CLI mode: auto-discovering agents');
+    const agents = await discoverAgents(deviceId, input.profileId);
+    if (agents.length === 0) {
+        logger.warn('no agents discovered on this machine. Daemon will start with no agents.');
+    }
+    return {
+        deviceId,
+        machineId,
+        profileId: input.profileId,
+        networkId: input.networkId,
+        server: { url: input.serverUrl, token: input.token },
+        heartbeatIntervalMs: 10_000,
+        agents,
+    };
+}
 async function runDeviceMode(cfgPath) {
     let cfg;
     let scannedEntries;
@@ -129,37 +148,62 @@ async function runCliMode() {
             'invite': { type: 'string' },
             'device-id': { type: 'string' },
             'network-id': { type: 'string' },
+            'profile': { type: 'string' },
+            'all-profiles': { type: 'boolean' },
             'help': { type: 'boolean' },
         },
         strict: true,
     });
     if (values.help) {
-        console.log(`Usage: agentbean-daemon --server-url <url> --token <token> [--device-id <id>] [--network-id <id>]
+        console.log(`Usage: agentbean-daemon --server-url <url> --token <token> [--device-id <id>] [--network-id <id>] [--profile <id>]
 
 Options:
   --server-url   AgentBean Server URL (required)
   --token        Authentication token (required)
   --device-id    Device ID (default: auto-detected from hardware)
   --network-id   Team ID (default: default)
+  --profile      Team profile for local auth/cache isolation
+  --all-profiles Start one connection for every saved team profile
 `);
         process.exit(0);
     }
+    if (values['all-profiles']) {
+        const profiles = listAuthProfiles();
+        if (profiles.length === 0) {
+            console.error('Error: no saved AgentBean team profiles found.');
+            process.exit(1);
+        }
+        const machineId = values['device-id'] ?? await getDeviceId();
+        const configs = await Promise.all(profiles.map((profile) => buildCliDeviceConfig({
+            serverUrl: profile.serverUrl,
+            token: profile.token,
+            networkId: profile.networkId ?? networkIdFromToken(profile.token) ?? 'default',
+            machineId,
+            profileId: profile.profileId,
+        })));
+        await Promise.all(configs.map((cfg) => startDeviceDaemon(cfg)));
+        return;
+    }
     let serverUrl = values['server-url'] ?? process.env.AGENT_BEAN_SERVER_URL;
     let token = values['token'] ?? process.env.AGENT_BEAN_AGENT_TOKEN;
     let savedAuth = null;
     let networkId = values['network-id'] ?? 'default';
+    let profileId = values.profile ?? process.env.AGENTBEAN_PROFILE;
     if (values.invite) {
         if (!serverUrl) {
             console.error('Error: --server-url is required with --invite.');
             process.exit(1);
         }
-        const auth = await runInviteMode(serverUrl, values.invite);
+        const machineId = values['device-id'] ?? await getDeviceId();
+        const auth = await runInviteMode(serverUrl, values.invite, machineId);
         serverUrl = auth.serverUrl;
         token = auth.token;
         networkId = auth.networkId ?? networkId;
+        profileId = profileId ?? profileIdForNetwork(networkId);
+        saveAuth(auth, { profileId });
     }
     else if (!token) {
-        savedAuth = loadAuth();
+        savedAuth = loadAuth({ profileId });
         if (savedAuth) {
             serverUrl = serverUrl ?? savedAuth.serverUrl;
             token = savedAuth.token;
@@ -182,19 +226,16 @@ Options:
         savedNetworkId: savedAuth?.networkId,
         fallbackNetworkId: networkId,
     });
-    const deviceId = values['device-id'] ?? await getDeviceId();
-    logger.info({ serverUrl, deviceId, networkId }, 'CLI mode: auto-discovering agents');
-    const agents = await discoverAgents(deviceId);
-    if (agents.length === 0) {
-        logger.warn('no agents discovered on this machine. Daemon will start with no agents.');
-    }
-    const cfg = {
-        deviceId,
+    profileId = profileId ?? profileIdForNetwork(networkId);
+    const machineId = values['device-id'] ?? await getDeviceId();
+    const cfg = await buildCliDeviceConfig({
+        serverUrl,
+        token,
         networkId,
-        server: { url: serverUrl, token },
-        heartbeatIntervalMs: 10_000,
-        agents,
-    };
+        machineId,
+        explicitDeviceId: values['device-id'] ? values['device-id'] : undefined,
+        profileId,
+    });
     await startDeviceDaemon(cfg);
 }
 function normalizeBaseUrl(serverUrl) {
@@ -238,7 +279,7 @@ export function socketErrorMessage(err) {
         .map((value) => value.trim());
     return [...new Set(details)].join(': ') || 'unknown socket error';
 }
-async function runInviteMode(serverUrl, inviteCode) {
+async function runInviteMode(serverUrl, inviteCode, deviceId) {
     const { io } = await import('socket.io-client');
     const { execFile } = await import('node:child_process');
     const baseUrl = normalizeBaseUrl(serverUrl);
@@ -265,7 +306,7 @@ async function runInviteMode(serverUrl, inviteCode) {
             clearTimeout(connectTimer);
             logger.info('invite mode: connected, validating invite code');
             console.log('Connected. Validating invite code...');
-            socket.emit('auth:invite:validate', { code: inviteCode }, (res) => {
+            socket.emit('auth:invite:validate', { code: inviteCode, deviceId }, (res) => {
                 if (!res?.ok) {
                     fail(new Error(res?.error ?? 'invalid invite code'));
                     return;
@@ -290,7 +331,6 @@ async function runInviteMode(serverUrl, inviteCode) {
                 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();
@@ -300,7 +340,7 @@ async function runInviteMode(serverUrl, inviteCode) {
 }
 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');
+    const hasCliFlags = process.argv.some((a) => a === '--server-url' || a === '--token' || a === '--invite' || a === '--profile' || a === '--all-profiles' || a === '--help');
     if (hasCliFlags) {
         await runCliMode();
         return;

package/dist/profile-paths.js

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function agentbeanHome() {
+    return process.env.AGENTBEAN_HOME?.trim() || join(homedir(), '.agentbean');
+}
+export function profileIdForNetwork(networkId) {
+    const source = networkId?.trim() || 'default';
+    const slug = source.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return slug || 'default';
+}
+export function profileRoot(profileId) {
+    const explicitDir = process.env.AGENTBEAN_PROFILE_DIR?.trim();
+    if (explicitDir && profileId)
+        return explicitDir;
+    if (!profileId)
+        return agentbeanHome();
+    return join(agentbeanHome(), 'teams', profileIdForNetwork(profileId));
+}
+export function ensureProfileRoot(profileId) {
+    const root = profileRoot(profileId);
+    if (!existsSync(root))
+        mkdirSync(root, { recursive: true });
+    return root;
+}
+export function authFile(profileId) {
+    return join(profileRoot(profileId), 'auth.json');
+}
+export function scanCacheFile(profileId) {
+    return join(profileRoot(profileId), 'scanned-agents.json');
+}
+export function localAgentsDir(profileId) {
+    return join(profileRoot(profileId), 'agents');
+}
+export function deviceInstanceId(machineId, networkId) {
+    const hash = createHash('sha256').update(`${networkId}:${machineId}`).digest('hex');
+    return `dev_${hash.slice(0, 24)}`;
+}

package/dist/sandbox.js

@@ -21,16 +21,21 @@ export function isSandboxAvailable() {
         return false;
     }
 }
-export function generateSandboxProfile(agentId, runtimePath) {
+export function generateSandboxProfile(agentId, runtimePath, writableDirs = []) {
     const workspaceDir = getWorkspaceDir(agentId);
     const runtimeDir = runtimePath.includes('/') ? dirname(runtimePath) : '/usr/bin';
     const profilePath = `/tmp/agentbean-sandbox-${agentId}.sb`;
+    const extraWritableRules = writableDirs
+        .filter(Boolean)
+        .map((dir) => `(allow file-read* file-write*
+  (subpath "${escapeSchemeString(dir)}"))`)
+        .join('\n');
     const profile = `(version 1)
 (allow file-read* file-write*
   (subpath "${escapeSchemeString(workspaceDir)}"))
 (allow file-read* file-write*
   (subpath "/tmp"))
-(allow file-read*
+${extraWritableRules ? `${extraWritableRules}\n` : ''}(allow file-read*
   (subpath "${escapeSchemeString(runtimeDir)}"))
 (allow file-read*
   (subpath "/bin")

package/dist/scanner.js

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
 import * as os from "node:os";
 import { logger } from "./log.js";
+import { agentbeanHome, localAgentsDir } from "./profile-paths.js";
 function readDaemonVersion() {
     try {
         const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -126,7 +127,7 @@ export function parseOpenClawAgentId(output) {
     return null;
 }
 // --- Machine ID (stable per-device identifier) ---
-const MACHINE_ID_FILE = join(os.homedir(), ".agentbean", "device-id");
+const MACHINE_ID_FILE = () => join(agentbeanHome(), "device-id");
 function getFirstMacAddress() {
     const ifaces = os.networkInterfaces();
     for (const [name, addrs] of Object.entries(ifaces)) {
@@ -185,8 +186,9 @@ async function readPlatformMachineId() {
  */
 export async function getDeviceId() {
     // 1. Read cached ID
-    if (existsSync(MACHINE_ID_FILE)) {
-        const cached = readFileSync(MACHINE_ID_FILE, "utf-8").trim();
+    const machineIdFile = MACHINE_ID_FILE();
+    if (existsSync(machineIdFile)) {
+        const cached = readFileSync(machineIdFile, "utf-8").trim();
         if (cached)
             return cached;
     }
@@ -221,10 +223,10 @@ export async function getDeviceId() {
     }
     // 3. Cache to file
     try {
-        const dir = join(os.homedir(), ".agentbean");
+        const dir = agentbeanHome();
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
-        writeFileSync(MACHINE_ID_FILE, deviceId);
+        writeFileSync(machineIdFile, deviceId);
     }
     catch {
         // non-fatal
@@ -308,7 +310,7 @@ export async function scanAgentOSAgents() {
     return [hermes, openclaw].filter((a) => a !== null);
 }
 // --- Scan local agent definitions from filesystem ---
-export async function scanLocalAgents(scanDir = join(os.homedir(), ".agentbean", "agents")) {
+export async function scanLocalAgents(scanDir = localAgentsDir(process.env.AGENTBEAN_PROFILE)) {
     if (!existsSync(scanDir)) {
         return [];
     }

package/dist/workspace-manager.js

@@ -34,6 +34,14 @@ function uniqueDestination(dir, filename) {
     }
     return candidate;
 }
+function fileNamePreference(path) {
+    const name = basename(path).toLowerCase();
+    if (/^ig_[a-f0-9]{32,}\.(png|jpe?g|gif|webp)$/i.test(name))
+        return 0;
+    if (/^(image|output|generated)[._-]?\d*\.(png|jpe?g|gif|webp)$/i.test(name))
+        return 1;
+    return 2;
+}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -94,12 +102,14 @@ export function workspaceEnv(run) {
 }
 export function archiveOutputFiles(run, files) {
     const archived = [];
-    const seen = new Set();
+    const candidates = new Map();
+    const hashOrder = [];
+    const seenPaths = new Set();
     for (const file of files) {
         const abs = isAbsolute(file) ? file : resolve(file);
-        if (seen.has(abs))
+        if (seenPaths.has(abs))
             continue;
-        seen.add(abs);
+        seenPaths.add(abs);
         let st;
         try {
             st = statSync(abs);
@@ -109,6 +119,21 @@ export function archiveOutputFiles(run, files) {
         catch {
             continue;
         }
+        const hash = fileHash(abs);
+        const current = candidates.get(hash);
+        if (!current) {
+            candidates.set(hash, { abs, hash });
+            hashOrder.push(hash);
+        }
+        else if (fileNamePreference(abs) > fileNamePreference(current.abs)) {
+            candidates.set(hash, { abs, hash });
+        }
+    }
+    for (const hash of hashOrder) {
+        const candidate = candidates.get(hash);
+        if (!candidate)
+            continue;
+        const abs = candidate.abs;
         const alreadyInRun = relative(run.runDir, abs);
         const archivedPath = alreadyInRun && !alreadyInRun.startsWith('..') && !isAbsolute(alreadyInRun)
             ? abs
@@ -121,7 +146,7 @@ export function archiveOutputFiles(run, files) {
             archivedPath,
             relativePath: relative(run.agentDir, archivedPath),
             pathKind: 'output',
-            sha256: fileHash(archivedPath),
+            sha256: candidate.hash,
             sizeBytes,
         });
     }

package/package.json

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