neoagent 2.3.1-beta.85 → 2.3.1-beta.87

package/server/services/browser/controller.js

@@ -26,6 +26,7 @@ const VIEWPORTS = [
 
 function resolveBrowserExecutablePath() {
   const explicitPath =
+    process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH ||
     process.env.PUPPETEER_EXECUTABLE_PATH ||
     process.env.CHROME_BIN ||
     process.env.CHROMIUM_BIN;
@@ -34,7 +35,6 @@ function resolveBrowserExecutablePath() {
 
   const bundledCandidates = [
     () => require('playwright-chromium').chromium.executablePath(),
-    () => require('playwright').chromium.executablePath(),
   ];
   for (const resolveBundled of bundledCandidates) {
     try {
@@ -76,22 +76,11 @@ function resolveBrowserExecutablePath() {
   return platformCandidates.find((candidate) => fs.existsSync(candidate)) || null;
 }
 
-function resolveFirefoxExecutablePath() {
-  try {
-    const bundledPath = require('playwright').firefox.executablePath();
-    return bundledPath && fs.existsSync(bundledPath) ? bundledPath : null;
-  } catch {
-    return null;
-  }
-}
-
 function installPlaywrightBrowserBinary(browserName) {
-  const packageRoot = path.dirname(require.resolve('playwright/package.json'));
+  const packageRoot = path.dirname(require.resolve('playwright-chromium/package.json'));
   const cliPath = path.join(packageRoot, 'cli.js');
   return new Promise((resolve, reject) => {
-    const args = browserName === 'chromium'
-      ? [cliPath, 'install', '--no-shell', 'chromium']
-      : [cliPath, 'install', browserName];
+    const args = [cliPath, 'install', '--no-shell', browserName];
     const child = spawn(process.execPath, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
     });
@@ -161,13 +150,29 @@ function normalizeWaitUntil(waitUntil) {
   return 'domcontentloaded';
 }
 
+function clearChromiumSingletonLocks(profileDir) {
+  const lockEntries = [
+    'SingletonLock',
+    'SingletonSocket',
+    'SingletonCookie',
+    'SingletonStartupLock',
+    'DevToolsActivePort',
+  ];
+  for (const entry of lockEntries) {
+    const targetPath = path.join(profileDir, entry);
+    try {
+      fs.rmSync(targetPath, { force: true, recursive: true });
+    } catch {}
+  }
+}
+
 class BrowserController {
   constructor(options = {}) {
     this.io = options.io || null;
     this.userId = options.userId != null ? String(options.userId) : null;
     this.artifactStore = options.artifactStore || null;
     this.runtimeBackend = options.runtimeBackend || 'host';
-    this.engine = this.runtimeBackend === 'vm' && process.platform === 'linux' ? 'firefox' : 'chromium';
+    this.engine = 'chromium';
     this.browser = null;
     this.context = null;
     this.page = null;
@@ -327,9 +332,7 @@ class BrowserController {
       this._userAgent = USER_AGENTS[rand(0, USER_AGENTS.length - 1)];
       this._viewport = VIEWPORTS[rand(0, VIEWPORTS.length - 1)];
 
-      let executablePath = this.engine === 'firefox'
-        ? resolveFirefoxExecutablePath()
-        : resolveBrowserExecutablePath();
+      let executablePath = resolveBrowserExecutablePath();
       if (!executablePath) {
         if (!this.browserBinaryInstallPromise) {
           this.browserBinaryInstallPromise = installPlaywrightBrowserBinary(this.engine);
@@ -339,9 +342,7 @@ class BrowserController {
         } finally {
           this.browserBinaryInstallPromise = null;
         }
-        executablePath = this.engine === 'firefox'
-          ? resolveFirefoxExecutablePath()
-          : resolveBrowserExecutablePath();
+        executablePath = resolveBrowserExecutablePath();
       }
 
       if (!executablePath) {
@@ -353,53 +354,35 @@ class BrowserController {
         ...(this.displayValue ? { DISPLAY: this.displayValue } : {}),
       };
 
-      if (this.engine === 'firefox') {
-        const { firefox } = require('playwright');
-        this.context = await firefox.launchPersistentContext(this.profileDir, {
-          headless: false,
-          executablePath,
-          env: launchEnv,
-          viewport: this._viewport,
-          userAgent: this._userAgent,
-          locale: 'en-US',
-          extraHTTPHeaders: {
-            'Accept-Language': 'en-US,en;q=0.9',
-          },
-          firefoxUserPrefs: {
-            'browser.shell.checkDefaultBrowser': false,
-            'browser.startup.homepage': 'about:blank',
-          },
-        });
-        this.browser = typeof this.context.browser === 'function' ? this.context.browser() : null;
-        this.page = this.context.pages()[0] || await this.context.newPage();
-      } else {
-        const puppeteer = require('puppeteer-core');
-        this.browser = await puppeteer.launch({
-          headless: false,
-          executablePath,
-          userDataDir: this.profileDir,
-          env: launchEnv,
-          args: [
-            '--no-sandbox',
-            '--disable-setuid-sandbox',
-            '--disable-dev-shm-usage',
-            '--disable-crash-reporter',
-            '--disable-background-networking',
-            '--disable-component-update',
-            '--disable-blink-features=AutomationControlled',
-            '--disable-infobars',
-            '--no-first-run',
-            '--no-default-browser-check',
-            '--disable-gpu',
-            '--lang=en-US,en',
-            `--window-size=${this._viewport.width},${this._viewport.height}`,
-          ],
-          defaultViewport: this._viewport,
-          ignoreDefaultArgs: ['--enable-automation'],
-          timeout: 120000,
-        });
-        this.page = await this.browser.newPage();
-      }
+      const launchArgs = [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-crash-reporter',
+        '--disable-background-networking',
+        '--disable-component-update',
+        '--disable-blink-features=AutomationControlled',
+        '--disable-infobars',
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-gpu',
+        '--lang=en-US,en',
+        `--window-size=${this._viewport.width},${this._viewport.height}`,
+      ];
+
+      const playwright = require('playwright-chromium');
+      clearChromiumSingletonLocks(this.profileDir);
+      this.context = await playwright.chromium.launchPersistentContext(this.profileDir, {
+        headless: false,
+        executablePath,
+        env: launchEnv,
+        args: launchArgs,
+        viewport: this._viewport,
+        ignoreHTTPSErrors: false,
+        timeout: 120000,
+      });
+      this.browser = typeof this.context.browser === 'function' ? this.context.browser() : null;
+      this.page = this.context.pages()[0] || await this.context.newPage();
       await this._applyStealthToPage(this.page);
     })();
 

package/server/services/manager.js

@@ -13,6 +13,7 @@ const { WidgetService } = require('./widgets/service');
 const { setupWebSocket } = require('./websocket');
 const { registerMessagingAutomation } = require('./messaging/automation');
 const { RecordingManager } = require('./recordings/manager');
+const { SocialVideoService } = require('./social_video');
 const { VoiceRuntimeManager } = require('./voice/runtimeManager');
 const { AuthProviderManager } = require('./account/auth_provider_manager');
 const { IntegrationManager } = require('./integrations/manager');
@@ -318,6 +319,19 @@ function createRecordingManager(app, io) {
   return recordingManager;
 }
 
+function createSocialVideoService(app) {
+  const socialVideoService = registerLocal(
+    app,
+    'socialVideoService',
+    new SocialVideoService({
+      artifactStore: app.locals.artifactStore,
+      runtimeManager: app.locals.runtimeManager,
+    }),
+  );
+  logServiceReady('Social video service ready');
+  return socialVideoService;
+}
+
 function createWidgetService(app) {
   const widgetService = registerLocal(
     app,
@@ -460,6 +474,7 @@ async function startServices(app, io) {
 
     const messagingManager = createMessagingManager(app, io, agentEngine);
     const recordingManager = createRecordingManager(app, io);
+    createSocialVideoService(app);
     createWidgetService(app);
     createWearableService(app);
     createScreenRecorder(app);

package/server/services/memory/llm_transfer.js

@@ -0,0 +1,217 @@
+const HEADING_ALIASES = {
+  profile: 'identity',
+  identity: 'identity',
+  preferences: 'preferences',
+  preference: 'preferences',
+  projects: 'projects',
+  project: 'projects',
+  contacts: 'contacts',
+  contact: 'contacts',
+  events: 'events',
+  event: 'events',
+  tasks: 'tasks',
+  task: 'tasks',
+  'assistant self': 'assistant_self',
+  self: 'assistant_self',
+  'behavior notes': '__behavior_notes',
+  'assistant behavior notes': '__behavior_notes',
+  'core memory': '__core',
+  'core memories': '__core',
+  'other memories': 'episodic',
+  other: 'episodic',
+  misc: 'episodic',
+  miscellaneous: 'episodic',
+};
+
+const SECTION_PRIORITY = {
+  identity: 8,
+  preferences: 7,
+  projects: 6,
+  contacts: 6,
+  events: 6,
+  tasks: 6,
+  assistant_self: 7,
+  episodic: 5,
+};
+
+const MAX_MEMORY_LENGTH = 1200;
+const MAX_MEMORIES = 200;
+
+function normalizeHeadingLabel(input) {
+  return String(input || '')
+    .trim()
+    .replace(/^#+\s*/, '')
+    .replace(/[:]+$/g, '')
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+}
+
+function detectHeading(line) {
+  const trimmed = String(line || '').trim();
+  if (!trimmed) return null;
+  const normalized = normalizeHeadingLabel(trimmed);
+  if (HEADING_ALIASES[normalized]) return normalized;
+  return null;
+}
+
+function splitSections(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const sections = [];
+  let current = { heading: 'other', lines: [] };
+
+  for (const line of lines) {
+    const heading = detectHeading(line);
+    if (heading) {
+      if (current.lines.length || current.heading) {
+        sections.push(current);
+      }
+      current = { heading, lines: [] };
+      continue;
+    }
+    current.lines.push(line);
+  }
+
+  if (current.lines.length || current.heading) {
+    sections.push(current);
+  }
+
+  return sections;
+}
+
+function collectBulletItems(lines) {
+  const items = [];
+  for (const line of lines) {
+    const match = String(line || '').match(/^\s*(?:[-*]|\u2022|\d+\.)\s+(.*)$/);
+    if (match && match[1]) {
+      const value = match[1].trim();
+      if (value) items.push(value);
+    }
+  }
+  return items;
+}
+
+function collapseParagraph(lines) {
+  const parts = lines
+    .map((line) => String(line || '').trim())
+    .filter((line) => line.length > 0);
+  if (!parts.length) return '';
+  return parts.join(' ');
+}
+
+function normalizeMemoryContent(text) {
+  const cleaned = String(text || '').trim();
+  if (!cleaned) return '';
+  if (cleaned.length <= MAX_MEMORY_LENGTH) return cleaned;
+  return cleaned.slice(0, MAX_MEMORY_LENGTH).trim();
+}
+
+function buildLlmTransferPrompt({ agentLabel = 'NeoAgent' } = {}) {
+  return [
+    'You are preparing a memory export for ' + agentLabel + '.',
+    'Return a concise, structured, natural language summary of everything you remember about the user.',
+    '',
+    'Rules:',
+    '- Use only plain text. No JSON or code blocks.',
+    '- Use short bullet points where possible.',
+    '- Omit secrets, passwords, API keys, or anything sensitive.',
+    '- If a section has no data, omit the section.',
+    '',
+    'Use these sections and formatting:',
+    '# Profile',
+    '- Key identity facts about the user.',
+    '# Preferences',
+    '- Stable preferences, likes, dislikes, habits.',
+    '# Projects',
+    '- Ongoing projects, goals, responsibilities.',
+    '# Contacts',
+    '- Important people or organizations and the relationship.',
+    '# Events',
+    '- Important dates or recurring events.',
+    '# Tasks',
+    '- Open tasks or commitments the user expects to remember.',
+    '# Behavior Notes',
+    'Short guidance for how the assistant should behave.',
+    '# Core Memory',
+    'key: value entries for critical facts that should always be pinned.',
+    '# Other Memories',
+    '- Anything else that does not fit above.',
+  ].join('\n');
+}
+
+function parseLlmTransferText(text) {
+  const sections = splitSections(text);
+  const memories = [];
+  const coreEntries = {};
+  let behaviorNotes = '';
+  const warnings = [];
+
+  for (const section of sections) {
+    const heading = normalizeHeadingLabel(section.heading || 'other');
+    const alias = HEADING_ALIASES[heading] || 'episodic';
+    const lines = section.lines || [];
+
+    if (alias === '__behavior_notes') {
+      const notes = collapseParagraph(lines);
+      if (notes) behaviorNotes = notes;
+      continue;
+    }
+
+    if (alias === '__core') {
+      for (const rawLine of lines) {
+        const line = String(rawLine || '').trim();
+        if (!line) continue;
+        const cleanedLine = line.replace(/^[-*]\s*/, '');
+        const colonIndex = cleanedLine.indexOf(':');
+        if (colonIndex <= 0) continue;
+        const key = cleanedLine.slice(0, colonIndex).trim();
+        const value = cleanedLine.slice(colonIndex + 1).trim();
+        if (!key || !value) continue;
+        if (key === 'active_context') continue;
+        coreEntries[key] = value;
+      }
+      continue;
+    }
+
+    const bulletItems = collectBulletItems(lines);
+    if (bulletItems.length) {
+      for (const item of bulletItems) {
+        const content = normalizeMemoryContent(item);
+        if (!content) continue;
+        memories.push({
+          category: alias,
+          content,
+        });
+      }
+      continue;
+    }
+
+    const paragraph = normalizeMemoryContent(collapseParagraph(lines));
+    if (paragraph) {
+      memories.push({
+        category: alias,
+        content: paragraph,
+      });
+    }
+  }
+
+  if (memories.length > MAX_MEMORIES) {
+    warnings.push('Import exceeded ' + MAX_MEMORIES + ' items; extra entries were skipped.');
+  }
+
+  return {
+    memories: memories.slice(0, MAX_MEMORIES),
+    coreEntries,
+    behaviorNotes,
+    warnings,
+  };
+}
+
+function importanceForCategory(category) {
+  return SECTION_PRIORITY[category] || 5;
+}
+
+module.exports = {
+  buildLlmTransferPrompt,
+  parseLlmTransferText,
+  importanceForCategory,
+};

package/server/services/runtime/backends/local-vm.js

@@ -23,6 +23,18 @@ function assertPathInside(baseDir, candidatePath, label) {
   return resolvedCandidate;
 }
 
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 class RuntimeHttpClient {
   constructor(baseUrl, token = '', options = {}) {
     this.baseUrl = String(baseUrl || '').replace(/\/+$/, '');
@@ -341,6 +353,7 @@ class VmAndroidProvider {
 class LocalVmExecutionBackend {
   constructor(options = {}) {
     this.vmManager = options.vmManager;
+    this.runtimeProfile = options.runtimeProfile === 'android' ? 'android' : 'browser_cli';
     this.token = options.token || process.env.NEOAGENT_VM_GUEST_TOKEN || '';
     this.artifactStore = options.artifactStore || null;
     this.lastActivity = new Map();
@@ -364,12 +377,12 @@ class LocalVmExecutionBackend {
       const now = Date.now();
       for (const [userId, lastUsed] of this.lastActivity.entries()) {
         if (now - lastUsed > IDLE_TIMEOUT_MS) {
-          console.log(`[Runtime] User ${userId} runtime idle for ${Math.round((now - lastUsed) / 1000)}s, shutting down VM.`);
+          console.log(`[Runtime:${this.runtimeProfile}] User ${userId} runtime idle for ${Math.round((now - lastUsed) / 1000)}s, shutting down VM.`);
           this.lastActivity.delete(userId);
           try {
             await this.vmManager?.killVm?.(userId);
           } catch (err) {
-            console.error(`[Runtime] Failed to shut down idle VM for user ${userId}:`, err.message);
+            console.error(`[Runtime:${this.runtimeProfile}] Failed to shut down idle VM for user ${userId}:`, err.message);
           }
         }
       }
@@ -391,7 +404,7 @@ class LocalVmExecutionBackend {
         checkLiveness: () => {
           const key = String(userId || '').trim();
           const session = this.vmManager.instances.get(key);
-          return session && session.process && !session.process.killed && session.process.exitCode === null;
+          return Boolean(session && session.process && isPidAlive(session.process.pid));
         },
       });
     } catch (error) {