neoagent 3.2.1-beta.4 → 3.2.1-beta.5

package/server/services/integrations/bitwarden/provider.js

@@ -0,0 +1,197 @@
+'use strict';
+
+const db = require('../../../db/database');
+const { resolveAgentId } = require('../../agents/manager');
+const { getConnectionAccessMode } = require('../access');
+const {
+  deleteProviderConfig,
+  getProviderConfig,
+  setProviderConfig,
+} = require('../provider_config_store');
+const { encryptValue } = require('../secrets');
+const { BITWARDEN_APP, BITWARDEN_PROVIDER_KEY } = require('./constants');
+const { buildBitwardenSnapshot } = require('./snapshot');
+
+const DEFAULT_SERVER_URL = 'https://vault.bitwarden.com';
+
+function text(value) {
+  return String(value || '').trim();
+}
+
+function normalizeServerUrl(value) {
+  const url = new URL(text(value) || DEFAULT_SERVER_URL);
+  if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash) {
+    throw new Error('Bitwarden server must be an HTTPS URL without embedded credentials.');
+  }
+  return url.toString().replace(/\/+$/, '');
+}
+
+function parseConfig(raw, existing = {}) {
+  const source = raw && typeof raw === 'object' ? raw : {};
+  return {
+    serverUrl: normalizeServerUrl(source.serverUrl || existing.serverUrl || DEFAULT_SERVER_URL),
+    email: text(source.email) || text(existing.email),
+    clientId: text(source.clientId) || text(existing.clientId),
+    clientSecret: text(source.clientSecret) || text(existing.clientSecret),
+    idleTimeoutMinutes: Math.max(5, Math.min(120, Number(
+      source.idleTimeoutMinutes || existing.idleTimeoutMinutes || 30,
+    ))),
+  };
+}
+
+function loadConnection(userId, agentId) {
+  return db.prepare(
+    `SELECT * FROM integration_connections
+     WHERE user_id = ? AND agent_id = ? AND provider_key = ? AND app_key = ?
+     ORDER BY updated_at DESC, id DESC LIMIT 1`,
+  ).get(userId, agentId, BITWARDEN_PROVIDER_KEY, BITWARDEN_APP.id) || null;
+}
+
+function publicConfig(config, connection, status = {}) {
+  return {
+    serverUrl: config.serverUrl || DEFAULT_SERVER_URL,
+    email: config.email || '',
+    idleTimeoutMinutes: config.idleTimeoutMinutes || 30,
+    hasClientId: Boolean(config.clientId),
+    hasClientSecret: Boolean(config.clientSecret),
+    configured: Boolean(config.email && config.clientId && config.clientSecret),
+    accountCount: connection?.status === 'connected' ? 1 : 0,
+    hasConnectedAccount: connection?.status === 'connected',
+    connectionId: connection?.id || null,
+    cliAvailable: status.cliAvailable !== false,
+    unlocked: Boolean(status.unlocked),
+    lastUsedAt: status.lastUsedAt || null,
+  };
+}
+
+function upsertConnection(userId, agentId, config) {
+  const existing = loadConnection(userId, agentId);
+  const metadata = JSON.stringify({
+    access_mode: getConnectionAccessMode(existing),
+    idleTimeoutMinutes: config.idleTimeoutMinutes,
+  });
+  db.prepare(
+    `INSERT INTO integration_connections (
+       user_id, agent_id, provider_key, app_key, status, account_email,
+       scopes_json, credentials_json, metadata_json, last_connected_at, updated_at
+     ) VALUES (?, ?, ?, ?, 'connected', ?, ?, ?, ?, datetime('now'), datetime('now'))
+     ON CONFLICT(user_id, agent_id, provider_key, app_key, account_email) DO UPDATE SET
+       status = excluded.status,
+       credentials_json = excluded.credentials_json,
+       metadata_json = excluded.metadata_json,
+       last_connected_at = excluded.last_connected_at,
+       updated_at = excluded.updated_at`,
+  ).run(
+    userId,
+    agentId,
+    BITWARDEN_PROVIDER_KEY,
+    BITWARDEN_APP.id,
+    config.email,
+    JSON.stringify(['vault:read_selected']),
+    encryptValue(JSON.stringify(config)),
+    metadata,
+  );
+  if (existing && existing.account_email !== config.email) {
+    db.prepare('DELETE FROM integration_connections WHERE id = ?').run(existing.id);
+  }
+  return loadConnection(userId, agentId);
+}
+
+function createBitwardenProvider(options = {}) {
+  const app = options.app || null;
+  const cli = () => app?.locals?.bitwardenCli;
+  const broker = () => app?.locals?.credentialBroker;
+
+  return {
+    key: BITWARDEN_PROVIDER_KEY,
+    label: 'Bitwarden',
+    description: 'Fill browser logins and authenticate bounded API requests while keeping secrets hidden from the AI.',
+    icon: 'password',
+    apps: [BITWARDEN_APP],
+    connectPrompt: 'Add a Bitwarden API key, then unlock the vault when credentials are needed. The master password and vault secrets are never sent to the AI.',
+    supportsMultipleAccounts: false,
+    connectionMethod: 'user_config',
+    getApp(appId) {
+      return text(appId) === BITWARDEN_APP.id ? BITWARDEN_APP : null;
+    },
+    getToolAppId() {
+      return null;
+    },
+    getToolDefinitions() {
+      return [];
+    },
+    supportsTool() {
+      return false;
+    },
+    getEnvStatus(context = {}) {
+      const userId = Number(context.userId);
+      const agentId = Number.isInteger(userId) && userId > 0
+        ? resolveAgentId(userId, context.agentId || null)
+        : null;
+      const config = agentId ? parseConfig(getProviderConfig(userId, BITWARDEN_PROVIDER_KEY, agentId)) : {};
+      const missing = ['email', 'clientId', 'clientSecret'].filter((key) => !config[key]);
+      return {
+        configured: missing.length === 0,
+        missing,
+        summary: missing.length === 0
+          ? 'Bitwarden is configured. Unlock it only when a credential operation is needed.'
+          : 'Add a Bitwarden personal API key in Official Integrations.',
+        setupMode: 'user',
+      };
+    },
+    buildSnapshot(connectionRows, context = {}) {
+      return buildBitwardenSnapshot(this, connectionRows, {
+        ...context,
+        credentialBindingsSummary: context.userId
+          ? broker()?.summarizeBindings(context.userId, context.agentId)
+          : 'No credential bindings are configured.',
+      });
+    },
+    summarizeForModel(snapshot) {
+      if (!snapshot?.connection?.connected) {
+        return 'Bitwarden: not configured. The user can connect it in Official Integrations.';
+      }
+      const bindings = snapshot.credentialBindingsSummary || 'No credential bindings are configured.';
+      return `Bitwarden credential broker: ${bindings} Secret values are never available to the model.`;
+    },
+    getUserConfig({ userId, agentId }) {
+      const normalizedUserId = Number(userId);
+      const scopedAgentId = resolveAgentId(normalizedUserId, agentId || null);
+      const config = parseConfig(getProviderConfig(normalizedUserId, BITWARDEN_PROVIDER_KEY, scopedAgentId));
+      return publicConfig(config, loadConnection(normalizedUserId, scopedAgentId), cli()?.getStatus(normalizedUserId, scopedAgentId));
+    },
+    async saveUserConfig({ userId, agentId, config, signal }) {
+      const normalizedUserId = Number(userId);
+      if (!Number.isInteger(normalizedUserId) || normalizedUserId <= 0) {
+        throw new Error('A valid user is required to save Bitwarden configuration.');
+      }
+      const scopedAgentId = resolveAgentId(normalizedUserId, agentId || null);
+      const existing = getProviderConfig(normalizedUserId, BITWARDEN_PROVIDER_KEY, scopedAgentId);
+      const parsed = parseConfig(config, existing);
+      if (!parsed.email || !parsed.clientId || !parsed.clientSecret) {
+        throw new Error('Bitwarden email, client ID, and client secret are required.');
+      }
+      if (!cli()) throw new Error('Bitwarden credential service is unavailable.');
+      await cli().configure(normalizedUserId, scopedAgentId, parsed, { signal });
+      setProviderConfig(normalizedUserId, BITWARDEN_PROVIDER_KEY, parsed, scopedAgentId);
+      const connection = upsertConnection(normalizedUserId, scopedAgentId, parsed);
+      return publicConfig(parsed, connection, cli().getStatus(normalizedUserId, scopedAgentId));
+    },
+    async clearUserConfig({ userId, agentId }) {
+      const normalizedUserId = Number(userId);
+      const scopedAgentId = resolveAgentId(normalizedUserId, agentId || null);
+      await cli()?.logout(normalizedUserId, scopedAgentId);
+      deleteProviderConfig(normalizedUserId, BITWARDEN_PROVIDER_KEY, scopedAgentId);
+      db.prepare(
+        'DELETE FROM integration_connections WHERE user_id = ? AND agent_id = ? AND provider_key = ?',
+      ).run(normalizedUserId, scopedAgentId, BITWARDEN_PROVIDER_KEY);
+      return { cleared: true };
+    },
+  };
+}
+
+module.exports = {
+  createBitwardenProvider,
+  normalizeServerUrl,
+  parseConfig,
+};

