neoagent 2.1.5 → 2.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"052f31d115eceda8cbff1b3481fcde4330c4ae
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "315305623" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "204310170" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/android/controller.js

@@ -47,6 +47,18 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function tailFile(filePath, maxLines = 40) {
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8')
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+    return lines.slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
+
 function commandExists(command) {
   const probe = spawnSync('bash', ['-lc', `command -v "${command}"`], { encoding: 'utf8' });
   return probe.status === 0;
@@ -270,25 +282,75 @@ function systemImageTagScore(tag) {
   return 0;
 }
 
+function parseSystemImageCandidates(entries = []) {
+  return entries.map((entry) => {
+    const platform = parseSystemImagePlatform(entry.platformId);
+    return {
+      packageName: entry.packageName,
+      platformId: entry.platformId,
+      tag: entry.tag,
+      arch: entry.arch,
+      apiLevel: platform.apiLevel,
+      stable: platform.stable,
+      tagScore: systemImageTagScore(entry.tag),
+    };
+  });
+}
+
 function parseSystemImages(listOutput) {
   const matches = [];
   const regex = /system-images;(android-[^;\s]+);([^;\s]+);([^;\s]+)/g;
   let match = regex.exec(listOutput);
   while (match) {
-    const platform = parseSystemImagePlatform(match[1]);
     matches.push({
       packageName: match[0],
       platformId: match[1],
       tag: match[2],
       arch: match[3],
-      apiLevel: platform.apiLevel,
-      stable: platform.stable,
-      tagScore: systemImageTagScore(match[2]),
     });
     match = regex.exec(listOutput);
   }
 
-  return matches;
+  return parseSystemImageCandidates(matches);
+}
+
+function parseInstalledSystemImages() {
+  const root = path.join(SDK_ROOT, 'system-images');
+  if (!fs.existsSync(root)) {
+    return [];
+  }
+
+  const matches = [];
+  const platforms = fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+
+  for (const platformId of platforms) {
+    const platformDir = path.join(root, platformId);
+    const tags = fs.readdirSync(platformDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name);
+    for (const tag of tags) {
+      const tagDir = path.join(platformDir, tag);
+      const archs = fs.readdirSync(tagDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+      for (const arch of archs) {
+        const packageXml = path.join(tagDir, arch, 'package.xml');
+        if (!fs.existsSync(packageXml)) {
+          continue;
+        }
+        matches.push({
+          packageName: `system-images;${platformId};${tag};${arch}`,
+          platformId,
+          tag,
+          arch,
+        });
+      }
+    }
+  }
+
+  return parseSystemImageCandidates(matches);
 }
 
 function rankSystemImagePool(pool) {
@@ -297,8 +359,8 @@ function rankSystemImagePool(pool) {
 
   rankedPool.sort((a, b) =>
     Number(b.stable) - Number(a.stable) ||
-    b.apiLevel - a.apiLevel ||
     b.tagScore - a.tagScore ||
+    b.apiLevel - a.apiLevel ||
     a.packageName.localeCompare(b.packageName)
   );
 
@@ -306,7 +368,9 @@ function rankSystemImagePool(pool) {
 }
 
 function chooseConfiguredSystemImage(listOutput) {
-  const matches = parseSystemImages(listOutput);
+  const matches = Array.isArray(listOutput)
+    ? parseSystemImageCandidates(listOutput)
+    : parseSystemImages(listOutput);
   const packageName = configuredSystemImagePackage();
   if (packageName) {
     return matches.find((candidate) => candidate.packageName === packageName) || null;
@@ -328,7 +392,9 @@ function chooseConfiguredSystemImage(listOutput) {
 }
 
 function chooseLatestSystemImage(listOutput, preferredArchs = systemImageArchCandidates()) {
-  const matches = parseSystemImages(listOutput);
+  const matches = Array.isArray(listOutput)
+    ? parseSystemImageCandidates(listOutput)
+    : parseSystemImages(listOutput);
   const archPool = Array.isArray(preferredArchs) && preferredArchs.length > 0
     ? preferredArchs
     : systemImageArchCandidates();
@@ -347,7 +413,10 @@ function chooseLatestSystemImage(listOutput, preferredArchs = systemImageArchCan
 }
 
 function formatSystemImageError(listOutput) {
-  const availableArchs = [...new Set(parseSystemImages(listOutput).map((candidate) => candidate.arch))].sort();
+  const candidates = Array.isArray(listOutput)
+    ? parseSystemImageCandidates(listOutput)
+    : parseSystemImages(listOutput);
+  const availableArchs = [...new Set(candidates.map((candidate) => candidate.arch))].sort();
   const wantedArchs = systemImageArchCandidates().join(', ');
   const packageName = configuredSystemImagePackage();
   const platformId = configuredSystemImagePlatform();
@@ -489,12 +558,27 @@ class AndroidController {
     }
 
     const state = readState();
-    if (
-      state.bootstrapped === true &&
-      state.systemImage &&
-      !shouldForceSdkRefresh()
-    ) {
-      return;
+    if (!shouldForceSdkRefresh()) {
+      const installedImages = parseInstalledSystemImages();
+      if (installedImages.length > 0) {
+        const preferredInstalled =
+          chooseConfiguredSystemImage(installedImages) ||
+          chooseLatestSystemImage(installedImages);
+        if (
+          preferredInstalled &&
+          preferredInstalled.packageName !== state.systemImage
+        ) {
+          appendState({
+            bootstrapped: true,
+            systemImage: preferredInstalled.packageName,
+            apiLevel: preferredInstalled.apiLevel,
+            systemImageArch: preferredInstalled.arch,
+          });
+        }
+        return;
+      } else if (state.bootstrapped === true && state.systemImage) {
+        return;
+      }
     }
 
     appendState({ bootstrapped: true });
@@ -693,7 +777,6 @@ class AndroidController {
       stdio: ['ignore', out, out],
       env: sdkEnv(),
     });
-    child.unref();
 
     console.log(`[Android] Emulator process started (pid ${child.pid})`);
     appendState({
@@ -706,7 +789,38 @@ class AndroidController {
       lastLogLine: 'Android emulator process started. Waiting for boot completion...',
     });
 
-    const onlineSerial = await this.waitForDevice({ timeoutMs: options.timeoutMs || 240000 });
+    const processExit = new Promise((resolve) => {
+      child.once('exit', (code, signal) => {
+        resolve({ code, signal });
+      });
+      child.once('error', (error) => {
+        resolve({ code: null, signal: null, error });
+      });
+    });
+
+    child.unref();
+
+    const bootResult = await Promise.race([
+      this.waitForDevice({ timeoutMs: options.timeoutMs || 240000 }).then((serial) => ({
+        serial,
+        exited: false,
+      })),
+      processExit.then((result) => ({
+        exited: true,
+        ...result,
+      })),
+    ]);
+
+    if (bootResult.exited) {
+      const recentLogLines = tailFile(logPath, 12);
+      const lastLine =
+        bootResult.error?.message ||
+        recentLogLines[recentLogLines.length - 1] ||
+        `Emulator process exited before boot completed (code ${bootResult.code ?? 'unknown'}, signal ${bootResult.signal ?? 'none'}).`;
+      throw new Error(lastLine);
+    }
+
+    const onlineSerial = bootResult.serial;
     appendState({
       serial: onlineSerial,
       emulatorPid: child.pid,
@@ -772,14 +886,17 @@ class AndroidController {
         lastLogLine: 'Android start requested.',
       });
       const startPromise = this.#startEmulatorBlocking(options).catch((err) => {
+        const state = readState();
+        const recentLogLines = state.logPath ? tailFile(state.logPath, 12) : [];
+        const detailedMessage = recentLogLines[recentLogLines.length - 1] || err.message;
         appendState({
           starting: false,
           startupPhase: 'Start failed',
-          lastStartError: err.message,
-          lastLogLine: err.message,
+          lastStartError: detailedMessage,
+          lastLogLine: detailedMessage,
         });
-        console.error('[Android] Emulator start failed:', err.message);
-        throw err;
+        console.error('[Android] Emulator start failed:', detailedMessage);
+        throw new Error(detailedMessage);
       }).finally(() => {
         if (this.startPromise === startPromise) {
           this.startPromise = null;