neoagent 2.3.1-beta.89 → 2.3.1-beta.91

package/server/services/runtime/manager.js

@@ -1,31 +1,51 @@
+'use strict';
+
 const { LocalVmExecutionBackend } = require('./backends/local-vm');
-const { QemuVmManager } = require('./qemu');
+const { DockerVMManager } = require('./docker-vm-manager');
 const { getRuntimeSettings } = require('./settings');
 const { ExtensionBrowserProvider } = require('../browser/extension/provider');
 const { AndroidController } = require('../android/controller');
+const { DesktopProvider } = require('../desktop/provider');
+
+// Resource defaults for Docker VMs (overridable via env).
+const DEFAULT_VM_MEMORY_MB = Number(process.env.NEOAGENT_VM_MEMORY_MB ?? 2048);
+const DEFAULT_VM_CPUS = Number(process.env.NEOAGENT_VM_CPUS ?? 2);
 
 class RuntimeManager {
   constructor(options = {}) {
     this.browserExtensionRegistry = options.browserExtensionRegistry || null;
-    const browserVmManager = options.browserVmManager || new QemuVmManager({
+    this.desktopCompanionRegistry = options.desktopCompanionRegistry || null;
+
+    const browserVmManager = options.browserVmManager || new DockerVMManager({
       runtimeProfile: 'browser_cli',
-      memoryMb: 2048,
-      cpus: 2,
-      warmup: false,
+      image: 'mcr.microsoft.com/playwright:v1.44.0-focal',
+      memoryMb: DEFAULT_VM_MEMORY_MB,
+      cpus: DEFAULT_VM_CPUS,
     });
     this.browserBackend = new LocalVmExecutionBackend({
       runtimeProfile: 'browser_cli',
       vmManager: browserVmManager,
       artifactStore: options.artifactStore,
     });
-    this.androidControllers = new Map();
-    this.getExtensionBrowserProvider = options.getExtensionBrowserProvider || ((userId) => new ExtensionBrowserProvider({
-      registry: options.browserExtensionRegistry,
-      artifactStore: options.artifactStore,
-      userId,
-    }));
+
+    this.artifactStore = options.artifactStore || null;
+
+    this.getExtensionBrowserProvider = options.getExtensionBrowserProvider
+      || ((userId) => new ExtensionBrowserProvider({
+        registry: options.browserExtensionRegistry,
+        artifactStore: options.artifactStore,
+        userId,
+      }));
+
+    this.getDesktopCliProvider = options.getDesktopCliProvider
+      || ((userId) => new DesktopProvider({
+        registry: options.desktopCompanionRegistry,
+        artifactStore: options.artifactStore,
+        userId,
+      }));
   }
 
+
   getSettings(userId) {
     return getRuntimeSettings(userId);
   }
@@ -38,8 +58,17 @@ class RuntimeManager {
     );
   }
 
+  hasActiveDesktopCompanion(userId) {
+    return Boolean(
+      this.desktopCompanionRegistry
+      && typeof this.desktopCompanionRegistry.isConnected === 'function'
+      && this.desktopCompanionRegistry.isConnected(userId)
+    );
+  }
+
   resolveBackend(userId, requested) {
     void userId;
+    void requested;
     return this.browserBackend;
   }
 
@@ -49,9 +78,6 @@ class RuntimeManager {
   }
 
   hasVmForUser(userId, capability = 'browser') {
-    if (capability === 'android') {
-      return Boolean(this.androidControllers.get(String(userId || '').trim()));
-    }
     return Boolean(this.browserBackend?.vmManager?.hasVm?.(userId));
   }
 
@@ -71,34 +97,25 @@ class RuntimeManager {
     return this.browserBackend.getBrowserProviderForUser(userId);
   }
 
+  async getCliProviderForUser(userId) {
+    const settings = this.getSettings(userId);
+    if (settings.cli_backend === 'desktop' && this.hasActiveDesktopCompanion(userId)) {
+      return this.getDesktopCliProvider(userId);
+    }
+    return this.browserBackend.getCommandExecutorForUser(userId);
+  }
+
   async getAndroidProviderForUser(userId) {
-    const key = String(userId || '').trim();
-    if (!key) {
+    if (userId == null || String(userId).trim() === '') {
       throw new Error('Android provider requires a user ID.');
     }
-    if (!this.androidControllers.has(key)) {
-      this.androidControllers.set(key, new AndroidController({
-        userId: key,
-        runtimeBackend: 'host',
-        artifactStore: null,
-      }));
-    }
-    return this.androidControllers.get(key);
+    return new AndroidController({
+      userId: String(userId).trim(),
+      artifactStore: this.artifactStore,
+    });
   }
 
   async isGuestAgentReadyForUser(userId, timeoutMs = 1000, capability = 'browser') {
-    if (capability === 'android') {
-      const controller = this.androidControllers.get(String(userId || '').trim());
-      if (!controller || typeof controller.getStatus !== 'function') {
-        return false;
-      }
-      try {
-        const status = await controller.getStatus();
-        return Boolean(status?.bootstrapped || status?.serial || status?.starting);
-      } catch {
-        return false;
-      }
-    }
     if (typeof this.browserBackend?.isGuestAgentReadyForUser !== 'function') {
       return false;
     }
@@ -108,9 +125,7 @@ class RuntimeManager {
   async shutdown() {
     await Promise.allSettled([
       this.browserBackend?.shutdown?.(),
-      ...[...this.androidControllers.values()].map((controller) => controller?.stopEmulator?.().catch?.(() => {})),
     ]);
-    this.androidControllers.clear();
   }
 }
 

package/server/services/runtime/settings.js

@@ -9,6 +9,7 @@ function createDefaultRuntimeSettings() {
     browser_backend: policy.runtimeDefaults.browser_backend,
     android_backend: policy.runtimeDefaults.android_backend,
     mcp_backend: policy.runtimeDefaults.mcp_backend,
+    cli_backend: policy.runtimeDefaults.cli_backend ?? 'vm',
   };
 }
 
@@ -24,6 +25,7 @@ const BASE_FALLBACK_SETTINGS = Object.freeze({
   browser_backend: 'vm',
   android_backend: 'host',
   mcp_backend: 'host-remote',
+  cli_backend: 'vm',
 });
 
 const RUNTIME_SETTING_KEYS = Object.freeze(Object.keys(DEFAULT_RUNTIME_SETTINGS));
@@ -42,6 +44,7 @@ function deriveDefaultsForProfile(profile) {
         runtime_backend: 'vm',
         browser_backend: 'vm',
         android_backend: 'host',
+        cli_backend: 'vm',
       };
   }
 }
@@ -53,21 +56,18 @@ function normalizeRuntimeSettings(raw = {}) {
   const derived = deriveDefaultsForProfile(profile);
   const runtimeBackend = normalizeChoice(raw.runtime_backend, ['vm'], derived.runtime_backend);
   const browserBackend = normalizeChoice(raw.browser_backend, ['vm', 'extension'], derived.browser_backend);
-  const androidBackend = normalizeChoice(raw.android_backend, ['host', 'vm'], derived.android_backend);
+  const cliBackend = normalizeChoice(raw.cli_backend, ['vm', 'desktop'], derived.cli_backend ?? 'vm');
+  const androidBackend = 'host';
   return {
     runtime_profile: profile === 'trusted-host' ? 'secure-vm' : profile,
     runtime_backend: runtimeBackend,
     browser_backend: browserBackend === 'extension' ? 'extension' : 'vm',
-    android_backend: androidBackend === 'vm' ? 'host' : androidBackend,
+    android_backend: androidBackend,
     mcp_backend: 'host-remote',
+    cli_backend: cliBackend === 'desktop' ? 'desktop' : 'vm',
   };
 }
 
-function deriveCloudBrowserBackend(raw = {}) {
-  normalizeRuntimeSettings(raw);
-  return 'vm';
-}
-
 function parseStoredRuntimeValue(key, value) {
   if (typeof value !== 'string') {
     return value;
@@ -102,8 +102,11 @@ function validateRuntimeSettings(raw = {}) {
     if (settings.browser_backend !== 'vm' && settings.browser_backend !== 'extension') {
       issues.push('This deployment requires the VM browser backend or a paired browser extension backend.');
     }
-    if (settings.android_backend !== 'host') {
-      issues.push('This deployment requires the host Android backend.');
+    if (settings.android_backend !== 'host' && settings.android_backend !== 'vm') {
+      issues.push('This deployment requires a supported Android backend.');
+    }
+    if (settings.cli_backend !== 'vm' && settings.cli_backend !== 'desktop') {
+      issues.push('This deployment requires a supported CLI backend.');
     }
   }
 
@@ -154,7 +157,6 @@ function getRuntimeSettings(userId) {
 module.exports = {
   DEFAULT_RUNTIME_SETTINGS,
   RUNTIME_SETTING_KEYS,
-  deriveCloudBrowserBackend,
   ensureDefaultRuntimeSettings,
   getRuntimeSettings,
   normalizeRuntimeSettings,

package/server/services/runtime/validation.js

@@ -25,7 +25,10 @@ function getRuntimeValidation(runtimeManager) {
   return {
     ready: issues.length === 0,
     issues,
-    vm: vmReadiness,
+    vm: {
+      browser: vmReadiness,
+      android: null,
+    },
     guestTokenConfigured: true,
     policy,
   };

package/server/utils/deployment.js

@@ -54,22 +54,28 @@ function getDeploymentProfile(env = process.env) {
   return parseDeploymentProfile(env.NEOAGENT_PROFILE);
 }
 
+function getAllowSignup(env = process.env) {
+  const raw = String(env.NEOAGENT_ALLOW_SIGNUP ?? '').trim().toLowerCase();
+  if (raw === 'false' || raw === '0' || raw === 'no') return false;
+  return true;
+}
+
 function getDeploymentPolicy(env = process.env) {
   const profile = getDeploymentProfile(env);
   const mode = getDeploymentMode(env);
-  const isProdProfile = profile === DEPLOYMENT_PROFILE_PROD;
   return {
     mode,
     profile,
     managed: mode === DEPLOYMENT_MODE_MANAGED,
     allowSelfUpdate: mode !== DEPLOYMENT_MODE_MANAGED,
-    registrationOpen: isProdProfile,
+    registrationOpen: getAllowSignup(env),
     runtimeDefaults: {
       runtime_profile: 'secure-vm',
       runtime_backend: 'vm',
       browser_backend: 'vm',
       android_backend: 'host',
       mcp_backend: 'host-remote',
+      cli_backend: 'vm',
     },
     allowHostRuntime: false,
   };