package/server/services/integrations/bitwarden/snapshot.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const { getConnectionAccessMode } = require('../access');
+const { BITWARDEN_APP } = require('./constants');
+
+function summarizeAccount(row, env) {
+  if (!row) {
+    return {
+      id: null,
+      status: env.configured ? 'not_connected' : 'env_not_configured',
+      connected: false,
+      accountEmail: null,
+      lastConnectedAt: null,
+      accessMode: 'read_write',
+    };
+  }
+  return {
+    id: row.id,
+    status: row.status,
+    connected: row.status === 'connected',
+    accountEmail: row.account_email || null,
+    lastConnectedAt: row.last_connected_at || null,
+    accessMode: getConnectionAccessMode(row),
+  };
+}
+
+function buildBitwardenSnapshot(provider, connectionRows, context = {}) {
+  const env = provider.getEnvStatus(context);
+  const row = (Array.isArray(connectionRows) ? connectionRows : [])
+    .filter((candidate) => candidate.app_key === BITWARDEN_APP.id)
+    .sort((left, right) => String(right.updated_at || '').localeCompare(String(left.updated_at || '')))[0] || null;
+  const account = summarizeAccount(row, env);
+  const accounts = row ? [account] : [];
+  const connection = {
+    status: !env.configured ? 'env_not_configured' : account.status,
+    connected: account.connected,
+    accountEmail: account.accountEmail,
+    accountCount: account.connected ? 1 : 0,
+    appCount: account.connected ? 1 : 0,
+    lastConnectedAt: account.lastConnectedAt,
+  };
+  return {
+    id: provider.key,
+    label: provider.label,
+    description: provider.description,
+    icon: provider.icon,
+    apps: [{
+      ...BITWARDEN_APP,
+      accounts,
+      connection,
+      availableToolCount: account.connected ? 2 : 0,
+    }],
+    env,
+    connection,
+    availableToolCount: account.connected ? 2 : 0,
+    credentialBindingsSummary: context.credentialBindingsSummary || 'No credential bindings are configured.',
+    connectPrompt: provider.connectPrompt,
+    supportsMultipleAccounts: false,
+    connectionMethod: 'user_config',
+  };
+}
+
+module.exports = {
+  buildBitwardenSnapshot,
+};

