@cloudcli-ai/cloudcli 1.37.0 → 1.37.1

package/server/modules/providers/tests/provider-runtime.service.test.ts

@@ -61,12 +61,8 @@ function createService(providers: IProvider[]) {
     },
     async getProviderModels() {
       return {
-        models: { OPTIONS: [], DEFAULT: 'default-model' },
-        cache: {
-          updatedAt: new Date(0).toISOString(),
-          expiresAt: new Date(0).toISOString(),
-          source: 'fresh',
-        },
+        OPTIONS: [],
+        DEFAULT: 'default-model',
       };
     },
   });

package/server/modules/providers/tests/provider-token-usage.service.test.ts

@@ -18,6 +18,7 @@ function createSessionRow(overrides: Record<string, unknown> = {}) {
     jsonl_path: null,
     custom_name: null,
     model: null,
+    effort: null,
     isArchived: 0,
     created_at: '2026-01-01T00:00:00.000Z',
     updated_at: '2026-01-01T00:00:00.000Z',

package/server/modules/providers/tests/provider.routes.test.ts

@@ -0,0 +1,183 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import type { AddressInfo } from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import express, { type NextFunction, type Request, type Response } from 'express';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import providerRouter from '@/modules/providers/provider.routes.js';
+import { AppError } from '@/shared/utils.js';
+
+async function withProviderServer(
+  run: (baseUrl: string, workspacePath: string) => Promise<void>,
+): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-routes-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await writeFile(process.env.DATABASE_PATH, '');
+  await initializeDatabase();
+
+  const app = express().use(express.json()).use('/api/providers', providerRouter);
+  app.use((error: unknown, _req: Request, res: Response, _next: NextFunction) => {
+    if (error instanceof AppError) {
+      res.status(error.statusCode).json({
+        success: false,
+        error: { code: error.code, message: error.message },
+      });
+      return;
+    }
+    res.status(500).json({ success: false, error: { code: 'INTERNAL_ERROR' } });
+  });
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    await run(`http://127.0.0.1:${address.port}`, path.join(tempDirectory, 'workspace'));
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('session creation route names a CloudCLI session from the initial message', async () => {
+  await withProviderServer(async (baseUrl, workspacePath) => {
+    const response = await fetch(`${baseUrl}/api/providers/sessions`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        provider: 'codex',
+        projectPath: workspacePath,
+        initialMessage: 'abcd  efg\nhij klm nop',
+      }),
+    });
+    const payload = await response.json() as {
+      data: { sessionId: string; sessionName: string };
+    };
+
+    assert.equal(response.status, 201);
+    assert.equal(payload.data.sessionName, 'abcd efg hij klm');
+    assert.equal(
+      sessionsDb.getSessionById(payload.data.sessionId)?.custom_name,
+      'abcd efg hij klm',
+    );
+  });
+});
+
+test('reasoning effort is persisted and returned with the active session model', async () => {
+  await withProviderServer(async (baseUrl, workspacePath) => {
+    sessionsDb.createAppSession('effort-session', 'codex', workspacePath);
+
+    const updateResponse = await fetch(
+      `${baseUrl}/api/providers/codex/sessions/effort-session/active-effort`,
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ effort: 'ultra' }),
+      },
+    );
+    const updatePayload = await updateResponse.json() as {
+      data: { effort: string; sessionId: string };
+    };
+
+    assert.equal(updateResponse.status, 200);
+    assert.equal(updatePayload.data.effort, 'ultra');
+    assert.equal(sessionsDb.getSessionById('effort-session')?.effort, 'ultra');
+
+    const readResponse = await fetch(
+      `${baseUrl}/api/providers/codex/sessions/effort-session/active-model`,
+    );
+    const readPayload = await readResponse.json() as {
+      data: { effort: string | null; sessionId: string };
+    };
+
+    assert.equal(readResponse.status, 200);
+    assert.equal(readPayload.data.sessionId, 'effort-session');
+    assert.equal(readPayload.data.effort, 'ultra');
+  });
+});
+
+test('model routes expose immutable defaults and full custom model CRUD', async () => {
+  await withProviderServer(async (baseUrl) => {
+    const initialResponse = await fetch(`${baseUrl}/api/providers/codex/models`);
+    const initialPayload = await initialResponse.json() as {
+      data: {
+        cache?: unknown;
+        models: {
+          OPTIONS: Array<{ recordId?: number; value: string; isCustom: boolean }>;
+        };
+      };
+    };
+    assert.equal(initialResponse.status, 200);
+    assert.equal('cache' in initialPayload.data, false);
+    const predefined = initialPayload.data.models.OPTIONS[0];
+    assert.equal(predefined.isCustom, false);
+    assert.equal(predefined.recordId, undefined);
+
+    const createResponse = await fetch(`${baseUrl}/api/providers/codex/models`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model: 'Gateway GPT', id: 'gateway/gpt' }),
+    });
+    const createPayload = await createResponse.json() as {
+      data: { model: { recordId: number; value: string; label: string; isCustom: boolean } };
+    };
+    assert.equal(createResponse.status, 201);
+    assert.equal(createPayload.data.model.isCustom, true);
+    const customRecordId = createPayload.data.model.recordId;
+
+    const updateResponse = await fetch(
+      `${baseUrl}/api/providers/codex/models/${customRecordId}`,
+      {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model: 'Gateway GPT Updated', id: 'gateway/gpt-v2' }),
+      },
+    );
+    const updatePayload = await updateResponse.json() as {
+      data: { model: { value: string; label: string } };
+    };
+    assert.equal(updateResponse.status, 200);
+    assert.equal(updatePayload.data.model.value, 'gateway/gpt-v2');
+    assert.equal(updatePayload.data.model.label, 'Gateway GPT Updated');
+
+    const immutableResponse = await fetch(
+      `${baseUrl}/api/providers/codex/models/999999`,
+      {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model: 'Changed', id: 'changed' }),
+      },
+    );
+    const immutablePayload = await immutableResponse.json() as { error: { code: string } };
+    assert.equal(immutableResponse.status, 404);
+    assert.equal(immutablePayload.error.code, 'MODEL_NOT_FOUND');
+
+    const deleteResponse = await fetch(
+      `${baseUrl}/api/providers/codex/models/${customRecordId}`,
+      { method: 'DELETE' },
+    );
+    const deletePayload = await deleteResponse.json() as {
+      data: { models: { OPTIONS: Array<{ recordId: number }> } };
+    };
+    assert.equal(deleteResponse.status, 200);
+    assert.equal(
+      deletePayload.data.models.OPTIONS.some((option) => option.recordId === customRecordId),
+      false,
+    );
+  });
+});

