@lightcone-ai/daemon 0.9.10 → 0.9.11

package/package.json

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

package/src/agent-manager.js

@@ -5,6 +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 './xhs-login.js';
 
 export class AgentManager {
   constructor({ serverUrl, machineApiKey }) {
@@ -25,6 +26,8 @@ export class AgentManager {
       case 'agent:start':       return this._startAgent(msg, connection);
       case 'agent:stop':        return this._stopAgent(msg.agentId, msg.teamId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
+      case 'xhs:start_login':   return this._startXhsLogin(connection);
+      case 'xhs:stop_login':    return this._stopXhsLogin();
       case 'ping':              return connection.send({ type: 'pong' });
       default:
         console.log(`[AgentManager] Unhandled: ${msg.type}`);
@@ -366,6 +369,21 @@ export class AgentManager {
     this._flushPending(key, connection);
   }
 
+  async _startXhsLogin(connection) {
+    console.log('[AgentManager] Starting XHS login session');
+    try {
+      await startSession(connection);
+    } catch (err) {
+      console.error('[AgentManager] XHS login start failed:', err.message);
+      connection.send({ type: 'xhs:login_error', error: err.message });
+    }
+  }
+
+  _stopXhsLogin() {
+    console.log('[AgentManager] Stopping XHS login session');
+    stopSession();
+  }
+
   _stopAgent(agentId, teamId, connection) {
     const key = this._key(agentId, teamId);
     const agent = this.agents.get(key);

package/src/xhs-login.js

@@ -0,0 +1,202 @@
+/**
+ * XHS (Xiaohongshu) login session via Chrome CDP.
+ * Runs on the daemon machine (VPS) where Chrome is installed.
+ * Screenshots are sent back to the server via the daemon WebSocket connection.
+ */
+import { spawn } from 'child_process';
+import { homedir } from 'os';
+import path from 'path';
+import http from 'http';
+import { WebSocket } from 'ws';
+
+export const XHS_PROFILE_DIR = path.join(homedir(), '.lightcone', 'chrome-profiles', 'xhs');
+
+const CDP_PORT = 9225;
+const CHROME_BIN = process.env.CHROME_BIN ?? '/usr/bin/google-chrome';
+const SCREENSHOT_INTERVAL_MS = 2000;
+const LOGIN_CHECK_INTERVAL_MS = 3000;
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, (res) => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => resolve(body));
+    }).on('error', reject);
+  });
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+export class XhsLoginSession {
+  constructor() {
+    this._proc = null;
+    this._ws = null;
+    this._nextId = 1;
+    this._pending = new Map();
+    this._screenshotTimer = null;
+    this._loginCheckTimer = null;
+  }
+
+  async start(connection) {
+    // Spawn Chrome
+    this._proc = spawn(CHROME_BIN, [
+      `--remote-debugging-port=${CDP_PORT}`,
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+      '--headless=new',
+      `--user-data-dir=${XHS_PROFILE_DIR}`,
+      '--window-size=800,900',
+      'about:blank',
+    ], {
+      stdio: 'ignore',
+      detached: false,
+    });
+
+    this._proc.on('exit', (code) => {
+      console.log(`[XhsLogin] Chrome exited (code=${code})`);
+      this._stopTimers();
+    });
+
+    // Poll for CDP readiness
+    let ready = false;
+    for (let i = 0; i < 20; i++) {
+      await sleep(300);
+      try {
+        await httpGet(`http://localhost:${CDP_PORT}/json/version`);
+        ready = true;
+        break;
+      } catch { /* not ready yet */ }
+    }
+    if (!ready) throw new Error('Chrome CDP did not become ready in time');
+
+    // Get WebSocket debugger URL
+    const pagesJson = await httpGet(`http://localhost:${CDP_PORT}/json`);
+    const pages = JSON.parse(pagesJson);
+    const page = pages.find(p => p.type === 'page') ?? pages[0];
+    if (!page?.webSocketDebuggerUrl) throw new Error('No page websocket URL from CDP');
+
+    await this._connect(page.webSocketDebuggerUrl);
+
+    await this.send('Page.enable', {});
+    await this.send('Network.enable', {});
+    await this.send('Page.navigate', { url: 'https://www.xiaohongshu.com' });
+
+    // Start sending screenshots and checking login
+    this._startPolling(connection);
+  }
+
+  _connect(wsUrl) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.on('open', () => { this._ws = ws; resolve(); });
+      ws.on('message', (data) => {
+        let msg;
+        try { msg = JSON.parse(data.toString()); } catch { return; }
+        if (msg.id != null) {
+          const entry = this._pending.get(msg.id);
+          if (entry) {
+            clearTimeout(entry.timer);
+            this._pending.delete(msg.id);
+            if (msg.error) entry.reject(new Error(msg.error.message ?? 'CDP error'));
+            else entry.resolve(msg.result);
+          }
+        }
+      });
+      ws.on('error', reject);
+      ws.on('close', () => {
+        for (const [, entry] of this._pending) {
+          clearTimeout(entry.timer);
+          entry.reject(new Error('WebSocket closed'));
+        }
+        this._pending.clear();
+        this._ws = null;
+      });
+    });
+  }
+
+  send(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this._ws) return reject(new Error('WebSocket not connected'));
+      const id = this._nextId++;
+      const timer = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`CDP timeout for ${method}`));
+      }, 10_000);
+      this._pending.set(id, { resolve, reject, timer });
+      this._ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  async screenshot() {
+    const result = await this.send('Page.captureScreenshot', { format: 'jpeg', quality: 70 });
+    return result.data; // base64 jpeg
+  }
+
+  async isLoggedIn() {
+    const result = await this.send('Network.getAllCookies', {});
+    const cookies = result.cookies ?? [];
+    return cookies.some(c => c.name === 'web_session' && c.value?.length > 0);
+  }
+
+  _startPolling(connection) {
+    // Send screenshots periodically
+    this._screenshotTimer = setInterval(async () => {
+      try {
+        const screenshot = await this.screenshot();
+        connection.send({ type: 'xhs:screenshot', screenshot });
+      } catch (err) {
+        console.error('[XhsLogin] Screenshot error:', err.message);
+      }
+    }, SCREENSHOT_INTERVAL_MS);
+
+    // Check login status periodically
+    this._loginCheckTimer = setInterval(async () => {
+      try {
+        const loggedIn = await this.isLoggedIn();
+        if (loggedIn) {
+          this._stopTimers();
+          connection.send({ type: 'xhs:login_complete', profileDir: XHS_PROFILE_DIR });
+          this.close();
+        }
+      } catch (err) {
+        console.error('[XhsLogin] Login check error:', err.message);
+      }
+    }, LOGIN_CHECK_INTERVAL_MS);
+  }
+
+  _stopTimers() {
+    if (this._screenshotTimer) { clearInterval(this._screenshotTimer); this._screenshotTimer = null; }
+    if (this._loginCheckTimer) { clearInterval(this._loginCheckTimer); this._loginCheckTimer = null; }
+  }
+
+  close() {
+    this._stopTimers();
+    if (this._ws) {
+      try { this._ws.close(); } catch { /* ignore */ }
+      this._ws = null;
+    }
+    if (this._proc) {
+      try { this._proc.kill('SIGKILL'); } catch { /* ignore */ }
+      this._proc = null;
+    }
+  }
+}
+
+// Singleton
+let _session = null;
+
+export function getSession() { return _session; }
+
+export async function startSession(connection) {
+  if (_session) { _session.close(); _session = null; }
+  _session = new XhsLoginSession();
+  await _session.start(connection);
+  return _session;
+}
+
+export function stopSession() {
+  if (_session) { _session.close(); _session = null; }
+}