package/server/services/integrations/manager.js

@@ -59,6 +59,7 @@ class IntegrationManager {
   constructor(options = {}) {
     this.app = options.app || null;
     this.registry = createIntegrationRegistry({
+      app: this.app,
       io: this.app?.locals?.io || null,
     });
     this.connectionExecutionQueues = new Map();

package/server/services/integrations/registry.js

@@ -4,6 +4,7 @@ const { createFigmaProvider } = require('./figma/provider');
 const { createGoogleWorkspaceProvider } = require('./google/provider');
 const { createGithubProvider } = require('./github/provider');
 const { createHomeAssistantProvider } = require('./home_assistant/provider');
+const { createBitwardenProvider } = require('./bitwarden/provider');
 const { createTrelloProvider } = require('./trello/provider');
 const { createMicrosoftProvider } = require('./microsoft/provider');
 const { createNotionProvider } = require('./notion/provider');
@@ -28,6 +29,7 @@ function createIntegrationRegistry(options = {}) {
     createNeoArchiveProvider(),
     createNeoRecallProvider(),
     createHomeAssistantProvider(),
+    createBitwardenProvider(options),
     createWhatsAppPersonalProvider(options),
   ];
   const byKey = new Map(providers.map((provider) => [provider.key, provider]));

package/server/services/manager.js

@@ -34,6 +34,8 @@ const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
 const { TimelineService } = require('./timeline/service');
 const { WearableService } = require('./wearable/service');
+const { BitwardenCli } = require('./credentials/bitwarden_cli');
+const { CredentialBroker } = require('./credentials/broker');
 const { getRuntimeValidation } = require('./runtime/validation');
 const {
   getErrorMessage,
@@ -142,6 +144,17 @@ function createIntegrationManager(app) {
   return integrationManager;
 }
 
+function createCredentialBroker(app) {
+  const bitwardenCli = registerLocal(app, 'bitwardenCli', new BitwardenCli());
+  const credentialBroker = registerLocal(
+    app,
+    'credentialBroker',
+    new CredentialBroker({ bitwarden: bitwardenCli }),
+  );
+  logServiceReady('Credential broker ready');
+  return credentialBroker;
+}
+
 function createMemoryIngestionService(app, { memoryManager, integrationManager }) {
   const memoryIngestionService = registerLocal(
     app,
@@ -469,10 +482,12 @@ async function startServices(app, io) {
     const memoryManager = createMemoryManager(app);
     const mcpClient = createMcpClient(app);
     createAuthProviderManager(app);
+    const credentialBroker = createCredentialBroker(app);
     const integrationManager = createIntegrationManager(app);
     createMemoryIngestionService(app, { memoryManager, integrationManager });
     const browserController = createBrowserController(app, artifactStore);
     const runtimeManager = createRuntimeManager(app);
+    credentialBroker.setRuntimeManager(runtimeManager);
     const runtimeValidation = getRuntimeValidation(runtimeManager);
     registerLocal(app, 'runtimeValidation', runtimeValidation);
     if (!runtimeValidation.ready) {
@@ -753,6 +768,14 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.bitwardenCli) {
+    tasks.push(
+      app.locals.bitwardenCli.shutdown().catch((err) => {
+        console.error('[Bitwarden] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
   if (app.locals.widgetService) {
     const widgetService = app.locals.widgetService;
     const cleanupMethod = ['shutdown', 'close', 'stop', 'dispose'].find(

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

@@ -389,6 +389,15 @@ class VmBrowserProvider {
   async launch(options = {}) { return this.#request('POST', '/browser/launch', options, options); }
   async closeBrowser(options = {}) { return this.#request('POST', '/browser/close', undefined, options); }
   async fill(selector, value, options = {}) { return this.type(selector, value, options); }
+  async fillCredential(input, options = {}) {
+    return this.#request('POST', '/browser/credential-fill', input, options);
+  }
+  async submitProtectedCredential(protectedFillId, options = {}) {
+    return this.#request('POST', '/browser/credential-submit', { protectedFillId }, options);
+  }
+  async cancelProtectedCredential(protectedFillId, options = {}) {
+    return this.#request('POST', '/browser/credential-cancel', { protectedFillId }, options);
+  }
   async extractContent(options = {}) { return this.#request('POST', '/browser/extract', options, options); }
   async executeJS(code, options = {}) { return this.evaluate(code, options); }
   async getPageInfo(options = {}) {
@@ -417,7 +426,10 @@ class VmBrowserProvider {
 class LocalVmExecutionBackend {
   constructor(options = {}) {
     this.vmManager = options.vmManager;
-    this.runtimeProfile = options.runtimeProfile === 'android' ? 'android' : 'browser_cli';
+    const runtimeProfile = String(options.runtimeProfile || '').trim();
+    this.runtimeProfile = ['android', 'browser', 'cli', 'browser_cli'].includes(runtimeProfile)
+      ? runtimeProfile
+      : 'browser_cli';
     this.token = options.token || process.env.NEOAGENT_VM_GUEST_TOKEN || '';
     this.artifactStore = options.artifactStore || null;
     this.lastActivity = new Map();

package/server/services/runtime/guest_bootstrap.js

@@ -7,6 +7,20 @@ const VM_ROOT = path.join(DATA_DIR, 'runtime-vms');
 const GUEST_BOOTSTRAP_ROOT = path.join(VM_ROOT, 'guest-bootstrap');
 const REPO_ROOT = path.resolve(__dirname, '../../..');
 const GUEST_PAYLOAD_PROFILES = Object.freeze({
+  browser: [
+    { source: 'server/guest-agent.browser.package.json', target: 'package.json' },
+    { source: 'runtime/env.js', target: 'runtime/env.js' },
+    { source: 'runtime/paths.js', target: 'runtime/paths.js' },
+    { source: 'server/guest_agent.js', target: 'server/guest_agent.js' },
+    { source: 'server/services/browser', target: 'server/services/browser' },
+  ],
+  cli: [
+    { source: 'server/guest-agent.cli.package.json', target: 'package.json' },
+    { source: 'runtime/env.js', target: 'runtime/env.js' },
+    { source: 'runtime/paths.js', target: 'runtime/paths.js' },
+    { source: 'server/guest_agent.js', target: 'server/guest_agent.js' },
+    { source: 'server/services/cli', target: 'server/services/cli' },
+  ],
   browser_cli: [
     { source: 'server/guest-agent.browser.package.json', target: 'package.json' },
     { source: 'runtime/env.js', target: 'runtime/env.js' },
@@ -32,7 +46,10 @@ function encodeGuestToken(value) {
 }
 
 function normalizeRuntimeProfile(runtimeProfile) {
-  return runtimeProfile === 'android' ? 'android' : 'browser_cli';
+  const normalized = String(runtimeProfile || '').trim();
+  return ['android', 'browser', 'cli', 'browser_cli'].includes(normalized)
+    ? normalized
+    : 'browser_cli';
 }
 
 // Copy the guest runtime source files for a profile into `stagingRoot`, producing
@@ -84,10 +101,12 @@ function createCloudInitScript({
   runtimeProfile = 'browser_cli',
 }) {
   const normalizedProfile = normalizeRuntimeProfile(runtimeProfile);
-  const includeBrowser = normalizedProfile === 'browser_cli';
+  const includeBrowser = ['browser', 'browser_cli'].includes(normalizedProfile);
   const guestUtilityPackages = includeBrowser
     ? 'curl ca-certificates gnupg git rsync unzip xvfb dbus-x11'
-    : 'curl ca-certificates gnupg git rsync unzip dbus-x11 adb';
+    : normalizedProfile === 'android'
+      ? 'curl ca-certificates gnupg git rsync unzip dbus-x11 adb'
+      : 'curl ca-certificates gnupg git rsync unzip';
   const guestTokenB64 = encodeGuestToken(guestToken);
   const envFile = '/etc/neoagent/neoagent.env';
   const appDir = '/opt/neoagent';
@@ -208,7 +227,7 @@ function createCloudInitUserData({
   runtimeProfile = 'browser_cli',
 }) {
   const normalizedProfile = normalizeRuntimeProfile(runtimeProfile);
-  const includeBrowser = normalizedProfile === 'browser_cli';
+  const includeBrowser = ['browser', 'browser_cli'].includes(normalizedProfile);
   const guestAgentInnerCommand = includeBrowser
     ? 'set -a; . /etc/neoagent/neoagent.env; set +a; cd /opt/neoagent && env DISPLAY=:99 PLAYWRIGHT_BROWSERS_PATH=/opt/neoagent/.playwright-browsers /usr/bin/env node server/guest_agent.js 2>&1 | tee -a /var/log/neoagent-guest-agent.log >/dev/console'
     : 'set -a; . /etc/neoagent/neoagent.env; set +a; cd /opt/neoagent && /usr/bin/env node server/guest_agent.js 2>&1 | tee -a /var/log/neoagent-guest-agent.log >/dev/console';

package/server/services/runtime/guest_image.js

@@ -21,11 +21,12 @@ const BUILD_TIMEOUT_MS = Number(process.env.NEOAGENT_GUEST_IMAGE_BUILD_TIMEOUT_M
 // container start. Copy package.json first so the dependency layer stays cached
 // across source-only changes.
 function dockerfileFor(profile) {
-  if (normalizeRuntimeProfile(profile) === 'android') {
+  const normalizedProfile = normalizeRuntimeProfile(profile);
+  if (normalizedProfile === 'android' || normalizedProfile === 'cli') {
     return [
       `FROM ${BASE_IMAGE}`,
       'ENV NODE_ENV=production',
-      'ENV NEOAGENT_GUEST_PROFILE=android',
+      `ENV NEOAGENT_GUEST_PROFILE=${normalizedProfile}`,
       'WORKDIR /opt/neoagent',
       'COPY package.json ./',
       'RUN npm install --omit=dev --no-audit --no-fund && npm cache clean --force',
@@ -42,7 +43,7 @@ function dockerfileFor(profile) {
     `FROM ${BASE_IMAGE}`,
     'ENV NODE_ENV=production',
     'ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright',
-    'ENV NEOAGENT_GUEST_PROFILE=browser_cli',
+    `ENV NEOAGENT_GUEST_PROFILE=${normalizedProfile}`,
     'WORKDIR /opt/neoagent',
     'COPY package.json ./',
     // Install deps without running package postinstall scripts, then fetch the

package/server/services/runtime/manager.js

@@ -10,6 +10,8 @@ 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);
+const DEFAULT_CLI_VM_MEMORY_MB = Number(process.env.NEOAGENT_CLI_VM_MEMORY_MB ?? 1024);
+const DEFAULT_CLI_VM_CPUS = Number(process.env.NEOAGENT_CLI_VM_CPUS ?? 1);
 
 class RuntimeManager {
   constructor(options = {}) {
@@ -19,15 +21,25 @@ class RuntimeManager {
     this.androidControllers = new Map();
 
     const browserVmManager = options.browserVmManager || new DockerVMManager({
-      runtimeProfile: 'browser_cli',
+      runtimeProfile: 'browser',
       memoryMb: DEFAULT_VM_MEMORY_MB,
       cpus: DEFAULT_VM_CPUS,
     });
     this.browserBackend = new LocalVmExecutionBackend({
-      runtimeProfile: 'browser_cli',
+      runtimeProfile: 'browser',
       vmManager: browserVmManager,
       artifactStore: options.artifactStore,
     });
+    const cliVmManager = options.cliVmManager || new DockerVMManager({
+      runtimeProfile: 'cli',
+      memoryMb: DEFAULT_CLI_VM_MEMORY_MB,
+      cpus: DEFAULT_CLI_VM_CPUS,
+    });
+    this.cliBackend = new LocalVmExecutionBackend({
+      runtimeProfile: 'cli',
+      vmManager: cliVmManager,
+      artifactStore: options.artifactStore,
+    });
 
     this.artifactStore = options.artifactStore || null;
 
@@ -77,25 +89,25 @@ class RuntimeManager {
 
   resolveBackend(userId, requested) {
     void userId;
-    void requested;
-    return this.browserBackend;
+    return requested === 'browser' ? this.browserBackend : this.cliBackend;
   }
 
   async executeCommand(userId, command, options = {}) {
-    const backend = this.resolveBackend(userId, 'browser_cli');
+    const backend = this.resolveBackend(userId, 'cli');
     return backend.executeCommand(userId, command, options);
   }
 
   hasVmForUser(userId, capability = 'browser') {
-    return Boolean(this.browserBackend?.vmManager?.hasVm?.(userId));
+    const backend = capability === 'browser' ? this.browserBackend : this.cliBackend;
+    return Boolean(backend?.vmManager?.hasVm?.(userId));
   }
 
   async killCommand(userId, pid, reason = 'aborted') {
-    return this.browserBackend.killCommand(userId, pid, reason);
+    return this.cliBackend.killCommand(userId, pid, reason);
   }
 
   async getCommandExecutorForUser(userId) {
-    return this.browserBackend.getCommandExecutorForUser(userId);
+    return this.cliBackend.getCommandExecutorForUser(userId);
   }
 
   async getBrowserProviderForUser(userId, options = {}) {
@@ -124,7 +136,7 @@ class RuntimeManager {
         kill: () => Promise.resolve(false),
       };
     }
-    const executor = await this.browserBackend.getCommandExecutorForUser(userId);
+    const executor = await this.cliBackend.getCommandExecutorForUser(userId);
     return { ...executor, backend: 'vm' };
   }
 
@@ -156,15 +168,17 @@ class RuntimeManager {
   }
 
   async isGuestAgentReadyForUser(userId, timeoutMs = 1000, capability = 'browser') {
-    if (typeof this.browserBackend?.isGuestAgentReadyForUser !== 'function') {
+    const backend = capability === 'browser' ? this.browserBackend : this.cliBackend;
+    if (typeof backend?.isGuestAgentReadyForUser !== 'function') {
       return false;
     }
-    return this.browserBackend.isGuestAgentReadyForUser(userId, timeoutMs);
+    return backend.isGuestAgentReadyForUser(userId, timeoutMs);
   }
 
   async shutdown() {
     const tasks = [
       this.browserBackend?.shutdown?.(),
+      this.cliBackend?.shutdown?.(),
       ...Array.from(this.androidControllers.values(), (controller) => controller?.close?.()),
     ];
     this.androidControllers.clear();

package/server/services/runtime/validation.js

@@ -6,14 +6,14 @@ function getRuntimeValidation(runtimeManager) {
   const policy = getDeploymentPolicy();
   const nodeEnvIsProd = String(process.env.NODE_ENV || '').trim().toLowerCase() === 'prod';
   const browserVmReadiness = runtimeManager?.browserBackend?.vmManager?.getReadiness?.() || null;
-  const vmReadiness = browserVmReadiness || null;
+  const cliVmReadiness = runtimeManager?.cliBackend?.vmManager?.getReadiness?.() || null;
   const issues = [];
 
   if (policy.profile === 'prod' || nodeEnvIsProd) {
-    if (!browserVmReadiness) {
-      issues.push('prod profile requires a working container runtime for browser/CLI.');
-    } else if (!browserVmReadiness.dockerAvailable) {
-      issues.push('prod profile requires Docker to be installed and running for the browser/CLI runtime.');
+    if (!browserVmReadiness || !cliVmReadiness) {
+      issues.push('prod profile requires working isolated container runtimes for browser and CLI.');
+    } else if (!browserVmReadiness.dockerAvailable || !cliVmReadiness.dockerAvailable) {
+      issues.push('prod profile requires Docker to be installed and running for the browser and CLI runtimes.');
     }
   }
 
@@ -21,7 +21,8 @@ function getRuntimeValidation(runtimeManager) {
     ready: issues.length === 0,
     issues,
     vm: {
-      browser: vmReadiness,
+      browser: browserVmReadiness,
+      cli: cliVmReadiness,
       android: null,
     },
     guestTokenConfigured: true,

package/server/services/security/tool_categories.js

@@ -18,6 +18,7 @@ const TOOL_CATEGORIES = {
     'desktop_observe',
   ],
   browser_privileged: ['browser_evaluate'],
+  credential_use: ['credential_fill_browser', 'credential_http_request'],
   network_write: ['http_request'],
   skill_mutation: [
     'create_skill',
@@ -78,6 +79,10 @@ const BUILT_IN_TOOLS = new Set([
   'browser_extract',
   'browser_screenshot',
   'browser_evaluate',
+  'credential_fill_browser',
+  'credential_submit_browser',
+  'credential_cancel_browser',
+  'credential_http_request',
   'desktop_list_devices',
   'desktop_select_device',
   'desktop_observe',
@@ -166,6 +171,7 @@ const DEFAULT_POLICY = {
   android_privileged: 'require_approval',
   desktop_control: 'require_approval',
   browser_privileged: 'require_approval',
+  credential_use: 'require_approval',
   network_write: 'require_approval',
   skill_mutation: 'deny',
   external: 'require_approval',