@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

package/server/{routes/commands.js → modules/commands/commands.routes.ts}

@@ -1,18 +1,31 @@
-import { promises as fs } from "fs";
-import os from "os";
+// @ts-nocheck -- temporary while command handlers are extracted into the injected service.
 import path from "path";
 
 import express from "express";
 
-import { providerModelsService } from "../modules/providers/services/provider-models.service.js";
-import { parseFrontMatter } from "../shared/frontmatter.js";
-import { findAppRoot, getModuleDir } from "../utils/runtime-paths.js";
-
-const __dirname = getModuleDir(import.meta.url);
-// This route reads the top-level package.json for the status command, so it needs the real
-// app root even after compilation moves the route file under dist-server/server/routes.
-const APP_ROOT = findAppRoot(__dirname);
+import { parseFrontMatter } from "../../shared/frontmatter.js";
+
+type CommandsRouterDependencies = {
+  fileSystem: typeof import('node:fs/promises');
+  homeDirectory(): string;
+  appRoot: string;
+  models: typeof import('../providers/index.js').providerModelsService;
+  runtime: {
+    uptime(): number;
+    memoryUsage(): NodeJS.MemoryUsage;
+    version: string;
+    platform: NodeJS.Platform;
+    pid: number;
+  };
+};
 
+/** Creates Commands routes around explicit filesystem, model-catalog, and runtime adapters. */
+export function createCommandsRouter(dependencies: CommandsRouterDependencies): express.Router {
+const fs = dependencies.fileSystem;
+const os = { homedir: dependencies.homeDirectory };
+const APP_ROOT = dependencies.appRoot;
+const providerModelsService = dependencies.models;
+const process = dependencies.runtime;
 const router = express.Router();
 
 const MODEL_PROVIDERS = ["claude", "cursor", "codex", "opencode"];
@@ -33,30 +46,26 @@ const readModelProvider = (value) => {
   return MODEL_PROVIDERS.includes(normalized) ? normalized : "claude";
 };
 
-const hasConcreteSessionId = (value) =>
-  typeof value === "string" && value.trim().length > 0;
-
-const resolveCommandModel = async (provider, catalog, sessionId) => {
-  if (!hasConcreteSessionId(sessionId)) {
-    return catalog.DEFAULT;
-  }
-
-  const currentActiveModel = await providerModelsService.getCurrentActiveModel(
-    provider,
-    sessionId,
-  );
-  return currentActiveModel?.model || catalog.DEFAULT;
+/**
+ * Resolves the model a command should report.
+ *
+ * `context.model` is what the composer would send right now, so it stands in
+ * for a chat that has no session row yet; the service prefers the session's own
+ * recorded model whenever there is one.
+ */
+const resolveCommandModel = async (modelsService, provider, context) => {
+  const resolved = await modelsService.resolveSessionModel(provider, {
+    sessionId: context?.sessionId,
+    requestedModel: context?.model,
+  });
+  return resolved.model;
 };
 
-export const executeModelsCommand = async (args, context) => {
+const executeModelsCommand = async (args, context, modelsService) => {
   const currentProvider = readModelProvider(context?.provider);
-  const result = await providerModelsService.getProviderModels(currentProvider);
+  const result = await modelsService.getProviderModels(currentProvider);
   const catalog = result.models;
-  const currentModel = await resolveCommandModel(
-    currentProvider,
-    catalog,
-    context?.sessionId,
-  );
+  const currentModel = await resolveCommandModel(modelsService, currentProvider, context);
   const availableModels = catalog.OPTIONS.map((option) => option.value);
   const availableOptions = catalog.OPTIONS.map((option) => ({
     value: option.value,
@@ -249,13 +258,12 @@ Custom commands can be created in:
     };
   },
 
-  "/models": executeModelsCommand,
+  "/models": (args, context) => executeModelsCommand(args, context, providerModelsService),
 
   "/cost": async (args, context) => {
     const tokenUsage = context?.tokenUsage || {};
     const provider = readModelProvider(context?.provider);
-    const catalog = (await providerModelsService.getProviderModels(provider)).models;
-    const model = await resolveCommandModel(provider, catalog, context?.sessionId);
+    const model = await resolveCommandModel(providerModelsService, provider, context);
 
     const reportedUsed =
       Number(
@@ -357,8 +365,7 @@ Custom commands can be created in:
         : `${uptimeMinutes}m`;
 
     const statusProvider = readModelProvider(context?.provider);
-    const statusCatalog = (await providerModelsService.getProviderModels(statusProvider)).models;
-    const model = await resolveCommandModel(statusProvider, statusCatalog, context?.sessionId);
+    const model = await resolveCommandModel(providerModelsService, statusProvider, context);
     const memoryUsage = process.memoryUsage();
 
     return {
@@ -593,4 +600,5 @@ router.post("/execute", async (req, res) => {
   }
 });
 
-export default router;
+return router;
+}

package/server/modules/commands/index.ts

@@ -0,0 +1,2 @@
+// commandsRoutes: used by the server entrypoint to mount protected slash-command endpoints.
+export { commandsRoutes } from './commands.module.js';

package/server/modules/commands/tests/commands.test.ts

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import test from 'node:test';
+
+import express from 'express';
+
+import { createCommandsRouter } from '../commands.routes.js';
+
+/**
+ * Stands in for `providerModelsService`. `resolveSessionModel` mirrors the real
+ * precedence closely enough for the command handlers: a model recorded for the
+ * session wins, otherwise the client's requested model, otherwise the catalog
+ * default.
+ */
+function createModelsService(sessionModels: Record<string, string> = {}) {
+  return {
+    getProviderModels: async () => ({
+      models: { OPTIONS: [{ value: 'default', label: 'Default' }], DEFAULT: 'default' },
+      cache: {
+        updatedAt: '2026-01-01T00:00:00.000Z',
+        expiresAt: '2026-01-02T00:00:00.000Z',
+        source: 'fresh' as const,
+      },
+    }),
+    getCurrentActiveModel: async () => ({ model: 'default' }),
+    setSessionModel: () => null,
+    resolveSessionModel: async (
+      provider: string,
+      options: { sessionId?: string | null; requestedModel?: string | null } = {},
+    ) => {
+      const recorded = options.sessionId ? sessionModels[options.sessionId] : undefined;
+      const model = recorded || options.requestedModel || 'default';
+      return {
+        provider,
+        sessionId: options.sessionId ?? null,
+        model,
+        source: model === 'default' ? 'default' : 'session',
+      };
+    },
+    resolveResumeModel: async () => undefined,
+    clearCache: () => undefined,
+  };
+}
+
+async function executeCommand(
+  commandName: string,
+  context: Record<string, unknown>,
+  sessionModels: Record<string, string> = {},
+): Promise<Record<string, unknown>> {
+  const router = createCommandsRouter({
+    fileSystem: {
+      readFile: async () => JSON.stringify({ name: 'claude-code-ui', version: '0.0.0-test' }),
+    } as unknown as typeof import('node:fs/promises'),
+    homeDirectory: () => '/home/test',
+    appRoot: '/app',
+    models: createModelsService(sessionModels) as never,
+    runtime: {
+      uptime: () => 0,
+      memoryUsage: () => ({ rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 }),
+      version: 'v22', platform: 'linux', pid: 1,
+    },
+  });
+  const app = express().use(express.json()).use('/api/commands', router);
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+  try {
+    const address = server.address() as AddressInfo;
+    const response = await fetch(`http://127.0.0.1:${address.port}/api/commands/execute`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ commandName, context }),
+    });
+    assert.equal(response.status, 200);
+    return await response.json() as Record<string, unknown>;
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+}
+
+test('models command returns models only for the active provider using injected catalog', async () => {
+  const result = await executeCommand('/models', { provider: 'codex' });
+  const data = result.data as Record<string, unknown>;
+  assert.deepEqual(Object.keys(data.available as object), ['codex']);
+});
+
+test('models command falls back to claude for unsupported providers', async () => {
+  const result = await executeCommand('/models', { provider: 'unknown-provider' });
+  const data = result.data as { current: { provider: string } };
+  assert.equal(data.current.provider, 'claude');
+});
+
+test('models command reports the model recorded for the session', async () => {
+  const result = await executeCommand(
+    '/models',
+    { provider: 'claude', sessionId: 'session-1', model: 'sonnet' },
+    { 'session-1': 'haiku' },
+  );
+
+  const data = result.data as { current: { model: string } };
+  assert.equal(data.current.model, 'haiku');
+});
+
+test('models command reports the composer model for a chat with no session yet', async () => {
+  const result = await executeCommand('/models', { provider: 'claude', model: 'haiku' });
+
+  const data = result.data as { current: { model: string } };
+  assert.equal(data.current.model, 'haiku');
+});
+
+test('cost and status commands report the same resolved model as /models', async () => {
+  const context = { provider: 'claude', sessionId: 'session-1', model: 'sonnet' };
+  const sessionModels = { 'session-1': 'haiku' };
+
+  const cost = await executeCommand('/cost', context, sessionModels);
+  const status = await executeCommand('/status', context, sessionModels);
+
+  assert.equal((cost.data as { model: string }).model, 'haiku');
+  assert.equal((status.data as { model: string }).model, 'haiku');
+});

package/server/modules/database/index.ts

@@ -6,6 +6,7 @@ export { credentialsDb } from '@/modules/database/repositories/credentials.js';
 export { githubTokensDb } from '@/modules/database/repositories/github-tokens.js';
 export { notificationChannelEndpointsDb } from '@/modules/database/repositories/notification-channel-endpoints.js';
 export { notificationPreferencesDb } from '@/modules/database/repositories/notification-preferences.js';
+// projectsDb: used by Projects, Worktrees, Git, WebSocket, and notification modules to persist and resolve project records.
 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';

package/server/modules/database/migrations.ts

@@ -402,6 +402,20 @@ const addProviderSessionIdMapping = (db: Database): void => {
   `);
 };
 
+/**
+ * Adds the `model` column that records which model each session runs with.
+ *
+ * Left NULL for pre-existing rows on purpose: the model resolver falls back to
+ * the provider-native lookup for sessions the app has never sent on, so a
+ * backfilled guess would only mask the real value.
+ */
+const addSessionModelColumn = (db: Database): void => {
+  const sessionsTableInfo = getTableInfo(db, 'sessions');
+  const columnNames = sessionsTableInfo.map((column) => column.name);
+
+  addColumnToTableIfNotExists(db, 'sessions', columnNames, 'model', 'TEXT');
+};
+
 const ensureProjectsForSessionPaths = (db: Database): void => {
   if (!tableExists(db, 'sessions')) {
     return;
@@ -452,6 +466,7 @@ export const runMigrations = (db: Database) => {
     rebuildSessionsTableWithProjectSchema(db);
     migrateLegacySessionNames(db);
     addProviderSessionIdMapping(db);
+    addSessionModelColumn(db);
     ensureProjectsForSessionPaths(db);
 
     db.exec('CREATE INDEX IF NOT EXISTS idx_session_ids_lookup ON sessions(session_id)');

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

@@ -9,13 +9,15 @@ type SessionRow = {
   project_path: string | null;
   jsonl_path: string | null;
   custom_name: string | null;
+  /** Model this session runs with; NULL until the app records one for it. */
+  model: string | null;
   isArchived: number;
   created_at: string;
   updated_at: string;
 };
 
 const SESSION_ROW_COLUMNS =
-  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, isArchived, created_at, updated_at';
+  'session_id, provider, provider_session_id, project_path, jsonl_path, custom_name, model, isArchived, created_at, updated_at';
 
 const SQLITE_UTC_TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
 
@@ -211,6 +213,22 @@ export const sessionsDb = {
     merge();
   },
 
+  /**
+   * Records the model one session runs with.
+   *
+   * Called both when the user picks a model for the session and on every send,
+   * so the row always reflects what the session last ran with and reopening it
+   * restores that model instead of a catalog default.
+   */
+  setSessionModel(sessionId: string, model: string): void {
+    const db = getConnection();
+    db.prepare(
+      `UPDATE sessions
+       SET model = ?
+       WHERE session_id = ?`
+    ).run(model, sessionId);
+  },
+
   updateSessionCustomName(sessionId: string, customName: string): void {
     const db = getConnection();
     db.prepare(

package/server/modules/database/schema.ts

@@ -109,6 +109,10 @@ 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 TEXT,
     isArchived BOOLEAN DEFAULT 0,
     created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
     updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,

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

@@ -0,0 +1,112 @@
+import { randomUUID } from 'node:crypto';
+import fs, { promises as fsPromises } from 'node:fs';
+import os from 'node:os';
+
+import mime from 'mime-types';
+import multer from 'multer';
+
+import { projectsDb } from '@/modules/database/index.js';
+import { createFileTreeRouter } from '@/modules/file-tree/file-tree.routes.js';
+import { createFileTreeService } from '@/modules/file-tree/file-tree.service.js';
+import type {
+  FileTreeFileSystem,
+  FileTreeLogger,
+  FileTreeProjectGateway,
+  FileTreeWorkspaceGateway,
+} from '@/shared/types.js';
+import { WORKSPACES_ROOT, validateWorkspacePath } from '@/shared/utils.js';
+
+const MAXIMUM_UPLOAD_SIZE_MEGABYTES = 200;
+const MAXIMUM_UPLOAD_SIZE_BYTES = MAXIMUM_UPLOAD_SIZE_MEGABYTES * 1024 * 1024;
+const MAXIMUM_UPLOAD_FILE_COUNT = 20;
+
+function readFileSystemConcurrency(): number {
+  const configuredConcurrency = Number.parseInt(process.env.FS_CONCURRENCY ?? '', 10);
+  return Number.isFinite(configuredConcurrency) && configuredConcurrency > 0
+    ? configuredConcurrency
+    : 64;
+}
+
+/**
+ * Production filesystem adapter owned by the File Tree composition root.
+ * Application services receive this complete capability explicitly and never
+ * import Node's mutable filesystem APIs themselves.
+ */
+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 }),
+  realpath: (candidatePath) => fsPromises.realpath(candidatePath),
+  readTextFile: (filePath) => fsPromises.readFile(filePath, 'utf8'),
+  writeTextFile: (filePath, content) => fsPromises.writeFile(filePath, content, 'utf8'),
+  async makeDirectory(directoryPath, recursive) {
+    await fsPromises.mkdir(directoryPath, { recursive });
+  },
+  rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+  async removeDirectory(directoryPath) {
+    await fsPromises.rm(directoryPath, { recursive: true, force: true });
+  },
+  unlink: (filePath) => fsPromises.unlink(filePath),
+  copyFile: (sourcePath, destinationPath) => fsPromises.copyFile(sourcePath, destinationPath),
+  createReadStream: (filePath) => fs.createReadStream(filePath),
+};
+
+/**
+ * Database boundary used only by File Tree production composition.
+ * The Database module is consumed through its barrel; services and routes see
+ * only the narrow project-path lookup contract.
+ */
+const fileTreeProjects: FileTreeProjectGateway = {
+  getProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
+};
+
+/**
+ * Workspace-policy boundary used only by File Tree production composition.
+ * Keeping both the configured root and symlink-aware validator together makes
+ * the path policy explicit for every service instance.
+ */
+const fileTreeWorkspace: FileTreeWorkspaceGateway = {
+  rootPath: WORKSPACES_ROOT,
+  validatePath: (candidatePath) => validateWorkspacePath(candidatePath),
+};
+
+const fileTreeLogger: FileTreeLogger = {
+  error: (message, error) => console.error(message, error),
+};
+
+const fileTreeServices = createFileTreeService({
+  fileSystem: fileTreeFileSystem,
+  projects: fileTreeProjects,
+  workspace: fileTreeWorkspace,
+  resolveMimeType: (filePath) => mime.lookup(filePath) || 'application/octet-stream',
+  fileSystemConcurrency: readFileSystemConcurrency(),
+  logger: fileTreeLogger,
+});
+
+const fileUploadMiddleware = multer({
+  storage: multer.diskStorage({
+    destination: os.tmpdir(),
+    filename: (_request, _file, callback) => {
+      callback(null, `cloudcli-file-upload-${randomUUID()}`);
+    },
+  }),
+  limits: {
+    fileSize: MAXIMUM_UPLOAD_SIZE_BYTES,
+    files: MAXIMUM_UPLOAD_FILE_COUNT,
+  },
+}).array('files', MAXIMUM_UPLOAD_FILE_COUNT);
+
+/**
+ * File Tree router used by the server entrypoint to mount the authenticated
+ * browsing, editing, file-management, and upload API under `/api/file-tree`.
+ */
+export const fileTreeRoutes = createFileTreeRouter(
+  fileTreeServices,
+  fileUploadMiddleware,
+  {
+    maximumFileSizeMegabytes: MAXIMUM_UPLOAD_SIZE_MEGABYTES,
+    maximumFileCount: MAXIMUM_UPLOAD_FILE_COUNT,
+  },
+  fileTreeLogger,
+);