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

package/server/routes/android.js

@@ -48,7 +48,7 @@ async function getAndroidController(req) {
   if (runtimeManager && typeof runtimeManager.getAndroidProviderForUser === 'function') {
     return runtimeManager.getAndroidProviderForUser(req.session?.userId);
   }
-  throw new Error('Android controller is unavailable. VM runtime is required.');
+  throw new Error('Android controller is unavailable.');
 }
 
 function getAndroidStatusSnapshot(req) {
@@ -77,17 +77,8 @@ function handleAndroidAction(action) {
 
 router.get('/status', async (req, res) => {
   try {
-    const runtimeManager = req.app?.locals?.runtimeManager;
-    if (!runtimeManager?.hasVmForUser?.(req.session?.userId)) {
-      res.json(getAndroidStatusSnapshot(req));
-      return;
-    }
-    if (!await runtimeManager?.isGuestAgentReadyForUser?.(req.session?.userId, 1000)) {
-      res.json(getAndroidStatusSnapshot(req));
-      return;
-    }
     const controller = await getAndroidController(req);
-    res.json(await controller.getStatus());
+    res.json(await controller.getStatus().catch(() => getAndroidStatusSnapshot(req)));
   } catch (err) {
     res.status(500).json({ error: sanitizeError(err) });
   }

package/server/routes/browser.js

@@ -41,11 +41,11 @@ function getBrowserStatusSnapshot(req) {
 router.get('/status', async (req, res) => {
   try {
     const runtimeManager = req.app?.locals?.runtimeManager;
-    if (!runtimeManager?.hasVmForUser?.(req.session?.userId)) {
+    if (!runtimeManager?.hasVmForUser?.(req.session?.userId, 'browser')) {
       res.json(getBrowserStatusSnapshot(req));
       return;
     }
-    if (!await runtimeManager?.isGuestAgentReadyForUser?.(req.session?.userId, 1000)) {
+    if (!await runtimeManager?.isGuestAgentReadyForUser?.(req.session?.userId, 1000, 'browser')) {
       res.json(getBrowserStatusSnapshot(req));
       return;
     }

package/server/routes/memory.js

@@ -4,6 +4,11 @@ const rateLimit = require('express-rate-limit');
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
+const {
+  buildLlmTransferPrompt,
+  parseLlmTransferText,
+  importanceForCategory,
+} = require('../services/memory/llm_transfer');
 
 router.use(requireAuth);
 
@@ -15,6 +20,16 @@ const apiKeyMutationLimiter = rateLimit({
   legacyHeaders: false,
 });
 
+const transferImportLimiter = rateLimit({
+  windowMs: 10 * 60 * 1000,
+  max: 20,
+  message: { error: 'Too many memory imports, try again later' },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
+const MAX_TRANSFER_TEXT_BYTES = 60 * 1024;
+
 function normalizeMemoryIds(value) {
   return [...new Set(
     (Array.isArray(value) ? value : [])
@@ -262,6 +277,81 @@ router.get('/core', (req, res) => {
   res.json(coreMemory);
 });
 
+// ─────────────────────────────────────────────────────────────────────────────
+// LLM Transfer (prompt + import)
+// ─────────────────────────────────────────────────────────────────────────────
+
+router.get('/transfer-prompt', (req, res) => {
+  const prompt = buildLlmTransferPrompt({ agentLabel: 'NeoAgent' });
+  res.json({ prompt });
+});
+
+router.post('/transfer-import', transferImportLimiter, async (req, res) => {
+  const mm = req.app.locals.memoryManager;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  const text = String(req.body?.text || '').trim();
+  if (!text) {
+    return res.status(400).json({ error: 'text is required' });
+  }
+  if (Buffer.byteLength(text, 'utf8') > MAX_TRANSFER_TEXT_BYTES) {
+    return res.status(413).json({ error: 'text exceeds 60KB limit' });
+  }
+
+  const applyBehaviorNotes = req.body?.applyBehaviorNotes !== false;
+  const applyCoreMemory = req.body?.applyCoreMemory !== false;
+
+  try {
+    const parsed = parseLlmTransferText(text);
+    let importedCount = 0;
+    let skippedCount = 0;
+
+    for (const memory of parsed.memories) {
+      const content = String(memory.content || '').trim();
+      if (!content) {
+        skippedCount += 1;
+        continue;
+      }
+      await mm.saveMemory(userId, content, memory.category, importanceForCategory(memory.category), {
+        agentId,
+        sourceRef: {
+          sourceType: 'llm_import',
+          sourceLabel: 'LLM memory transfer',
+        },
+        metadata: {
+          importedFrom: 'llm_transfer',
+        },
+      });
+      importedCount += 1;
+    }
+
+    let coreUpdatedCount = 0;
+    if (applyCoreMemory && parsed.coreEntries) {
+      for (const [key, value] of Object.entries(parsed.coreEntries)) {
+        if (!key || key === 'active_context') continue;
+        mm.updateCore(userId, key, value, { agentId });
+        coreUpdatedCount += 1;
+      }
+    }
+
+    let behaviorNotesUpdated = false;
+    if (applyBehaviorNotes && parsed.behaviorNotes) {
+      mm.setAssistantBehaviorNotes(userId, parsed.behaviorNotes, { agentId });
+      behaviorNotesUpdated = true;
+    }
+
+    res.json({
+      importedCount,
+      skippedCount,
+      coreUpdatedCount,
+      behaviorNotesUpdated,
+      warnings: parsed.warnings || [],
+    });
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
 router.put('/core/:key', (req, res) => {
   const mm = req.app.locals.memoryManager;
   const userId = req.session.userId;

package/server/routes/social_video.js

@@ -0,0 +1,62 @@
+const express = require('express');
+const { requireAuth } = require('../middleware/auth');
+const { sanitizeError } = require('../utils/security');
+
+const router = express.Router();
+
+router.use(requireAuth);
+
+router.get('/health', async (req, res) => {
+  try {
+    const service = req.app?.locals?.socialVideoService;
+    if (!service || typeof service.getHealthStatus !== 'function') {
+      return res.status(503).json({
+        ready: false,
+        error: 'Social video service is unavailable.',
+      });
+    }
+    const health = await service.getHealthStatus({
+      forceRefresh: req.query?.refresh === '1' || req.query?.refresh === 'true',
+    });
+    return res.json(health);
+  } catch (error) {
+    return res.status(500).json({ error: sanitizeError(error) });
+  }
+});
+
+router.post('/extract', async (req, res) => {
+  try {
+    const service = req.app?.locals?.socialVideoService;
+    if (!service || typeof service.extractFromUrl !== 'function') {
+      return res.status(503).json({ error: 'Social video service is unavailable.' });
+    }
+    if (!req.session || !req.session.userId) {
+      return res.status(401).json({ error: 'Authentication required.' });
+    }
+
+    const sourceUrl = String(req.body?.url || '').trim();
+    if (!sourceUrl) {
+      return res.status(400).json({ error: 'url is required.' });
+    }
+
+    const result = await service.extractFromUrl(req.session.userId, sourceUrl, {
+      includeFrame: req.body?.include_frame !== false,
+      forceStt: req.body?.force_stt === true,
+    });
+
+    if (result?.setup?.ready === false) {
+      return res.status(503).json(result);
+    }
+
+    if (Array.isArray(result.errors) && result.errors.length > 0) {
+      const failed = !result.title && !result.description && !result.transcript && !result.frameImage;
+      return res.status(failed ? 422 : 200).json(result);
+    }
+
+    return res.json(result);
+  } catch (error) {
+    return res.status(500).json({ error: sanitizeError(error) });
+  }
+});
+
+module.exports = router;

package/server/services/ai/capabilityHealth.js

@@ -1,6 +1,5 @@
 const db = require('../../db/database');
 const { getProviderHealthCatalog } = require('./models');
-const { resolveBrowserExecutablePath } = require('../browser/controller');
 const { deriveCloudBrowserBackend } = require('../runtime/settings');
 
 function capabilityEntry(overrides = {}) {
@@ -38,7 +37,6 @@ function summarizeCapabilityHealth(health) {
 
 async function getBrowserHealth(userId, app, engine) {
   const runtimeManager = app?.locals?.runtimeManager || engine?.runtimeManager || null;
-  const executablePath = resolveBrowserExecutablePath();
   const runtimeSettings = typeof runtimeManager?.getSettings === 'function'
     ? runtimeManager.getSettings(userId)
     : null;
@@ -83,12 +81,11 @@ async function getBrowserHealth(userId, app, engine) {
 
   if (!controller && resolutionError) {
     return capabilityEntry({
-      configured: Boolean(executablePath),
+      configured: true,
       healthy: false,
       degraded: true,
       summary: `Browser controller resolution failed: ${resolutionError.message}`,
       details: {
-        executablePath: executablePath || null,
         error: resolutionError.message,
       },
     });
@@ -108,20 +105,15 @@ async function getBrowserHealth(userId, app, engine) {
 
   return capabilityEntry({
     connected: launched,
-    configured: Boolean(executablePath),
-    healthy: Boolean(executablePath) && !error,
+    configured: true,
+    healthy: !error,
     degraded: Boolean(error) || runtimeSettings?.browser_backend === 'extension',
     summary: error
       ? `Browser runtime error: ${error}`
       : runtimeSettings?.browser_backend === 'extension'
-        ? executablePath
-          ? `No extension device is active. Falling back to the ${deriveCloudBrowserBackend(runtimeSettings)} browser runtime.`
-          : 'No extension device is active and no browser executable was found for Puppeteer.'
-        : executablePath
-          ? (launched ? 'Browser runtime is ready.' : 'Browser executable is available but not launched.')
-          : 'No browser executable was found for Puppeteer.',
+        ? `No extension device is active. Falling back to the ${deriveCloudBrowserBackend(runtimeSettings)} browser runtime.`
+        : (launched ? 'Browser runtime is ready.' : 'Browser runtime is available but not launched.'),
     details: {
-      executablePath: executablePath || null,
       preferredBackend: runtimeSettings?.browser_backend || null,
       backend: runtimeSettings?.browser_backend === 'extension'
         ? deriveCloudBrowserBackend(runtimeSettings)
@@ -175,7 +167,7 @@ async function getAndroidHealth(userId, app, engine) {
       summary: status.lastStartError
         ? `Android tooling reported: ${status.lastStartError}`
         : bootstrapped
-          ? 'Android environment is bootstrapped.'
+          ? 'Android environment is ready on this host.'
           : (canBootstrap ? 'Android environment can be bootstrapped on this host.' : 'Android tooling cannot bootstrap on this host.'),
       details: status,
     });

package/server/services/ai/systemPrompt.js

@@ -94,6 +94,7 @@ Separate facts from inferences. If you are inferring from logs, code, or partial
 When evidence conflicts, state the conflict instead of smoothing it over.
 Source priority for factual work is: direct tool output and first-party integrations in this run, then authoritative primary sources, then other web sources, then model memory. Search-result snippets, link previews, and remembered facts are leads, not evidence.
 If the user provides a URL, open or fetch that URL before describing its contents unless the user only wants formatting help with the URL itself.
+If the user sends only a video link with no extra instruction, default to researching and fact-checking the video's key claims and context.
 
 DON'T REPEAT YOURSELF
 State a limitation or error once. If the user pushes back, try a different approach before restating the same failure. Repeating the same dead-end across five messages is useless.

package/server/services/ai/toolResult.js

@@ -112,6 +112,26 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
       });
       break;
 
+    case 'social_video_extract':
+      envelope = trimObject({
+        tool: toolName,
+        platform: toolResult?.platform,
+        sourceUrl: toolResult?.sourceUrl,
+        resolvedUrl: toolResult?.resolvedUrl,
+        title: clampText(toolResult?.title || '', Math.floor(softLimit * 0.25)),
+        description: clampText(toolResult?.description || '', Math.floor(softLimit * 0.25)),
+        transcriptSource: toolResult?.transcriptSource,
+        transcriptPreview: lineExcerpt(toolResult?.transcript || '', 6, Math.floor(softLimit * 0.35)),
+        frameImage: trimObject({
+          url: toolResult?.frameImage?.url,
+          source: toolResult?.frameImage?.source,
+        }),
+        setupReady: toolResult?.setup?.ready,
+        warningCount: Array.isArray(toolResult?.warnings) ? toolResult.warnings.length : 0,
+        errorCount: Array.isArray(toolResult?.errors) ? toolResult.errors.length : 0,
+      });
+      break;
+
     case 'android_dump_ui':
     case 'android_observe':
       envelope = trimObject({

package/server/services/ai/tools.js

@@ -1267,6 +1267,19 @@ function getAvailableTools(app, options = {}) {
                 },
                 required: ['query']
             }
+        },
+        {
+            name: 'social_video_extract',
+            description: 'Extract title, description, transcript, and one representative frame image from a public social video URL (YouTube, TikTok, Instagram, or X) without social API keys.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Public social video URL.' },
+                    include_frame: { type: 'boolean', description: 'Whether to return one representative frame image artifact (default true).' },
+                    force_stt: { type: 'boolean', description: 'Force speech-to-text fallback even if captions are present.' }
+                },
+                required: ['url']
+            }
         }
     ];
 
@@ -1392,6 +1405,7 @@ async function executeTool(toolName, args, context, engine) {
     const sk = () => app?.locals?.skillRunner || engine.skillRunner;
     const taskRuntime = () => app?.locals?.taskRuntime || engine.taskRuntime;
     const rec = () => app?.locals?.recordingManager || null;
+    const socialVideo = () => app?.locals?.socialVideoService || null;
     const widgets = () => app?.locals?.widgetService || null;
     const artifactStore = app?.locals?.artifactStore || null;
 
@@ -1950,6 +1964,21 @@ async function executeTool(toolName, args, context, engine) {
             };
         }
 
+        case 'social_video_extract': {
+            const service = socialVideo();
+            if (!service || typeof service.extractFromUrl !== 'function') {
+                return { error: 'Social video extraction service is unavailable.' };
+            }
+            const sourceUrl = String(args.url || '').trim();
+            if (!sourceUrl) {
+                return { error: 'url is required' };
+            }
+            return await service.extractFromUrl(userId, sourceUrl, {
+                includeFrame: args.include_frame !== false,
+                forceStt: args.force_stt === true,
+            });
+        }
+
         case 'memory_write': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();

package/server/services/android/android_bootstrap_worker.js

@@ -10,10 +10,10 @@ function parseBoolean(value) {
 async function main() {
   const controller = new AndroidController({
     userId: process.env.NEOAGENT_ANDROID_BOOTSTRAP_USER_ID || null,
-    runtimeBackend: 'vm',
+    runtimeBackend: 'host',
   });
   const headless = parseBoolean(process.env.NEOAGENT_ANDROID_BOOTSTRAP_HEADLESS);
-  const timeoutMs = Math.max(120000, Number(process.env.NEOAGENT_ANDROID_BOOTSTRAP_TIMEOUT_MS) || 240000);
+  const timeoutMs = Math.max(120000, Number(process.env.NEOAGENT_ANDROID_BOOTSTRAP_TIMEOUT_MS) || 600000);
 
   try {
     await controller.bootstrapEmulator({ headless, timeoutMs });