@lightcone-ai/daemon 0.15.59 → 0.15.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.59",
+  "version": "0.15.61",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -2,6 +2,7 @@ import { spawn } from 'child_process';
 import { createHash } from 'crypto';
 import {
   existsSync,
+  cpSync,
   mkdirSync,
   readFileSync,
   readdirSync,
@@ -179,6 +180,48 @@ export class AgentManager {
     return `${workspaceId ?? ''}:${agentId}`;
   }
 
+  /**
+   * Snapshot of agents this daemon process is currently managing. Sent to the
+   * server alongside 'ready' so the server can reconcile lifecycle state
+   * after a reconnect — agents previously on this machine but absent from
+   * the inventory get reset from stale `crashed unreachable` back to a clean
+   * `standby reachable available` baseline (machine is healthy, agent will
+   * be spawned on demand).
+   *
+   * Each entry mirrors the daemon-internal agent state machine:
+   *   - 'starting': spawn in progress (entry exists in this.starting)
+   *   - 'running':  child process is alive (this.agents has it)
+   * The server treats whatever is NOT in this list as 'standby' (spawnable
+   * but not currently running on this machine).
+   */
+  getAgentInventory() {
+    const inventory = [];
+    for (const key of this.starting) {
+      const colonIdx = key.indexOf(':');
+      const workspaceId = colonIdx === -1 ? null : (key.slice(0, colonIdx) || null);
+      const agentId = colonIdx === -1 ? key : key.slice(colonIdx + 1);
+      inventory.push({
+        agentId,
+        workspaceId,
+        runtimeState: 'starting',
+      });
+    }
+    for (const [key, agent] of this.agents.entries()) {
+      const colonIdx = key.indexOf(':');
+      const workspaceId = agent.workspaceId
+        ?? (colonIdx === -1 ? null : (key.slice(0, colonIdx) || null));
+      const agentId = agent.agentId
+        ?? (colonIdx === -1 ? key : key.slice(colonIdx + 1));
+      inventory.push({
+        agentId,
+        workspaceId,
+        runtimeState: 'running',
+        sessionId: agent.sessionId ?? null,
+      });
+    }
+    return inventory;
+  }
+
   handle(msg, connection) {
     switch (msg.type) {
       case 'agent:start':       return this._startAgent(msg, connection);
@@ -188,6 +231,7 @@ export class AgentManager {
       case 'agent:reprobe':     return this._reprobeCapability(msg, connection);
       case 'publish:job':       return this._handlePublishJob(msg, connection);
       case 'browser:start_login': return this._startBrowserLogin(msg, connection);
+      case 'browser:bind_profile': return this._bindBrowserProfile(msg, connection);
       case 'browser:stop_login':  return this._stopBrowserLogin(msg);
       case 'policy_invalidate':   return this._handlePolicyInvalidate(msg, connection);
       case 'credential_revoked':  return this._handleCredentialRevoked(msg, connection);
@@ -1464,6 +1508,34 @@ export class AgentManager {
     }
   }
 
+  _bindBrowserProfile(msg, connection) {
+    const platform = String(msg.platform ?? 'xhs').trim() || 'xhs';
+    const credentialId = String(msg.credentialId ?? '').trim();
+    const sourceProfileDir = String(msg.sourceProfileDir ?? '').trim();
+    if (!credentialId || !sourceProfileDir) {
+      connection.send({
+        type: 'browser:login_error',
+        platform,
+        error: 'browser profile bind missing credentialId/sourceProfileDir',
+      });
+      return;
+    }
+    const targetProfileDir = path.join(homedir(), '.lightcone', 'chrome-profiles', `cred-${credentialId}`);
+    try {
+      if (!existsSync(sourceProfileDir)) {
+        throw new Error(`source profile does not exist: ${sourceProfileDir}`);
+      }
+      rmSync(targetProfileDir, { recursive: true, force: true });
+      mkdirSync(path.dirname(targetProfileDir), { recursive: true });
+      cpSync(sourceProfileDir, targetProfileDir, { recursive: true });
+      console.log(`[AgentManager] Bound browser profile platform=${platform} credential=${credentialId}`);
+      connection.send({ type: 'browser:profile_bound', platform, credentialId });
+    } catch (err) {
+      console.error(`[AgentManager] Failed to bind browser profile (${platform}):`, err.message);
+      connection.send({ type: 'browser:login_error', platform, error: `profile_bind_failed:${err.message}` });
+    }
+  }
+
   _stopBrowserLogin(msg) {
     const platform = msg.platform ?? 'xhs';
     console.log(`[AgentManager] Stopping browser login for platform=${platform}`);

package/src/browser-login.js

@@ -461,6 +461,77 @@ export class BrowserLoginSession {
     return true;
   }
 
+  async _extractAccountIdentity(cookies = []) {
+    if (this._platform !== 'xhs') return null;
+    const result = await this.send('Runtime.evaluate', {
+      expression: `(() => {
+        const out = { externalAccountId: '', externalDisplayName: '', externalAvatarUrl: '' };
+        const seen = new Set();
+        const candidates = [];
+        const push = (value, source) => {
+          if (value == null) return;
+          const text = String(value).trim();
+          if (!text || text.length < 3 || text.length > 160 || seen.has(text)) return;
+          seen.add(text);
+          candidates.push({ value: text, source });
+        };
+        const visit = (obj, source, depth = 0) => {
+          if (!obj || depth > 5) return;
+          if (typeof obj === 'string') {
+            const trimmed = obj.trim();
+            if (!trimmed) return;
+            if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+              try { visit(JSON.parse(trimmed), source, depth + 1); } catch {}
+            }
+            return;
+          }
+          if (typeof obj !== 'object') return;
+          for (const [key, value] of Object.entries(obj)) {
+            const normalizedKey = String(key).toLowerCase();
+            if (['userid', 'user_id', 'user id', 'creatorid', 'creator_id', 'redid', 'red_id', 'authorid', 'author_id', 'accountid', 'account_id'].includes(normalizedKey)) {
+              push(value, source + ':' + key);
+            }
+            if (!out.externalDisplayName && ['nickname', 'nick_name', 'name', 'username', 'user_name'].includes(normalizedKey) && typeof value === 'string') {
+              out.externalDisplayName = value.trim().slice(0, 80);
+            }
+            if (!out.externalAvatarUrl && ['avatar', 'avatarurl', 'avatar_url', 'image'].includes(normalizedKey) && typeof value === 'string' && /^https?:\\/\\//.test(value)) {
+              out.externalAvatarUrl = value.trim();
+            }
+            if (value && typeof value === 'object') visit(value, source + ':' + key, depth + 1);
+            else if (typeof value === 'string' && value.length < 5000) visit(value, source + ':' + key, depth + 1);
+          }
+        };
+        for (const storage of [localStorage, sessionStorage]) {
+          for (let i = 0; i < storage.length; i += 1) {
+            const key = storage.key(i);
+            const value = storage.getItem(key);
+            const lk = String(key || '').toLowerCase();
+            if (/(user|account|creator|red)/.test(lk)) {
+              push(value, 'storage:' + key);
+              visit(value, 'storage:' + key);
+            }
+          }
+        }
+        for (const key of ['__INITIAL_STATE__', '__INITIAL_DATA__', '__REDUX_STATE__']) {
+          if (window[key]) visit(window[key], 'window:' + key);
+        }
+        out.externalAccountId = candidates[0]?.value || '';
+        out.identitySource = candidates[0]?.source || '';
+        return out;
+      })()`,
+      returnByValue: true,
+    }, 5000);
+    const value = result?.result?.value ?? {};
+    const externalAccountId = String(value.externalAccountId ?? '').trim();
+    if (!externalAccountId) return null;
+    return {
+      externalAccountId,
+      externalDisplayName: String(value.externalDisplayName ?? '').trim(),
+      externalAvatarUrl: String(value.externalAvatarUrl ?? '').trim(),
+      identitySource: String(value.identitySource ?? (value.externalAccountId ? 'page' : 'session_cookie')).trim(),
+    };
+  }
+
   _startPolling(connection, baselineSession) {
     let _screenshotInProgress = false;
     this._screenshotTimer = setInterval(async () => {
@@ -485,10 +556,11 @@ export class BrowserLoginSession {
           try {
             const cookieResult = await this.send('Network.getAllCookies', {});
             const baseDomain = new URL(this._config.loginUrl).hostname.split('.').slice(-2).join('.');
-            const cookies = (cookieResult.cookies ?? []).filter(c =>
-              c.domain.includes(baseDomain)
-            );
-            writeFileSync(path.join(this._profileDir, 'cookies.json'), JSON.stringify(cookies));
+	            const cookies = (cookieResult.cookies ?? []).filter(c =>
+	              c.domain.includes(baseDomain)
+	            );
+	            var accountIdentity = await this._extractAccountIdentity(cookies);
+	            writeFileSync(path.join(this._profileDir, 'cookies.json'), JSON.stringify(cookies));
             console.log(`[BrowserLogin][${this._platform}] Saved ${cookies.length} cookies to cookies.json`);
             if (this._platform === 'wechat_mp') {
               const hrefResult = await this.send('Runtime.evaluate', {
@@ -515,9 +587,14 @@ export class BrowserLoginSession {
             closePublisherSession(this._platform);
             console.log(`[BrowserLogin][${this._platform}] Closed stale publisher Chrome session after re-login`);
           } catch {}
-          connection.send({ type: 'browser:login_complete', platform: this._platform, profileDir: this._profileDir });
-          await this.close();
-        }
+	          await this.close();
+	          connection.send({
+	            type: 'browser:login_complete',
+	            platform: this._platform,
+	            profileDir: this._profileDir,
+	            accountIdentity,
+	          });
+	        }
       } catch (err) {
         console.error(`[BrowserLogin][${this._platform}] Login check error:`, err.message);
       }

package/src/connection.js

@@ -45,10 +45,18 @@ function parseOptionalDeviceHints() {
 }
 
 export class DaemonConnection {
-  constructor({ serverUrl, machineApiKey, onMessage }) {
+  constructor({ serverUrl, machineApiKey, onMessage, getAgentInventory }) {
+    if (typeof getAgentInventory !== 'function') {
+      throw new TypeError('DaemonConnection: getAgentInventory callback is required');
+    }
     this.serverUrl = serverUrl.replace(/^http/, 'ws');
     this.machineApiKey = machineApiKey;
     this.onMessage = onMessage;
+    // Snapshot of agents this daemon is currently managing, sent at 'ready'
+    // time. The server uses it to reconcile stale lifecycle state after
+    // reconnects (see src/daemon/index.js 'ready' handler — agents on this
+    // machine but missing from inventory get reset from stale crashed→standby).
+    this.getAgentInventory = getAgentInventory;
     this.ws = null;
     this.reconnectDelay = RECONNECT_INITIAL;
     this.stopped = false;
@@ -111,7 +119,11 @@ export class DaemonConnection {
       ...parseOptionalDeviceHints(),
     };
 
-    console.log(`[Connection] Ready — host=${hostname} runtimes=[${runtimes.join(',')}] v${DAEMON_VERSION}`);
+    const agentInventory = this.getAgentInventory();
+    console.log(
+      `[Connection] Ready — host=${hostname} runtimes=[${runtimes.join(',')}] v${DAEMON_VERSION}`
+      + ` inventory=${agentInventory.length}`
+    );
     this.send({
       type: 'ready',
       hostname,
@@ -119,6 +131,7 @@ export class DaemonConnection {
       runtimes,
       daemonVersion: DAEMON_VERSION,
       deviceHints,
+      agentInventory,
     });
   }
 

package/src/index.js

@@ -58,6 +58,7 @@ const connection = new DaemonConnection({
   serverUrl: SERVER_URL,
   machineApiKey: MACHINE_API_KEY,
   onMessage: (msg) => agentManager.handle(msg, connection),
+  getAgentInventory: () => agentManager.getAgentInventory(),
 });
 
 connection.connect();