package/server/modules/providers/tests/sessions.service.test.ts

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, projectsDb, sessionsDb } from '@/modules/database/index.js';
+import { sessionsService } from '@/modules/providers/services/sessions.service.js';
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'sessions-service-db-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('provider session id returns the mapped native id', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-session-id', 'codex', '/tmp/session-id-copy-project');
+    sessionsDb.assignProviderSessionId('app-session-id', 'codex-native-session-id');
+
+    assert.equal(sessionsService.getProviderSessionId('app-session-id'), 'codex-native-session-id');
+  });
+});
+
+test('app session names use at most four whole words from the initial message', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    const result = sessionsService.createAppSession(
+      'codex',
+      '/tmp/session-name-project',
+      '  supercalifragilisticexpialidocious\nsecond   third fourth fifth  ',
+    );
+
+    assert.equal(result.sessionName, 'supercalifragilisticexpialidocious second third fourth');
+    assert.equal(
+      sessionsDb.getSessionById(result.sessionId)?.custom_name,
+      'supercalifragilisticexpialidocious second third fourth',
+    );
+  });
+});
+
+test('app sessions without message text receive a stable fallback name', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    const result = sessionsService.createAppSession('claude', '/tmp/attachment-only-project', '  \n ');
+
+    assert.equal(result.sessionName, 'Untitled Session');
+    assert.equal(sessionsDb.getSessionById(result.sessionId)?.custom_name, 'Untitled Session');
+  });
+});
+
+test('provider session id is unavailable until the provider assigns one', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('pending-app-session', 'claude', '/tmp/session-id-copy-project');
+
+    assert.throws(
+      () => sessionsService.getProviderSessionId('pending-app-session'),
+      (error: unknown) => {
+        const typedError = error as { code?: string; statusCode?: number };
+        return typedError.code === 'PROVIDER_SESSION_ID_NOT_AVAILABLE' && typedError.statusCode === 409;
+      },
+    );
+  });
+});
+
+test('provider session id reports a missing app session', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    assert.throws(
+      () => sessionsService.getProviderSessionId('missing-session'),
+      (error: unknown) => {
+        const typedError = error as { code?: string; statusCode?: number };
+        return typedError.code === 'SESSION_NOT_FOUND' && typedError.statusCode === 404;
+      },
+    );
+  });
+});
+
+test('recent sessions map project metadata and preserve database pagination', { concurrency: false }, async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createSession(
+      'older-session',
+      'claude',
+      '/tmp/recent-project',
+      'Older conversation',
+      '2026-08-01T08:00:00.000Z',
+      '2026-08-01T09:00:00.000Z',
+    );
+    sessionsDb.createSession(
+      'newer-session',
+      'codex',
+      '/tmp/recent-project',
+      'Newer conversation',
+      '2026-08-01T10:00:00.000Z',
+      '2026-08-01T11:00:00.000Z',
+    );
+    projectsDb.updateCustomProjectName('/tmp/recent-project', 'Recent Project');
+
+    const project = projectsDb.getProjectPath('/tmp/recent-project');
+    const page = sessionsService.listRecentSessions(1, 0);
+
+    assert.deepEqual(page, {
+      conversations: [{
+        sessionId: 'newer-session',
+        provider: 'codex',
+        projectId: project?.project_id ?? null,
+        projectDisplayName: 'Recent Project',
+        sessionTitle: 'Newer conversation',
+        lastActivity: '2026-08-01T11:00:00.000Z',
+      }],
+      total: 2,
+      hasMore: true,
+    });
+  });
+});

