@lightcone-ai/daemon 0.9.62 → 0.9.64

package/package.json

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

package/src/agent-manager.js

@@ -5,7 +5,7 @@ import path from 'path';
 import { buildSystemPrompt } from './drivers/claude.js';
 import { buildCodexSpawn, buildCodexSystemPrompt, parseCodexLine } from './drivers/codex.js';
 import { buildKimiSpawn, buildKimiInitMessages, parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
-import { startSession, stopSession } from './browser-login.js';
+import { startSession, stopSession, stopAllSessions } from './browser-login.js';
 import { buildSkillMcpServers } from './mcp-config.js';
 
 export class AgentManager {
@@ -35,11 +35,12 @@ export class AgentManager {
     }
   }
 
-  stopAll() {
+  async stopAll() {
     for (const [, agent] of this.agents) {
       if (agent.proc) agent.proc.kill();
     }
     this.agents.clear();
+    await stopAllSessions();
   }
 
   // ── private ───────────────────────────────────────────────────────────────
@@ -355,7 +356,7 @@ export class AgentManager {
   _stopBrowserLogin(msg) {
     const platform = msg.platform ?? 'xhs';
     console.log(`[AgentManager] Stopping browser login for platform=${platform}`);
-    stopSession(platform);
+    return stopSession(platform);
   }
 
   _stopAgent(agentId, teamId, connection) {

package/src/browser-login.js

@@ -41,11 +41,7 @@ export const PLATFORM_CONFIGS = {
         .map(e => ({ e, r: e.getBoundingClientRect() }))
         .filter(({ r }) => r.top <= boxRect.top + 120 && r.right >= boxRect.right - 140)
         .sort((a, b) => (b.r.right + boxRect.top - b.r.top) - (a.r.right + boxRect.top - a.r.top))[0]?.e;
-      if (corner) {
-        const target = corner.closest('button, [role="button"], a, div') || corner;
-        target.click();
-        return 'corner-qr-icon';
-      }
+      if (corner) return { via: 'corner-qr-icon', rect: corner.getBoundingClientRect().toJSON() };
       return null;
     `,
     getSessionValue: (cookies) =>
@@ -135,6 +131,7 @@ export class BrowserLoginSession {
     this._loginCheckTimer = null;
     this._profileDir = null;
     this._profileLock = null;
+    this._closing = null;
   }
 
   async start(connection, userId) {
@@ -227,24 +224,8 @@ export class BrowserLoginSession {
       // Try to click the QR scan login tab if present (some platforms default to password login)
       if (this._config.qrTabSelector) {
         try {
-          const selectors = this._config.qrTabSelector;
-          const qrResult = await this.send('Runtime.evaluate', {
-            expression: `(function() {
-              const sels = ${JSON.stringify(selectors)};
-              for (const s of sels) {
-                const el = document.querySelector(s);
-                if (el) { el.click(); return s; }
-              }
-            // Also try text-based search
-            const all = [...document.querySelectorAll('a,button,span,div')];
-            const el = all.find(e => e.innerText?.trim() === '扫码登录' || e.innerText?.trim() === '二维码登录');
-            if (el) { el.click(); return 'text:' + el.innerText.trim(); }
-            ${this._config.qrFallbackScript ?? ''}
-            return null;
-          })()`,
-            returnByValue: true,
-          });
-          console.log(`[BrowserLogin][${this._platform}] QR switch result: ${qrResult.result?.value ?? 'not-found'}`);
+          const qrResult = await this._switchToQrLogin();
+          console.log(`[BrowserLogin][${this._platform}] QR switch result: ${qrResult?.via ?? 'not-found'}`);
           await sleep(1000);
         } catch (err) {
           console.error(`[BrowserLogin][${this._platform}] QR switch failed: ${err.message}`);
@@ -305,6 +286,54 @@ export class BrowserLoginSession {
     return result.data;
   }
 
+  async _switchToQrLogin() {
+    const selectors = this._config.qrTabSelector ?? [];
+    const result = await this.send('Runtime.evaluate', {
+      expression: `(function() {
+        const visible = (el) => {
+          const r = el.getBoundingClientRect();
+          const cs = getComputedStyle(el);
+          return r.width > 0 && r.height > 0 && cs.display !== 'none' && cs.visibility !== 'hidden';
+        };
+        const hit = (el, via) => {
+          if (!el) return null;
+          const target = el.closest('button, [role="button"], a') || el;
+          const rect = target.getBoundingClientRect();
+          if (rect.width <= 0 || rect.height <= 0) return null;
+          return { via, rect: rect.toJSON() };
+        };
+
+        const sels = ${JSON.stringify(selectors)};
+        for (const s of sels) {
+          const el = document.querySelector(s);
+          if (el && visible(el)) return hit(el, s);
+        }
+
+        const textElements = [...document.querySelectorAll('a,button,span,div')].filter(visible);
+        const textEl = textElements.find(e => {
+          const t = (e.innerText || e.textContent || '').trim();
+          return t === '扫码登录' || t === '二维码登录' || t === '扫码';
+        });
+        const textHit = hit(textEl, textEl ? 'text:' + (textEl.innerText || textEl.textContent || '').trim() : '');
+        if (textHit) return textHit;
+
+        ${this._config.qrFallbackScript ?? 'return null;'}
+      })()`,
+      returnByValue: true,
+    });
+
+    const hit = result.result?.value;
+    const rect = hit?.rect;
+    if (!rect) return null;
+
+    const x = Math.round(rect.left + rect.width / 2);
+    const y = Math.round(rect.top + rect.height / 2);
+    await this.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }, 5_000);
+    await this.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 }, 5_000);
+    await this.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 }, 5_000);
+    return { via: hit.via, x, y };
+  }
+
   async isLoggedIn(baseline) {
     const result = await this.send('Network.getAllCookies', {});
     return this._config.isLoggedIn(result.cookies ?? [], baseline);
@@ -344,7 +373,7 @@ export class BrowserLoginSession {
             console.error(`[BrowserLogin][${this._platform}] Failed to save cookies: ${err.message}`);
           }
           connection.send({ type: 'browser:login_complete', platform: this._platform, profileDir: this._profileDir });
-          this.close();
+          await this.close();
         }
       } catch (err) {
         console.error(`[BrowserLogin][${this._platform}] Login check error:`, err.message);
@@ -367,13 +396,17 @@ export class BrowserLoginSession {
   }
 
   async close() {
-    this._stopTimers();
-    // Use CDP Browser.close for graceful shutdown so Chrome flushes cookies to disk
-    try { await this.send('Browser.close', {}, 3000); } catch {}
-    await sleep(1000);
-    if (this._ws) { try { this._ws.close(); } catch {} this._ws = null; }
-    if (this._proc) { try { this._proc.kill('SIGKILL'); } catch {} this._proc = null; }
-    if (this._profileLock) { this._profileLock.release(); this._profileLock = null; }
+    if (this._closing) return this._closing;
+    this._closing = (async () => {
+      this._stopTimers();
+      // Use CDP Browser.close for graceful shutdown so Chrome flushes cookies to disk
+      try { await this.send('Browser.close', {}, 3000); } catch {}
+      await sleep(1000);
+      if (this._ws) { try { this._ws.close(); } catch {} this._ws = null; }
+      if (this._proc) { try { this._proc.kill('SIGKILL'); } catch {} this._proc = null; }
+      if (this._profileLock) { this._profileLock.release(); this._profileLock = null; }
+    })();
+    return this._closing;
   }
 }
 
@@ -385,14 +418,26 @@ export function getSession(platform) { return _sessions.get(platform) ?? null; }
 
 export async function startSession(platform, connection, userId) {
   const existing = _sessions.get(platform);
-  if (existing) { existing.close(); _sessions.delete(platform); }
+  if (existing) { await existing.close(); _sessions.delete(platform); }
   const session = new BrowserLoginSession(platform);
   _sessions.set(platform, session);
-  await session.start(connection, userId);
-  return session;
+  try {
+    await session.start(connection, userId);
+    return session;
+  } catch (err) {
+    _sessions.delete(platform);
+    await session.close();
+    throw err;
+  }
 }
 
-export function stopSession(platform) {
+export async function stopSession(platform) {
   const session = _sessions.get(platform);
-  if (session) { session.close(); _sessions.delete(platform); }
+  if (session) { await session.close(); _sessions.delete(platform); }
+}
+
+export async function stopAllSessions() {
+  const sessions = [..._sessions.values()];
+  _sessions.clear();
+  await Promise.allSettled(sessions.map(session => session.close()));
 }

package/src/index.js

@@ -3,6 +3,7 @@ import 'dotenv/config';
 import { createRequire } from 'module';
 import { DaemonConnection } from './connection.js';
 import { AgentManager } from './agent-manager.js';
+import { releaseProfileLocksForProcess } from './profile-lock.js';
 
 const { version } = createRequire(import.meta.url)('../package.json');
 
@@ -42,5 +43,18 @@ const connection = new DaemonConnection({
 
 connection.connect();
 
-process.on('SIGINT',  () => { connection.stop(); agentManager.stopAll(); process.exit(0); });
-process.on('SIGTERM', () => { connection.stop(); agentManager.stopAll(); process.exit(0); });
+let shuttingDown = false;
+async function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log(`[Daemon] Shutting down (${signal})`);
+  connection.stop();
+  try { await agentManager.stopAll(); } catch (err) { console.error('[Daemon] Shutdown error:', err.message); }
+  releaseProfileLocksForProcess();
+  process.exit(0);
+}
+
+process.on('SIGINT',  () => { shutdown('SIGINT'); });
+process.on('SIGTERM', () => { shutdown('SIGTERM'); });
+process.on('SIGHUP',  () => { shutdown('SIGHUP'); });
+process.on('exit', () => { releaseProfileLocksForProcess(); });

package/src/profile-lock.js

@@ -1,6 +1,7 @@
 import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync, statSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
+import { randomUUID } from 'crypto';
 
 const LOCK_ROOT = path.join(homedir(), '.lightcone', 'profile-locks');
 const DEFAULT_STALE_MS = 20 * 60 * 1000;
@@ -37,6 +38,28 @@ function isStale(dir, staleMs) {
   }
 }
 
+function pidIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM';
+  }
+}
+
+function isAbandoned(dir) {
+  const info = lockInfo(dir);
+  if (!info?.pid) return false;
+  return !pidIsAlive(info.pid);
+}
+
+function removeLockDir(dir) {
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+}
+
+const heldLocks = new Map();
+
 export async function acquireProfileLock(platform, profileDir, {
   owner = 'unknown',
   timeoutMs = DEFAULT_TIMEOUT_MS,
@@ -50,21 +73,26 @@ export async function acquireProfileLock(platform, profileDir, {
   while (true) {
     try {
       mkdirSync(dir);
+      const token = randomUUID();
       const release = () => {
-        try { rmSync(dir, { recursive: true, force: true }); } catch {}
+        const info = lockInfo(dir);
+        heldLocks.delete(dir);
+        if (!info || info.token === token || info.pid === process.pid) removeLockDir(dir);
       };
       writeFileSync(path.join(dir, 'owner.json'), JSON.stringify({
         platform,
         profileDir,
         owner,
         pid: process.pid,
+        token,
         createdAt: new Date().toISOString(),
       }, null, 2));
+      heldLocks.set(dir, token);
       return { release, dir };
     } catch (err) {
       if (err.code !== 'EEXIST') throw err;
-      if (existsSync(dir) && isStale(dir, staleMs)) {
-        try { rmSync(dir, { recursive: true, force: true }); } catch {}
+      if (existsSync(dir) && (isAbandoned(dir) || isStale(dir, staleMs))) {
+        removeLockDir(dir);
         continue;
       }
       if (Date.now() >= deadline) {
@@ -76,6 +104,14 @@ export async function acquireProfileLock(platform, profileDir, {
   }
 }
 
+export function releaseProfileLocksForProcess() {
+  for (const [dir, token] of heldLocks) {
+    const info = lockInfo(dir);
+    if (!info || info.token === token || info.pid === process.pid) removeLockDir(dir);
+    heldLocks.delete(dir);
+  }
+}
+
 export async function withProfileLock(platform, profileDir, options, fn) {
   const lock = await acquireProfileLock(platform, profileDir, options);
   try {