@cloudcli-ai/cloudcli 1.37.0 → 1.37.1

package/server/modules/database/repositories/provider-models.ts

@@ -0,0 +1,168 @@
+import { getConnection } from '@/modules/database/connection.js';
+import type {
+  CustomProviderModelInput,
+  CustomProviderModelRecord,
+  LLMProvider,
+} from '@/shared/types.js';
+
+type CustomProviderModelRow = {
+  id: number;
+  provider: LLMProvider;
+  model_id: string;
+  model_name: string;
+  sort_order: number;
+};
+
+const toCustomProviderModelRecord = (
+  row: CustomProviderModelRow,
+): CustomProviderModelRecord => ({
+  recordId: row.id,
+  provider: row.provider,
+  modelId: row.model_id,
+  model: row.model_name,
+  sortOrder: row.sort_order,
+});
+
+const readCustomProviderModelRow = (
+  provider: LLMProvider,
+  recordId: number,
+): CustomProviderModelRow | null => {
+  const row = getConnection().prepare(`
+    SELECT id, provider, model_id, model_name, sort_order
+    FROM provider_models
+    WHERE provider = ? AND id = ?
+  `).get(provider, recordId) as CustomProviderModelRow | undefined;
+
+  return row ?? null;
+};
+
+/**
+ * Custom provider-model persistence API consumed by the Providers module.
+ *
+ * Every row in this repository is user-created. Predefined models are owned by
+ * provider adapters and never enter this table. Model-id changes are propagated
+ * to stored sessions, while deletion replaces affected session selections with
+ * the predefined default supplied by the Providers service.
+ */
+export const providerModelsDb = {
+  listCustomProviderModels(provider: LLMProvider): CustomProviderModelRecord[] {
+    const rows = getConnection().prepare(`
+      SELECT id, provider, model_id, model_name, sort_order
+      FROM provider_models
+      WHERE provider = ?
+      ORDER BY sort_order ASC, lower(model_name) ASC, id ASC
+    `).all(provider) as CustomProviderModelRow[];
+
+    return rows.map(toCustomProviderModelRecord);
+  },
+
+  getCustomProviderModel(
+    provider: LLMProvider,
+    recordId: number,
+  ): CustomProviderModelRecord | null {
+    const row = readCustomProviderModelRow(provider, recordId);
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+
+  findCustomProviderModelByModelId(
+    provider: LLMProvider,
+    modelId: string,
+  ): CustomProviderModelRecord | null {
+    const row = getConnection().prepare(`
+      SELECT id, provider, model_id, model_name, sort_order
+      FROM provider_models
+      WHERE provider = ? AND model_id = ?
+    `).get(provider, modelId) as CustomProviderModelRow | undefined;
+
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+
+  createCustomProviderModel(
+    provider: LLMProvider,
+    input: CustomProviderModelInput,
+  ): CustomProviderModelRecord {
+    const db = getConnection();
+    const nextOrder = db.prepare(`
+      SELECT COALESCE(MAX(sort_order), -1) + 1 AS next_order
+      FROM provider_models
+      WHERE provider = ?
+    `).get(provider) as { next_order: number };
+
+    const result = db.prepare(`
+      INSERT INTO provider_models (provider, model_id, model_name, sort_order)
+      VALUES (?, ?, ?, ?)
+    `).run(provider, input.id, input.model, nextOrder.next_order);
+
+    const row = readCustomProviderModelRow(provider, Number(result.lastInsertRowid));
+    if (!row) {
+      throw new Error('Created provider model could not be read back.');
+    }
+
+    return toCustomProviderModelRecord(row);
+  },
+
+  updateCustomProviderModel(
+    provider: LLMProvider,
+    recordId: number,
+    input: CustomProviderModelInput,
+  ): CustomProviderModelRecord | null {
+    const db = getConnection();
+    const update = db.transaction(() => {
+      const previous = readCustomProviderModelRow(provider, recordId);
+      if (!previous) {
+        return null;
+      }
+
+      db.prepare(`
+        UPDATE provider_models
+        SET model_id = ?, model_name = ?, updated_at = CURRENT_TIMESTAMP
+        WHERE provider = ? AND id = ?
+      `).run(input.id, input.model, provider, recordId);
+
+      if (previous.model_id !== input.id) {
+        db.prepare(`
+          UPDATE sessions
+          SET model = ?, updated_at = CURRENT_TIMESTAMP
+          WHERE provider = ? AND model = ?
+        `).run(input.id, provider, previous.model_id);
+      }
+
+      return readCustomProviderModelRow(provider, recordId);
+    });
+
+    const row = update();
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+
+  deleteCustomProviderModel(
+    provider: LLMProvider,
+    recordId: number,
+    fallbackModelId: string,
+  ): CustomProviderModelRecord | null {
+    const db = getConnection();
+    const remove = db.transaction(() => {
+      const row = readCustomProviderModelRow(provider, recordId);
+      if (!row) {
+        return null;
+      }
+
+      // The effort is cleared alongside the model because it was chosen for the
+      // deleted model; replaced sessions resume on the fallback model's default.
+      db.prepare(`
+        UPDATE sessions
+        SET model = ?, effort = NULL, updated_at = CURRENT_TIMESTAMP
+        WHERE provider = ? AND model = ?
+      `).run(fallbackModelId, provider, row.model_id);
+
+      db.prepare(`
+        DELETE FROM provider_models
+        WHERE provider = ? AND id = ?
+      `).run(provider, recordId);
+
+      return row;
+    });
+
+    const row = remove();
+    return row ? toCustomProviderModelRecord(row) : null;
+  },
+};

package/server/modules/database/repositories/sessions.db.ts

@@ -11,13 +11,20 @@ type SessionRow = {
   custom_name: string | null;
   /** Model this session runs with; NULL until the app records one for it. */
   model: string | null;
+  /** Reasoning effort this session runs with; NULL until the app records one. */
+  effort: string | null;
   isArchived: number;
   created_at: string;
   updated_at: string;
 };
 
+type RecentSessionsPage = {
+  sessions: SessionRow[];
+  total: number;
+};
+
 const SESSION_ROW_COLUMNS =
-  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, isArchived, created_at, updated_at';
+  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, effort, isArchived, created_at, updated_at';
 
 const SQLITE_UTC_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
 
@@ -67,7 +74,9 @@ export const sessionsDb = {
    * The given id is the provider-native session id. Rows are keyed by
    * `provider_session_id` so a session that was first created by the app
    * (with an app-allocated `session_id`) is updated in place once its
-   * transcript shows up on disk, instead of producing a duplicate row.
+   * transcript shows up on disk, instead of producing a duplicate row. An
+   * app-created row keeps its existing name; synchronizer names only update
+   * rows that were themselves created by indexing provider storage.
    */
   createSession(
     providerSessionId: string,
@@ -103,7 +112,10 @@ export const sessionsDb = {
            project_path = ?,
            jsonl_path = ?,
            isArchived = 0,
-           custom_name = COALESCE(?, custom_name)
+           custom_name = CASE
+             WHEN session_id <> provider_session_id AND custom_name IS NOT NULL THEN custom_name
+             ELSE COALESCE(?, custom_name)
+           END
          WHERE session_id = ?`
       ).run(
         provider,
@@ -130,7 +142,11 @@ export const sessionsDb = {
          project_path = excluded.project_path,
          jsonl_path = excluded.jsonl_path,
          isArchived = 0,
-         custom_name = COALESCE(excluded.custom_name, sessions.custom_name)`
+         custom_name = CASE
+           WHEN sessions.session_id <> sessions.provider_session_id AND sessions.custom_name IS NOT NULL
+             THEN sessions.custom_name
+           ELSE COALESCE(excluded.custom_name, sessions.custom_name)
+         END`
     ).run(
       providerSessionId,
       provider,
@@ -151,9 +167,15 @@ export const sessionsDb = {
    * The session gateway uses this when the frontend starts a brand-new chat:
    * `session_id` is the stable app-facing id, while `provider_session_id`
    * stays NULL until the provider runtime announces its own id and
-   * `assignProviderSessionId` records the mapping.
+   * `assignProviderSessionId` records the mapping. `customName` is derived
+   * from the first visible CloudCLI message by the sessions service.
    */
-  createAppSession(sessionId: string, provider: string, projectPath: string): string {
+  createAppSession(
+    sessionId: string,
+    provider: string,
+    projectPath: string,
+    customName?: string,
+  ): string {
     const db = getConnection();
     const normalizedProjectPath = normalizeProjectPathForProvider(provider, projectPath);
 
@@ -161,8 +183,8 @@ export const sessionsDb = {
 
     db.prepare(
       `INSERT INTO sessions (session_id, provider, provider_session_id, custom_name, project_path, jsonl_path, isArchived, created_at, updated_at)
-       VALUES (?, ?, NULL, NULL, ?, NULL, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`
-    ).run(sessionId, provider, normalizedProjectPath);
+       VALUES (?, ?, NULL, ?, ?, NULL, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)`
+    ).run(sessionId, provider, customName ?? null, normalizedProjectPath);
 
     return sessionId;
   },
@@ -229,6 +251,21 @@ export const sessionsDb = {
     ).run(model, sessionId);
   },
 
+  /**
+   * Records the reasoning effort one session runs with.
+   *
+   * `default` is stored as an explicit choice rather than NULL so reopening
+   * the session does not inherit a later per-provider effort preference.
+   */
+  setSessionEffort(sessionId: string, effort: string): void {
+    const db = getConnection();
+    db.prepare(
+      `UPDATE sessions
+       SET effort = ?
+       WHERE session_id = ?`
+    ).run(effort, sessionId);
+  },
+
   updateSessionCustomName(sessionId: string, customName: string): void {
     const db = getConnection();
     db.prepare(
@@ -325,6 +362,46 @@ export const sessionsDb = {
     return normalizeSessionRows(rows);
   },
 
+  /**
+   * Returns one globally ordered page of visible conversations.
+   *
+   * Pagination happens after archived sessions and sessions belonging to an
+   * archived project have been excluded. This keeps the sidebar feed complete
+   * and correctly ordered across projects instead of flattening only the
+   * per-project slices already loaded by the client.
+   */
+  getRecentSessionsPage(limit: number, offset: number): RecentSessionsPage {
+    const db = getConnection();
+    const visibilityClause = `
+      sessions.isArchived = 0
+      AND (projects.isArchived IS NULL OR projects.isArchived = 0)
+    `;
+    const rows = db
+      .prepare(
+        `SELECT sessions.*
+         FROM sessions
+         LEFT JOIN projects ON projects.project_path = sessions.project_path
+         WHERE ${visibilityClause}
+         ORDER BY julianday(COALESCE(sessions.updated_at, sessions.created_at)) DESC,
+                  sessions.session_id DESC
+         LIMIT ? OFFSET ?`
+      )
+      .all(limit, offset) as SessionRow[];
+    const countRow = db
+      .prepare(
+        `SELECT COUNT(*) AS count
+         FROM sessions
+         LEFT JOIN projects ON projects.project_path = sessions.project_path
+         WHERE ${visibilityClause}`
+      )
+      .get() as { count: number } | undefined;
+
+    return {
+      sessions: normalizeSessionRows(rows),
+      total: Number(countRow?.count ?? 0),
+    };
+  },
+
   /**
    * Archived rows are intentionally queried separately so the caller can render
    * them in a dedicated view without reintroducing them into active session lists.

package/server/modules/database/schema.ts

@@ -109,10 +109,11 @@ CREATE TABLE IF NOT EXISTS sessions (
     custom_name TEXT,
     project_path TEXT,
     jsonl_path TEXT,
-    -- Model this session runs with. Written when the user picks a model for the
-    -- session and on every send, so reopening a session restores the model it
-    -- was last used with instead of falling back to the catalog default.
+    -- Model and reasoning effort this session runs with. Written when the user
+    -- changes either selection and on every send, so reopening a session
+    -- restores its exact runtime configuration instead of provider defaults.
     model TEXT,
+    effort TEXT,
     isArchived BOOLEAN DEFAULT 0,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
@@ -138,6 +139,27 @@ CREATE TABLE IF NOT EXISTS app_config (
 );
 `;
 
+/**
+ * Persistent custom-model library used by the Providers module.
+ *
+ * Only user-created models are stored here. Predefined models remain source-
+ * controlled in each provider's `-models.provider.ts` adapter so they can be
+ * updated without migrating application data. `model_id` is unique only within
+ * a provider because different CLIs can accept the same identifier.
+ */
+export const PROVIDER_MODELS_TABLE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS provider_models (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    provider TEXT NOT NULL CHECK (provider IN ('claude', 'cursor', 'codex', 'opencode')),
+    model_id TEXT NOT NULL,
+    model_name TEXT NOT NULL,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(provider, model_id)
+);
+`;
+
 export const INIT_SCHEMA_SQL = `
 -- Initialize authentication database
 PRAGMA foreign_keys = ON;
@@ -181,4 +203,8 @@ CREATE INDEX IF NOT EXISTS idx_session_ids_lookup ON sessions(session_id);
 ${LAST_SCANNED_AT_SQL}
 
 ${APP_CONFIG_TABLE_SCHEMA_SQL}
+
+${PROVIDER_MODELS_TABLE_SCHEMA_SQL}
+CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
+ON provider_models(provider, sort_order, id);
 `;

package/server/modules/database/tests/provider-models.db.integration.test.ts

@@ -0,0 +1,125 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  closeConnection,
+  getConnection,
+  initializeDatabase,
+  providerModelsDb,
+  sessionsDb,
+} from '@/modules/database/index.js';
+import { runMigrations } from '@/modules/database/migrations.js';
+
+test('provider model repository stores custom rows only and maintains session references', async () => {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-model-db-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await writeFile(databasePath, '');
+  await initializeDatabase();
+
+  try {
+    const columns = getConnection().prepare('PRAGMA table_info(provider_models)').all() as Array<{
+      name: string;
+    }>;
+    assert.deepEqual(columns.map((column) => column.name), [
+      'id',
+      'provider',
+      'model_id',
+      'model_name',
+      'sort_order',
+      'created_at',
+      'updated_at',
+    ]);
+    assert.deepEqual(providerModelsDb.listCustomProviderModels('codex'), []);
+
+    const custom = providerModelsDb.createCustomProviderModel('codex', {
+      model: 'Private Gateway Model',
+      id: 'gateway/model-v1',
+    });
+    assert.equal(custom.modelId, 'gateway/model-v1');
+    assert.equal(
+      providerModelsDb.findCustomProviderModelByModelId('codex', 'gateway/model-v1')?.recordId,
+      custom.recordId,
+    );
+
+    const db = getConnection();
+    db.prepare(`
+      INSERT INTO projects (project_id, project_path)
+      VALUES ('project-1', '/tmp/project-1')
+    `).run();
+    db.prepare(`
+      INSERT INTO sessions (session_id, provider, project_path, model, effort)
+      VALUES ('session-1', 'codex', '/tmp/project-1', 'gateway/model-v1', 'high')
+    `).run();
+
+    const updated = providerModelsDb.updateCustomProviderModel('codex', custom.recordId, {
+      model: 'Private Gateway Model 2',
+      id: 'gateway/model-v2',
+    });
+    assert.equal(updated?.modelId, 'gateway/model-v2');
+    assert.equal(sessionsDb.getSessionById('session-1')?.model, 'gateway/model-v2');
+    // A rename keeps the same underlying model, so its effort stays applicable.
+    assert.equal(sessionsDb.getSessionById('session-1')?.effort, 'high');
+
+    const removed = providerModelsDb.deleteCustomProviderModel(
+      'codex',
+      custom.recordId,
+      'gpt-default',
+    );
+    assert.equal(removed?.modelId, 'gateway/model-v2');
+    assert.equal(sessionsDb.getSessionById('session-1')?.model, 'gpt-default');
+    // The effort belonged to the deleted model and must not survive onto the
+    // fallback, which has its own default.
+    assert.equal(sessionsDb.getSessionById('session-1')?.effort, null);
+    assert.equal(providerModelsDb.getCustomProviderModel('codex', custom.recordId), null);
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('migrations create the provider model index on an install that lacks it', async () => {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-model-index-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await writeFile(databasePath, '');
+  await initializeDatabase();
+
+  try {
+    const db = getConnection();
+    // Upgraded installs reach runMigrations with provider_models present but no
+    // index, so the CREATE INDEX statement is compiled against the real table
+    // instead of short-circuiting on the existing index name.
+    db.exec('DROP INDEX IF EXISTS idx_provider_models_provider_order');
+
+    runMigrations(db);
+
+    const indexedColumns = (db
+      .prepare('PRAGMA index_info(idx_provider_models_provider_order)')
+      .all() as Array<{ name: string }>)
+      .map((column) => column.name);
+    assert.deepEqual(indexedColumns, ['provider', 'sort_order', 'id']);
+  } finally {
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});

package/server/modules/database/tests/sessions-provider-mapping.test.ts

@@ -45,7 +45,7 @@ test('disk-discovered sessions are keyed by the provider id for both columns', a
 
 test('app sessions get the provider id assigned without creating a duplicate row', async () => {
   await withIsolatedDatabase(() => {
-    sessionsDb.createAppSession('app-id-1', 'claude', '/workspace/demo');
+    sessionsDb.createAppSession('app-id-1', 'claude', '/workspace/demo', 'Initial CloudCLI message');
     sessionsDb.assignProviderSessionId('app-id-1', 'provider-xyz');
 
     // A later synchronizer pass that discovers the transcript on disk must
@@ -66,6 +66,7 @@ test('app sessions get the provider id assigned without creating a duplicate row
     const row = sessionsDb.getSessionById('app-id-1');
     assert.equal(row?.provider_session_id, 'provider-xyz');
     assert.equal(row?.jsonl_path, '/fake/path/provider-xyz.jsonl');
+    assert.equal(row?.custom_name, 'Initial CloudCLI message');
   });
 });
 

package/server/modules/database/tests/sessions.db.integration.test.ts

@@ -6,6 +6,7 @@ import test from 'node:test';
 
 import { closeConnection } from '@/modules/database/connection.js';
 import { initializeDatabase } from '@/modules/database/init-db.js';
+import { projectsDb } from '@/modules/database/repositories/projects.db.js';
 import { sessionsDb } from '@/modules/database/repositories/sessions.db.js';
 
 async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
@@ -82,3 +83,34 @@ test('repository reads normalize SQLite UTC timestamps to ISO strings', async ()
     assert.match(row?.updated_at ?? '', /^\d{4}-\d{2}-\d{2}T/);
   });
 });
+
+test('recent sessions are globally ordered, paginated, and limited to visible conversations', async () => {
+  await withIsolatedDatabase(() => {
+    const fixtures: Array<Parameters<typeof sessionsDb.createSession>> = [
+      ['session-oldest', 'claude', '/workspace/project-a', 'Oldest', '2026-07-18T09:00:00.000Z', '2026-07-18T10:00:00.000Z'],
+      ['session-newest', 'codex', '/workspace/project-b', 'Newest', '2026-07-18T11:00:00.000Z', '2026-07-18T12:00:00.900Z'],
+      ['session-same-second', 'claude', '/workspace/project-a', 'Same second, slightly older', '2026-07-18T12:00:00.000Z', '2026-07-18T12:00:00.100Z'],
+      ['session-middle', 'claude', '/workspace/project-a', 'Middle', '2026-07-18T10:00:00.000Z', '2026-07-18T11:00:00.000Z'],
+      ['session-archived', 'claude', '/workspace/project-a', 'Archived session', '2026-07-18T13:00:00.000Z', '2026-07-18T13:00:00.000Z'],
+      ['session-hidden-project', 'claude', '/workspace/project-hidden', 'Archived project session', '2026-07-18T14:00:00.000Z', '2026-07-18T14:00:00.000Z'],
+    ];
+    fixtures.forEach((fixture) => sessionsDb.createSession(...fixture));
+
+    sessionsDb.updateSessionIsArchived('session-archived', true);
+    projectsDb.updateProjectIsArchived('/workspace/project-hidden', true);
+
+    const firstPage = sessionsDb.getRecentSessionsPage(2, 0);
+    const secondPage = sessionsDb.getRecentSessionsPage(2, 2);
+
+    assert.equal(firstPage.total, 4);
+    assert.deepEqual(
+      firstPage.sessions.map((session) => session.session_id),
+      ['session-newest', 'session-same-second'],
+    );
+    assert.equal(secondPage.total, 4);
+    assert.deepEqual(
+      secondPage.sessions.map((session) => session.session_id),
+      ['session-middle', 'session-oldest'],
+    );
+  });
+});

package/server/modules/file-tree/file-tree.module.ts

@@ -36,7 +36,11 @@ const fileTreeFileSystem: FileTreeFileSystem = {
   access: (candidatePath) => fsPromises.access(candidatePath),
   stat: (candidatePath) => fsPromises.stat(candidatePath),
   lstat: (candidatePath) => fsPromises.lstat(candidatePath),
-  readdir: (directoryPath) => fsPromises.readdir(directoryPath, { withFileTypes: true }),
+  // `opendir` streams entries in batches and the handle is closed by the
+  // iterator protocol, including when the caller stops early at the entry cap.
+  openDirectory: async function* (directoryPath) {
+    yield* await fsPromises.opendir(directoryPath);
+  },
   realpath: (candidatePath) => fsPromises.realpath(candidatePath),
   readTextFile: (filePath) => fsPromises.readFile(filePath, 'utf8'),
   writeTextFile: (filePath, content) => fsPromises.writeFile(filePath, content, 'utf8'),