@lightcone-ai/daemon 0.9.62 → 0.9.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.9.62",
+  "version": "0.9.63",
   "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

@@ -135,6 +135,7 @@ export class BrowserLoginSession {
     this._loginCheckTimer = null;
     this._profileDir = null;
     this._profileLock = null;
+    this._closing = null;
   }
 
   async start(connection, userId) {
@@ -344,7 +345,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 +368,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 +390,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 {