neoagent 2.3.1-beta.11 → 2.3.1-beta.111

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

@@ -7,6 +7,11 @@ const APK_UPLOAD_ROOT = path.resolve(
     || path.join(DATA_DIR, 'uploads', 'android-apks'),
 );
 const MAX_APK_BYTES = Number(process.env.NEOAGENT_ANDROID_APK_MAX_BYTES || 512 * 1024 * 1024);
+const IDLE_TIMEOUT_MS = Number(process.env.NEOAGENT_VM_IDLE_TIMEOUT_MS || 10 * 60 * 1000);
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 function assertPathInside(baseDir, candidatePath, label) {
   const resolvedBase = path.resolve(baseDir);
@@ -22,27 +27,49 @@ 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 = '') {
+  constructor(baseUrl, token = '', options = {}) {
     this.baseUrl = String(baseUrl || '').replace(/\/+$/, '');
     this.token = String(token || '').trim();
+    this.onActivity = options.onActivity || null;
   }
 
   async waitForHealth(options = {}) {
-    const timeoutMs = Number(options.timeoutMs || 120000);
+    const timeoutMs = Number(options.timeoutMs || 600000); // Increased from 120s to 10m for bootstrap
     const intervalMs = Number(options.intervalMs || 1000);
+    const checkLiveness = options.checkLiveness || (() => true);
     const startedAt = Date.now();
     let lastError = null;
 
     while (Date.now() - startedAt < timeoutMs) {
+      if (!checkLiveness()) {
+        throw new Error('Guest runtime process exited unexpectedly during bootstrap.');
+      }
+      const elapsed = Math.round((Date.now() - startedAt) / 1000);
       try {
-        const health = await this.request('GET', '/health');
+        const health = await this.request('GET', '/health', undefined, { timeoutMs: 2000 });
         if (health?.status === 'ok') {
+          console.log(`[Runtime] Guest agent ready after ${elapsed}s`);
           return health;
         }
         lastError = new Error('Guest agent health check returned a non-ok status.');
       } catch (error) {
         lastError = error;
+        if (elapsed % 10 === 0) {
+          console.log(`[Runtime] Waiting for guest agent health... (${elapsed}s elapsed, last error: ${error.message})`);
+        }
       }
       await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
@@ -53,26 +80,54 @@ class RuntimeHttpClient {
     throw new Error('Timed out waiting for the guest runtime to become ready.');
   }
 
-  async request(method, pathname, body) {
-    const response = await fetch(`${this.baseUrl}${pathname}`, {
-      method,
-      headers: {
-        'content-type': 'application/json',
-        ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
-      },
-      body: body === undefined ? undefined : JSON.stringify(body),
-    });
+  async request(method, pathname, body, options = {}) {
+    const retryCount = Math.max(0, Number(options.retryCount ?? 6));
+    const retryDelayMs = Math.max(100, Number(options.retryDelayMs ?? 1000));
+    let lastError = null;
 
-    const contentType = response.headers.get('content-type') || '';
-    const payload = contentType.includes('application/json')
-      ? await response.json().catch(() => ({}))
-      : { text: await response.text().catch(() => '') };
+    for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+      const controller = options.timeoutMs ? new AbortController() : null;
+      const timer = controller ? setTimeout(() => controller.abort(new Error(`Request timed out after ${options.timeoutMs} ms.`)), options.timeoutMs) : null;
+      try {
+        const response = await fetch(`${this.baseUrl}${pathname}`, {
+          method,
+          headers: {
+            'content-type': 'application/json',
+            ...(this.token ? { authorization: `Bearer ${this.token}` } : {}),
+          },
+          body: body === undefined ? undefined : JSON.stringify(body),
+          signal: controller?.signal,
+        });
 
-    if (!response.ok) {
-      const errorMessage = payload?.error || payload?.text || `Runtime request failed: ${response.status}`;
-      throw new Error(errorMessage);
+        const contentType = response.headers.get('content-type') || '';
+        const payload = contentType.includes('application/json')
+          ? await response.json().catch(() => ({}))
+          : { text: await response.text().catch(() => '') };
+
+        if (!response.ok) {
+          const errorMessage = payload?.error || payload?.text || `Runtime request failed: ${response.status}`;
+          throw new Error(errorMessage);
+        }
+        if (typeof this.onActivity === 'function') {
+          this.onActivity();
+        }
+        return payload;
+      } catch (error) {
+        lastError = error;
+        const message = String(error?.message || error);
+        const retryable = /fetch failed|ECONNREFUSED|ECONNRESET|socket hang up|timed out/i.test(message);
+        if (!retryable || attempt === retryCount) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
     }
-    return payload;
+
+    throw lastError || new Error('Runtime request failed.');
   }
 
   async requestStream(method, pathname, stream, options = {}) {
@@ -88,6 +143,10 @@ class RuntimeHttpClient {
       duplex: 'half',
     });
 
+    if (response.ok && typeof this.onActivity === 'function') {
+      this.onActivity();
+    }
+
     const contentType = response.headers.get('content-type') || '';
     const payload = contentType.includes('application/json')
       ? await response.json().catch(() => ({}))
@@ -110,13 +169,63 @@ class VmBrowserProvider {
   }
 
   async #materialize(result) {
-    if (!result || !result.fullPath || !this.artifactStore || this.userId == null) {
+    if (!result || !this.artifactStore || this.userId == null) {
       return result;
     }
-    const file = await this.client.request('POST', '/files/read', {
-      path: result.fullPath,
-      encoding: 'base64',
-    });
+
+    const readablePathCandidates = [];
+    if (result.fullPath) {
+      readablePathCandidates.push(String(result.fullPath));
+    }
+    if (typeof result.screenshotPath === 'string' && result.screenshotPath.trim() !== '') {
+      readablePathCandidates.push(result.screenshotPath);
+    }
+    if (readablePathCandidates.length === 0) {
+      return result;
+    }
+
+    let file = null;
+    const maxAttempts = 20;
+    for (let attempt = 0; attempt < maxAttempts && !file?.content; attempt += 1) {
+      for (const candidate of readablePathCandidates) {
+        try {
+          file = await this.client.request('POST', '/files/read', {
+            path: candidate,
+            encoding: 'base64',
+          });
+          if (file?.content) {
+            break;
+          }
+        } catch (error) {
+          if (attempt === maxAttempts - 1) {
+            console.warn('[Runtime:browser_vm] screenshot materialization read failed', {
+              userId: this.userId,
+              candidate,
+              error: String(error?.message || error),
+            });
+          }
+        }
+      }
+      if (!file?.content) {
+        await sleep(250);
+      }
+    }
+    if (!file?.content) {
+      if (typeof result.screenshotPath === 'string' && result.screenshotPath.trim() !== '') {
+        console.warn('[Runtime:browser_vm] unresolved VM screenshot path suppressed', {
+          userId: this.userId,
+          screenshotPath: result.screenshotPath,
+        });
+        return {
+          ...result,
+          screenshotPath: null,
+          artifactId: result.artifactId || null,
+          fullPath: result.fullPath || null,
+        };
+      }
+      return result;
+    }
+
     const allocation = this.artifactStore.allocateFile(this.userId, {
       kind: 'browser-screenshot',
       backend: 'vm',
@@ -163,143 +272,52 @@ class VmBrowserProvider {
     const status = await this.client.request('GET', '/browser/status');
     return Number(status?.pages || 0);
   }
+  async getCookies() {
+    return this.client.request('GET', '/browser/cookies');
+  }
   async setHeadless(value) {
-    this.headless = value !== false && value !== 'false';
-    return { success: false, unsupported: true };
+    this.headless = true;
+    return { success: true };
   }
 }
 
-class VmAndroidProvider {
-  constructor(client, options = {}) {
-    this.client = client;
-    this.userId = options.userId;
+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;
-  }
-
-  async #promoteBinary(pathname, kind, contentType, extension) {
-    if (!pathname || !this.artifactStore || this.userId == null || /^\/api\/artifacts\//.test(pathname)) {
-      return { url: pathname, artifactId: null, fullPath: null };
-    }
-    const file = await this.client.request('POST', '/files/read', {
-      path: pathname,
-      encoding: 'base64',
-    });
-    const allocation = this.artifactStore.allocateFile(this.userId, {
-      kind,
-      backend: 'vm',
-      extension,
-      contentType,
-      filenameBase: kind,
-    });
-    fs.writeFileSync(allocation.storagePath, Buffer.from(String(file.content || ''), 'base64'));
-    this.artifactStore.finalizeFile(allocation.artifactId, allocation.storagePath);
-    return {
-      url: allocation.url,
-      artifactId: allocation.artifactId,
-      fullPath: allocation.storagePath,
-    };
-  }
+    this.lastActivity = new Map();
+    this.reaperInterval = null;
 
-  async #promoteText(pathname, kind, contentType, extension) {
-    if (!pathname || !this.artifactStore || this.userId == null || /^\/api\/artifacts\//.test(pathname)) {
-      return { url: pathname, artifactId: null };
+    if (IDLE_TIMEOUT_MS > 0) {
+      this.#startIdleReaper();
     }
-    const file = await this.client.request('POST', '/files/read', {
-      path: pathname,
-      encoding: 'utf8',
-    });
-    const artifact = this.artifactStore.createTextArtifact(this.userId, {
-      kind,
-      backend: 'vm',
-      extension,
-      contentType,
-      filenameBase: kind,
-      content: String(file.content || ''),
-    });
-    return {
-      url: artifact.url,
-      artifactId: artifact.artifactId,
-    };
   }
 
-  async #materializeObservation(result = {}) {
-    if (!result || typeof result !== 'object') return result;
-    let next = { ...result };
-    if (result.fullPath) {
-      const screenshot = await this.#promoteBinary(result.fullPath, 'android-screenshot', 'image/png', 'png');
-      next = {
-        ...next,
-        screenshotPath: screenshot.url,
-        artifactId: screenshot.artifactId || next.artifactId || null,
-        fullPath: screenshot.fullPath,
-      };
+  #touch(userId) {
+    const key = String(userId || '').trim();
+    if (key) {
+      this.lastActivity.set(key, Date.now());
     }
-    if (result.uiDumpPath && !/^https?:|^\/api\/artifacts\//.test(String(result.uiDumpPath))) {
-      const dump = await this.#promoteText(result.uiDumpPath, 'android-ui-dump', 'application/xml', 'xml');
-      next = {
-        ...next,
-        uiDumpPath: dump.url,
-        uiDumpArtifactId: dump.artifactId || next.uiDumpArtifactId || null,
-      };
-    }
-    return next;
   }
 
-  getStatus() { return this.client.request('GET', '/android/status'); }
-  requestStartEmulator(options = {}) { return this.client.request('POST', '/android/start', options); }
-  startEmulator(options = {}) { return this.requestStartEmulator(options); }
-  stopEmulator() { return this.client.request('POST', '/android/stop'); }
-  listDevices() { return this.client.request('GET', '/android/devices').then((result) => result.devices || []); }
-  async screenshot(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/screenshot', options)); }
-  async observe(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/observe', options)); }
-  async dumpUi(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/ui-dump', options)); }
-  listApps(options = {}) {
-    const query = options.includeSystem === true ? '?includeSystem=true' : '';
-    return this.client.request('GET', `/android/apps${query}`);
-  }
-  async openApp(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/open-app', options)); }
-  async openIntent(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/open-intent', options)); }
-  async tap(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/tap', options)); }
-  async longPress(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/long-press', options)); }
-  async type(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/type', options)); }
-  async swipe(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/swipe', options)); }
-  async pressKey(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/press-key', options)); }
-  async waitFor(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/wait-for', options)); }
-  async shell(options = {}) { return this.#materializeObservation(await this.client.request('POST', '/android/shell', options)); }
-  async installApk(options = {}) {
-    const apkPath = assertPathInside(
-      APK_UPLOAD_ROOT,
-      String(options.apkPath || ''),
-      'APK path',
-    );
-    const stat = await fs.promises.stat(apkPath).catch(() => null);
-    if (!stat || !stat.isFile()) {
-      throw new Error(`APK not found: ${apkPath}`);
-    }
-    if (stat.size > MAX_APK_BYTES) {
-      throw new Error(`APK is too large: ${stat.size} bytes (limit ${MAX_APK_BYTES}).`);
-    }
-    return this.client.requestStream(
-      'POST',
-      '/android/install-apk-stream',
-      fs.createReadStream(apkPath),
-      {
-        contentType: 'application/octet-stream',
-        contentLength: stat.size,
-        headers: {
-          'x-neoagent-filename': encodeURIComponent(path.basename(apkPath)),
-        },
-      },
-    );
-  }
-  close() { return Promise.resolve(); }
-}
-
-class LocalVmExecutionBackend {
-  constructor(options = {}) {
-    this.vmManager = options.vmManager;
-    this.token = options.token || process.env.NEOAGENT_VM_GUEST_TOKEN || '';
-    this.artifactStore = options.artifactStore || null;
+  #startIdleReaper() {
+    if (this.reaperInterval) return;
+    this.reaperInterval = setInterval(async () => {
+      const now = Date.now();
+      for (const [userId, lastUsed] of this.lastActivity.entries()) {
+        if (now - lastUsed > IDLE_TIMEOUT_MS) {
+          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:${this.runtimeProfile}] Failed to shut down idle VM for user ${userId}:`, err.message);
+          }
+        }
+      }
+    }, Math.min(IDLE_TIMEOUT_MS, 60 * 1000));
   }
 
   async #clientForUser(userId) {
@@ -307,10 +325,18 @@ class LocalVmExecutionBackend {
       throw new Error('Local VM manager is not available.');
     }
     const session = await this.vmManager.ensureVm(userId);
-    const client = new RuntimeHttpClient(session.baseUrl, this.token);
+    this.#touch(userId);
+    const client = new RuntimeHttpClient(session.baseUrl, session.guestToken || this.token, {
+      onActivity: () => this.#touch(userId),
+    });
     try {
       await client.waitForHealth({
-        timeoutMs: Number(process.env.NEOAGENT_VM_BOOT_TIMEOUT_MS || 120000),
+        timeoutMs: Number(process.env.NEOAGENT_VM_BOOT_TIMEOUT_MS || 20 * 60 * 1000),
+        checkLiveness: () => {
+          const key = String(userId || '').trim();
+          const session = this.vmManager.instances.get(key);
+          return Boolean(session && session.process && isPidAlive(session.process.pid));
+        },
       });
     } catch (error) {
       const runtimeError = typeof session.getLastError === 'function' ? session.getLastError() : '';
@@ -332,6 +358,14 @@ class LocalVmExecutionBackend {
     });
   }
 
+  async killCommand(userId, pid, reason = 'aborted') {
+    const client = await this.#clientForUser(userId);
+    return client.request('POST', '/exec/kill', {
+      pid,
+      reason,
+    });
+  }
+
   async getBrowserProviderForUser(userId) {
     return new VmBrowserProvider(await this.#clientForUser(userId), {
       userId,
@@ -339,14 +373,44 @@ class LocalVmExecutionBackend {
     });
   }
 
-  async getAndroidProviderForUser(userId) {
-    return new VmAndroidProvider(await this.#clientForUser(userId), {
-      userId,
-      artifactStore: this.artifactStore,
-    });
+  async getCommandExecutorForUser(userId) {
+    return {
+      execute: (command, options = {}) => this.executeCommand(userId, command, options),
+      executeInteractive: (command, inputs = [], options = {}) => this.executeCommand(userId, command, {
+        ...options,
+        pty: true,
+        inputs,
+      }),
+      kill: (pid, reason = 'aborted') => this.killCommand(userId, pid, reason),
+    };
+  }
+
+  async isGuestAgentReadyForUser(userId, timeoutMs = 1000) {
+    if (!this.vmManager) {
+      return false;
+    }
+    const key = String(userId || '').trim();
+    if (!key) {
+      return false;
+    }
+    const session = this.vmManager.instances?.get?.(key);
+    if (!session?.baseUrl) {
+      return false;
+    }
+    const client = new RuntimeHttpClient(session.baseUrl, this.token);
+    try {
+      await client.request('GET', '/health', undefined, { timeoutMs });
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   async shutdown() {
+    if (this.reaperInterval) {
+      clearInterval(this.reaperInterval);
+      this.reaperInterval = null;
+    }
     await this.vmManager?.shutdown?.();
   }
 }
@@ -354,6 +418,5 @@ class LocalVmExecutionBackend {
 module.exports = {
   LocalVmExecutionBackend,
   RuntimeHttpClient,
-  VmAndroidProvider,
   VmBrowserProvider,
 };