@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

package/server/modules/agent/agent.routes.ts

@@ -978,8 +978,8 @@ export function createAgentRouter(dependencies: AgentRouterDependencies): expres
         });
       }
 
-      const codexModels = (await providerModelsService.getProviderModels('codex')).models;
-      const opencodeModels = (await providerModelsService.getProviderModels('opencode')).models;
+      const codexModels = await providerModelsService.getProviderModels('codex');
+      const opencodeModels = await providerModelsService.getProviderModels('opencode');
 
       // Start the appropriate session
       if (provider === 'claude') {

package/server/modules/agent/tests/agent.routes.test.ts

@@ -182,7 +182,7 @@ test('Agent route reuses a matching checkout without cloning or deleting it', as
     } as unknown as AgentDependencies['fileSystem'],
     spawnProcess,
     models: {
-      getProviderModels: async () => ({ models: { DEFAULT: 'default-model' } }),
+      getProviderModels: async () => ({ OPTIONS: [], DEFAULT: 'default-model' }),
     } as unknown as AgentDependencies['models'],
     queryClaude: (async () => undefined) as AgentDependencies['queryClaude'],
   }), async (baseUrl) => {
@@ -203,3 +203,35 @@ test('Agent route reuses a matching checkout without cloning or deleting it', as
   assert.deepEqual(spawnedArguments, [['config', '--get', 'remote.origin.url']]);
   assert.deepEqual(removedPaths, []);
 });
