@agentbean/daemon 0.1.34 → 0.1.35

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,
@@ -298,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),
@@ -326,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) {
@@ -339,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,38 +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 inviteDeviceId = values['device-id'] ?? await getDeviceId();
-        const auth = await runInviteMode(serverUrl, values.invite, inviteDeviceId);
+        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;
@@ -183,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) {
@@ -291,7 +331,6 @@ async function runInviteMode(serverUrl, inviteCode, deviceId) {
                 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();
@@ -301,7 +340,7 @@ async function runInviteMode(serverUrl, inviteCode, deviceId) {
 }
 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/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/package.json

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