package/server/modules/websocket/services/chat-websocket.service.ts

@@ -194,10 +194,14 @@ async function handleChatSend(
   const command = typeof data.content === 'string' ? data.content : '';
 
   // Record what this turn runs with so reopening the session later restores the
-  // same model, and so the resume path has a session-scoped answer to use.
+  // same model and reasoning effort, and so the resume path has a
+  // session-scoped model answer to use.
   if (typeof clientOptions.model === 'string' && clientOptions.model.trim()) {
     providerModelsService.setSessionModel(provider, sessionId, clientOptions.model);
   }
+  if (typeof clientOptions.effort === 'string' && clientOptions.effort.trim()) {
+    providerModelsService.setSessionEffort(provider, sessionId, clientOptions.effort);
+  }
 
   const attachmentCandidates = [
     ...normalizeAttachmentDescriptors(clientOptions.images),

package/server/shared/interfaces.ts

@@ -60,15 +60,13 @@ export interface IProvider {
 /**
  * Model catalog contract for one provider.
  *
- * Implementations are responsible for resolving the provider's currently
- * supported models and converting them into the shared
- * `ProviderModelsDefinition` shape used by backend routes and frontend model
- * pickers. The `DEFAULT` field should be the most appropriate default selection
- * for that provider at the time the catalog is read.
+ * Implementations supply CloudCLI's curated predefined models and can inspect
+ * provider-native session state. The Providers service merges these immutable
+ * source-controlled definitions with user-created SQLite rows at read time.
  */
 export interface IProviderModels {
   /**
-   * Returns the provider's currently supported model catalog.
+   * Returns the curated predefined catalog owned by this provider adapter.
    */
   getSupportedModels(): Promise<ProviderModelsDefinition>;
 

package/server/shared/types.ts

@@ -75,6 +75,10 @@ export type ProviderModelOption = {
   value: string;
   label: string;
   description?: string;
+  /** Stable SQLite row id used only by model-management actions. */
+  recordId?: number;
+  /** True for user-created rows; false for immutable CloudCLI defaults. */
+  isCustom?: boolean;
   effort?: {
     default?: string;
     values: {
@@ -93,28 +97,31 @@ export type ProviderModelsDefinition = {
 };
 
 /**
- * Cache metadata returned alongside one provider model catalog.
+ * One persisted custom-model row in the provider model library.
  *
- * `updatedAt` is when the current cached snapshot was last refreshed from the
- * provider itself. `expiresAt` is the backend cache expiry timestamp, and
- * `source` tells callers whether the current response came from in-memory cache,
- * persisted disk cache, or a fresh provider fetch.
+ * Provider modules use this shape at the database boundary. Predefined models
+ * never use this type because they remain source-controlled in provider
+ * adapters. `modelId` is sent to the provider runtime, while `model` is the
+ * user-supplied display name shown in pickers.
  */
-export type ProviderModelsCacheInfo = {
-  updatedAt: string;
-  expiresAt: string;
-  source: 'memory' | 'disk' | 'fresh';
+export type CustomProviderModelRecord = {
+  recordId: number;
+  provider: LLMProvider;
+  modelId: string;
+  model: string;
+  sortOrder: number;
 };
 
 /**
- * Full provider model lookup result returned by the backend service layer.
+ * User-editable values accepted when creating or changing a custom model.
  *
- * Use this shape when a caller needs both the selectable model catalog and the
- * cache metadata that explains how current the catalog is.
+ * `id` must be the exact provider-facing model identifier and cannot contain
+ * whitespace. `model` is a concise display name. The provider is supplied by
+ * the route path so a row can never be moved across providers accidentally.
  */
-export type ProviderModelsResult = {
-  models: ProviderModelsDefinition;
-  cache: ProviderModelsCacheInfo;
+export type CustomProviderModelInput = {
+  id: string;
+  model: string;
 };
 
 // ---------------------------
@@ -147,7 +154,8 @@ export type ProviderCurrentActiveModel = {
 export type ProviderSessionModelSource = 'session' | 'provider' | 'default';
 
 /**
- * The model one session runs with, plus where that answer came from.
+ * The model one session runs with, its persisted reasoning effort when one has
+ * been recorded, and where the model answer came from.
  *
  * Returned by `providerModelsService.resolveSessionModel` and used by the
  * `/models`, `/cost` and `/status` commands, the active-model route, and the
@@ -157,6 +165,8 @@ export type ProviderSessionModel = {
   provider: LLMProvider;
   sessionId: string | null;
   model: string;
+  /** NULL means this session has not recorded an effort choice yet. */
+  effort: string | null;
   source: ProviderSessionModelSource;
 };
 
@@ -944,7 +954,9 @@ export type FileTreeFileSystem = {
   access(candidatePath: string): Promise<void>;
   stat(candidatePath: string): Promise<FileTreeStats>;
   lstat(candidatePath: string): Promise<FileTreeStats>;
-  readdir(directoryPath: string): Promise<FileTreeDirectoryEntry[]>;
+  // Streamed rather than returned as an array so a directory with millions of
+  // children is abandoned at the entry limit instead of being materialized.
+  openDirectory(directoryPath: string): AsyncIterable<FileTreeDirectoryEntry>;
   realpath(candidatePath: string): Promise<string>;
   readTextFile(filePath: string): Promise<string>;
   writeTextFile(filePath: string, content: string): Promise<void>;