+
+test('Agent route starts codex on the catalog default when the request names no model', async () => {
+  const codexCalls: { model?: string }[] = [];
+
+  await withAgentServer(createDependencies({
+    fileSystem: {
+      access: async () => undefined,
+    } as unknown as AgentDependencies['fileSystem'],
+    models: {
+      // `getProviderModels` resolves to a `ProviderModelsDefinition` - `OPTIONS`
+      // and `DEFAULT`, with nothing wrapped around it.
+      getProviderModels: async () => ({ OPTIONS: [], DEFAULT: 'catalog-default' }),
+    } as unknown as AgentDependencies['models'],
+    queryCodex: (async (_prompt: string, options: { model?: string }) => {
+      codexCalls.push(options);
+    }) as unknown as AgentDependencies['queryCodex'],
+  }), async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/agent`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        projectPath: '/home/test/project',
+        message: 'Run',
+        provider: 'codex',
+        stream: false,
+      }),
+    });
+    assert.equal(response.status, 200);
+  });
+
+  assert.deepEqual(codexCalls.map((call) => call.model), ['catalog-default']);
+});

package/server/modules/auth/auth.middleware.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck -- JWT request augmentation is narrowed by Auth route contracts.
 import jwt from 'jsonwebtoken';
 
-import { userDb, appConfigDb } from '../database/index.js';
+import { IS_PLATFORM } from '@/shared/utils.js';
 
-const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true';
+import { userDb, appConfigDb } from '../database/index.js';
 
 // Use env var if set, otherwise auto-generate a unique secret per installation
 const JWT_SECRET = process.env.JWT_SECRET || appConfigDb.getOrCreateJwtSecret();

package/server/modules/browser-use/browser-use-runtime.ts

@@ -0,0 +1,10 @@
+import { IS_PLATFORM } from '@/shared/utils.js';
+
+/**
+ * Resolves the runtime label exposed by Browser Use status and session APIs.
+ * The Browser Use service and CLI environment-mode regression coverage consume
+ * this after the server or CLI entrypoint has completed environment bootstrapping.
+ */
+export function getBrowserUseRuntime(): 'cloud' | 'local' {
+  return IS_PLATFORM ? 'cloud' : 'local';
+}

package/server/modules/browser-use/browser-use.routes.ts

@@ -1,9 +1,45 @@
 import express from 'express';
+import type { Response } from 'express';
 
 import { browserUseService } from '@/modules/browser-use/browser-use.service.js';
 
 const router = express.Router();
 
+/**
+ * Stable machine-readable error codes for the browser-use API.
+ *
+ * The server always replies with the structured envelope used by AppError
+ * (`{ success: false, error: { code, message, details } }`). Clients map
+ * `code` to localized copy; `message` is an English fallback and `details`
+ * may carry the underlying error text for diagnostics.
+ */
+export const BROWSER_USE_ERROR_CODES = {
+  STATUS_LOAD_FAILED: 'BROWSER_USE_STATUS_LOAD_FAILED',
+  SETTINGS_LOAD_FAILED: 'BROWSER_USE_SETTINGS_LOAD_FAILED',
+  SETTINGS_SAVE_FAILED: 'BROWSER_USE_SETTINGS_SAVE_FAILED',
+  RUNTIME_INSTALL_FAILED: 'BROWSER_USE_RUNTIME_INSTALL_FAILED',
+  SESSIONS_LOAD_FAILED: 'BROWSER_USE_SESSIONS_LOAD_FAILED',
+  SESSION_STOP_FAILED: 'BROWSER_USE_SESSION_STOP_FAILED',
+  SESSION_DELETE_FAILED: 'BROWSER_USE_SESSION_DELETE_FAILED',
+} as const;
+
+function sendError(
+  res: Response,
+  statusCode: number,
+  code: string,
+  message: string,
+  details?: unknown,
+): void {
+  res.status(statusCode).json({
+    success: false,
+    error: {
+      code,
+      message,
+      details,
+    },
+  });
+}
+
 function readParam(value: string | string[] | undefined): string {
   return Array.isArray(value) ? value[0] || '' : value || '';
 }
@@ -12,10 +48,13 @@ router.get('/status', async (_req, res) => {
   try {
     res.json({ success: true, data: await browserUseService.getStatus() });
   } catch (error) {
-    res.status(500).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to load Browser status.',
-    });
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.STATUS_LOAD_FAILED,
+      'Failed to load Browser status.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -23,10 +62,13 @@ router.get('/settings', async (_req, res) => {
   try {
     res.json({ success: true, data: { settings: await browserUseService.getSettings() } });
   } catch (error) {
-    res.status(500).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to load Browser settings.',
-    });
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.SETTINGS_LOAD_FAILED,
+      'Failed to load Browser settings.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -35,26 +77,38 @@ router.put('/settings', async (req, res) => {
     const settings = await browserUseService.updateSettings(req.body || {});
     res.json({ success: true, data: { settings } });
   } catch (error) {
-    res.status(400).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to save Browser settings.',
-    });
+    sendError(
+      res,
+      400,
+      BROWSER_USE_ERROR_CODES.SETTINGS_SAVE_FAILED,
+      'Failed to save Browser settings.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
 router.post('/runtime/install', async (_req, res) => {
   try {
     const result = await browserUseService.installRuntime();
-    res.status(result.success ? 200 : 500).json({
-      success: result.success,
-      data: result,
-      error: result.success ? undefined : result.message,
-    });
+    if (result.success) {
+      res.json({ success: true, data: result });
+      return;
+    }
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.RUNTIME_INSTALL_FAILED,
+      'Failed to install Browser runtime.',
+      result.message,
+    );
   } catch (error) {
-    res.status(500).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to install Browser runtime.',
-    });
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.RUNTIME_INSTALL_FAILED,
+      'Failed to install Browser runtime.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -62,10 +116,13 @@ router.get('/sessions', async (_req, res) => {
   try {
     res.json({ success: true, data: { sessions: await browserUseService.listSessions() } });
   } catch (error) {
-    res.status(401).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to list browser sessions.',
-    });
+    sendError(
+      res,
+      401,
+      BROWSER_USE_ERROR_CODES.SESSIONS_LOAD_FAILED,
+      'Failed to list browser sessions.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -74,10 +131,13 @@ router.post('/sessions/:sessionId/stop', async (req, res) => {
     const result = await browserUseService.stopSession(readParam(req.params.sessionId));
     res.json({ success: true, data: result });
   } catch (error) {
-    res.status(400).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to stop browser session.',
-    });
+    sendError(
+      res,
+      400,
+      BROWSER_USE_ERROR_CODES.SESSION_STOP_FAILED,
+      'Failed to stop browser session.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -86,10 +146,13 @@ router.delete('/sessions/:sessionId', async (req, res) => {
     const result = await browserUseService.deleteSession(readParam(req.params.sessionId));
     res.json({ success: true, data: result });
   } catch (error) {
-    res.status(400).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to delete browser session.',
-    });
+    sendError(
+      res,
+      400,
+      BROWSER_USE_ERROR_CODES.SESSION_DELETE_FAILED,
+      'Failed to delete browser session.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 

package/server/modules/browser-use/browser-use.service.ts

@@ -11,15 +11,16 @@ import { appConfigDb } from '@/modules/database/index.js';
 import { providerMcpService } from '@/modules/providers/index.js';
 import { getModuleDirectory } from '@/shared/utils.js';
 
+import { getBrowserUseRuntime } from './browser-use-runtime.js';
+
 const require = createRequire(import.meta.url);
 const __dirname = getModuleDirectory(import.meta.url);
-const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true';
 const MAX_SESSIONS_PER_OWNER = Number.parseInt(process.env.CLOUDCLI_BROWSER_USE_MAX_SESSIONS_PER_OWNER || '3', 10);
 const SESSION_TTL_MS = Number.parseInt(process.env.CLOUDCLI_BROWSER_USE_SESSION_TTL_MS || String(30 * 60 * 1000), 10);
 const BROWSER_USE_SETTINGS_KEY = 'browser_use_settings';
 const BROWSER_USE_MCP_TOKEN_KEY = 'browser_use_mcp_token';
 
-type BrowserUseRuntime = 'cloud' | 'local';
+type BrowserUseRuntime = ReturnType<typeof getBrowserUseRuntime>;
 type BrowserUseSessionStatus = 'ready' | 'stopped' | 'unavailable';
 
 type BrowserUseSession = {
@@ -85,10 +86,6 @@ const MCP_SERVER_NAME = 'cloudcli-browser';
 const LEGACY_MCP_SERVER_NAMES = ['cloudcli-browser-use'];
 const RUNTIME_READINESS_CACHE_TTL_MS = 30_000;
 
-function getRuntime(): BrowserUseRuntime {
-  return IS_PLATFORM ? 'cloud' : 'local';
-}
-
 function readSettings(): BrowserUseSettings {
   try {
     const raw = appConfigDb.get(BROWSER_USE_SETTINGS_KEY);
@@ -446,7 +443,7 @@ export const browserUseService = {
 
     return {
       enabled: settings.enabled,
-      runtime: getRuntime(),
+      runtime: getBrowserUseRuntime(),
       available,
       playwrightInstalled: readiness.playwrightInstalled,
       chromiumInstalled: readiness.chromiumInstalled,
@@ -515,7 +512,7 @@ export const browserUseService = {
       id: randomUUID(),
       ownerId: AGENT_OWNER_ID,
       createdBy: 'agent',
-      runtime: getRuntime(),
+      runtime: getBrowserUseRuntime(),
       status: 'unavailable',
       url: null,
       title: null,

package/server/modules/browser-use/index.ts

@@ -6,3 +6,6 @@
 export async function startBrowserUseMcp(): Promise<void> {
   await import('./browser-use-mcp.js');
 }
+
+// getBrowserUseRuntime: used by Browser Use services and environment-mode regression coverage.
+export { getBrowserUseRuntime } from './browser-use-runtime.js';

package/server/modules/cli/cli.module.ts

@@ -28,7 +28,6 @@ export function createCliApplication(): CliApplication {
     bugsUrl: packageMetadataJson.bugs?.url,
   };
   const fileSystem = {
-    readTextFile: (filePath: string) => fs.readFileSync(filePath, 'utf8'),
     pathExists: (filePath: string) => fs.existsSync(filePath),
     getFileStats: (filePath: string) => {
       const stats = fs.statSync(filePath);

package/server/modules/cli/cli.service.ts

@@ -77,27 +77,7 @@ function isNewerVersion(candidateVersion: string, currentVersion: string): boole
   return false;
 }
 
-function loadEnvironmentFile(dependencies: CliServiceDependencies): void {
-  try {
-    const environmentFile = dependencies.fileSystem.readTextFile(
-      path.join(dependencies.applicationRoot, '.env'),
-    );
-    for (const line of environmentFile.split('\n')) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine || trimmedLine.startsWith('#')) continue;
-
-      const [key, ...valueParts] = trimmedLine.split('=');
-      if (key && valueParts.length > 0 && !dependencies.environment[key]) {
-        dependencies.environment[key] = valueParts.join('=').trim();
-      }
-    }
-  } catch {
-    // The repository-level .env file is optional for every CLI command.
-  }
-}
-
 function showStatus(dependencies: CliServiceDependencies): void {
-  loadEnvironmentFile(dependencies);
   const { environment, fileSystem, output } = dependencies;
   const databasePath = environment.DATABASE_PATH || dependencies.defaultDatabasePath;
   const databaseExists = fileSystem.pathExists(databasePath);

package/server/modules/cli/cli.ts

@@ -1,10 +1,16 @@
 #!/usr/bin/env node
 
-import { createCliApplication } from './index.js';
+// The CLI can reach shared environment constants through its composition root,
+// so finish the root environment bootstrap before loading that import graph.
+// eslint-disable-next-line boundaries/no-unknown
+import '../../load-env.js';
 
-const cliApplication = createCliApplication();
+async function runCli(): Promise<number> {
+  const { createCliApplication } = await import('./index.js');
+  return createCliApplication().run(process.argv.slice(2));
+}
 
-cliApplication.run(process.argv.slice(2)).then((exitCode) => {
+runCli().then((exitCode) => {
   process.exitCode = exitCode;
 }).catch((error: unknown) => {
   const message = error instanceof Error ? error.message : String(error);

package/server/modules/cli/tests/cli-environment-bootstrap.test.ts

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { copyFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+type BootstrapResult = {
+  command: string | null;
+  environmentFileReads: number;
+  mode: string | null;
+  authNextCalled: boolean;
+  authStatus: number;
+  authenticatedUsername: string | null;
+  runtime: string;
+};
+
+const RESULT_PREFIX = '__CLOUDCLI_BOOTSTRAP_RESULT__';
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const applicationRoot = path.resolve(testDirectory, '..', '..', '..', '..');
+
+function sourceModuleUrl(...segments: string[]): string {
+  return pathToFileURL(path.join(applicationRoot, ...segments)).href;
+}
+
+async function runCliBootstrapFixture(isPlatform: boolean): Promise<BootstrapResult> {
+  const fixtureRoot = await mkdtemp(path.join(os.tmpdir(), 'cloudcli-cli-bootstrap-'));
+  const fixtureServerDirectory = path.join(fixtureRoot, 'server');
+  const fixtureCliDirectory = path.join(fixtureServerDirectory, 'modules', 'cli');
+  const fixtureDatabasePath = path.join(fixtureRoot, 'auth.db');
+
+  try {
+    await mkdir(fixtureCliDirectory, { recursive: true });
+    await Promise.all([
+      copyFile(
+        path.join(applicationRoot, 'server', 'load-env.ts'),
+        path.join(fixtureServerDirectory, 'load-env.ts'),
+      ),
+      copyFile(
+        path.join(applicationRoot, 'server', 'modules', 'cli', 'cli.ts'),
+        path.join(fixtureCliDirectory, 'cli.ts'),
+      ),
+    ]);
+    await writeFile(
+      path.join(fixtureRoot, '.env'),
+      [
+        `VITE_IS_PLATFORM=${String(isPlatform)}`,
+        `DATABASE_PATH=${fixtureDatabasePath.replace(/\\/g, '/')}`,
+      ].join('\n'),
+      'utf8',
+    );
+
+    const fixtureIndexSource = `
+import { createCliService } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'cli', 'cli.service.ts'))};
+import { authenticateToken } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'auth', 'index.ts'))};
+import { getBrowserUseRuntime } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'browser-use', 'index.ts'))};
+import { closeConnection, initializeDatabase, userDb } from ${JSON.stringify(sourceModuleUrl('server', 'modules', 'database', 'index.ts'))};
+
+let environmentFileReads = 0;
+
+export function createCliApplication() {
+  const service = createCliService({
+    applicationRoot: ${JSON.stringify(fixtureRoot)},
+    defaultDatabasePath: ${JSON.stringify(fixtureDatabasePath)},
+    homeDirectory: ${JSON.stringify(fixtureRoot)},
+    packageMetadata: { version: '1.0.0' },
+    environment: process.env,
+    fileSystem: {
+      readTextFile: () => {
+        environmentFileReads += 1;
+        return '';
+      },
+      pathExists: () => false,
+      getFileStats: () => ({ size: 0, modifiedAt: new Date(0) }),
+    },
+    output: { log: () => undefined, error: () => undefined },
+    sandboxService: { execute: async () => 0 },
+    getLatestPackageVersion: async () => '1.0.0',
+    updateGlobalPackage: () => undefined,
+    startServer: async () => undefined,
+    startBrowserUseMcp: async () => undefined,
+  });
+
+  return {
+    async run(argumentsList: string[]) {
+      const exitCode = await service.run(argumentsList);
+      await initializeDatabase();
+      userDb.createUser('bootstrap-user', 'password-hash');
+
+      const request: any = { headers: {}, query: {} };
+      const response: any = {
+        statusCode: 200,
+        body: null,
+        headers: {},
+        setHeader(name: string, value: string) {
+          this.headers[name] = value;
+        },
+        status(statusCode: number) {
+          this.statusCode = statusCode;
+          return this;
+        },
+        json(body: unknown) {
+          this.body = body;
+          return this;
+        },
+      };
+      let authNextCalled = false;
+      await authenticateToken(request, response, () => {
+        authNextCalled = true;
+      });
+      const runtime = getBrowserUseRuntime();
+
+      console.log(${JSON.stringify(RESULT_PREFIX)} + JSON.stringify({
+        command: argumentsList[0] ?? null,
+        environmentFileReads,
+        mode: process.env.VITE_IS_PLATFORM ?? null,
+        authNextCalled,
+        authStatus: response.statusCode,
+        authenticatedUsername: request.user?.username ?? null,
+        runtime,
+      }));
+      closeConnection();
+      return exitCode;
+    },
+  };
+}
+`;
+    await writeFile(path.join(fixtureCliDirectory, 'index.ts'), fixtureIndexSource, 'utf8');
+
+    const childEnvironment = { ...process.env };
+    delete childEnvironment.VITE_IS_PLATFORM;
+    delete childEnvironment.DATABASE_PATH;
+    const stdout = execFileSync(
+      process.execPath,
+      [
+        path.join(applicationRoot, 'node_modules', 'tsx', 'dist', 'cli.mjs'),
+        '--tsconfig',
+        path.join(applicationRoot, 'server', 'tsconfig.json'),
+        path.join(fixtureCliDirectory, 'cli.ts'),
+        'status',
+      ],
+      {
+        cwd: applicationRoot,
+        encoding: 'utf8',
+        env: childEnvironment,
+        timeout: 30_000,
+      },
+    );
+    const resultLine = stdout
+      .split(/\r?\n/)
+      .find((line) => line.startsWith(RESULT_PREFIX));
+    assert.ok(resultLine, `Missing bootstrap result in child output:\n${stdout}`);
+    return JSON.parse(resultLine.slice(RESULT_PREFIX.length)) as BootstrapResult;
+  } finally {
+    await rm(fixtureRoot, { recursive: true, force: true });
+  }
+}
+
+test('CLI bootstrap selects Platform authentication and cloud runtime from .env', async () => {
+  const result = await runCliBootstrapFixture(true);
+
+  assert.deepEqual(result, {
+    command: 'status',
+    environmentFileReads: 0,
+    mode: 'true',
+    authNextCalled: true,
+    authStatus: 200,
+    authenticatedUsername: 'bootstrap-user',
+    runtime: 'cloud',
+  });
+});
+
+test('CLI bootstrap selects OSS authentication and local runtime from .env', async () => {
+  const result = await runCliBootstrapFixture(false);
+
+  assert.deepEqual(result, {
+    command: 'status',
+    environmentFileReads: 0,
+    mode: 'false',
+    authNextCalled: false,
+    authStatus: 401,
+    authenticatedUsername: null,
+    runtime: 'local',
+  });
+});

package/server/modules/cli/tests/cli.service.test.ts

@@ -26,9 +26,6 @@ function createHarness() {
     },
     environment,
     fileSystem: {
-      readTextFile: () => {
-        throw new Error('missing');
-      },
       pathExists: () => false,
       getFileStats: () => ({ size: 0, modifiedAt: new Date(0) }),
     },

package/server/modules/database/connection.ts

@@ -10,11 +10,12 @@
  * `getConnection()` to obtain the shared singleton.
  */
 
-import Database from 'better-sqlite3';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
+import Database from 'better-sqlite3';
+
 import { APP_CONFIG_TABLE_SCHEMA_SQL } from '@/modules/database/schema.js';
 
 const __filename = fileURLToPath(import.meta.url);

package/server/modules/database/index.ts

@@ -12,6 +12,16 @@ export { providerModelsDb } from '@/modules/database/repositories/provider-model
 export { projectsDb } from '@/modules/database/repositories/projects.db.js';
 export { pushSubscriptionsDb } from '@/modules/database/repositories/push-subscriptions.js';
 export { scanStateDb } from '@/modules/database/repositories/scan-state.db.js';
+// sessionDraftsDb: used by User for drafts and Scheduled Messages for server-owned queued turns.
+export { sessionDraftsDb } from '@/modules/database/repositories/session-drafts.db.js';
+export type {
+  QueuedSessionMessageRecord,
+  SessionDraftRecord,
+} from '@/modules/database/repositories/session-drafts.db.js';
 export { sessionsDb } from '@/modules/database/repositories/sessions.db.js';
 export { userDb } from '@/modules/database/repositories/users.js';
+// userPreferencesDb: used by the User module to persist the settings that used to live in browser localStorage.
+export { userPreferencesDb } from '@/modules/database/repositories/user-preferences.db.js';
 export { vapidKeysDb } from '@/modules/database/repositories/vapid-keys.js';
+export { scheduledMessagesDb } from './repositories/scheduled-messages.db.js';
+export type { ScheduledMessageRow, ScheduledMessageStatus } from './repositories/scheduled-messages.db.js';