wind-agent-cli 1.37.2

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

@@ -0,0 +1,171 @@
+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 () => ({
+      OPTIONS: [{ value: 'default', label: 'Default' }],
+      DEFAULT: 'default',
+    }),
+    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,
+  };
+}
+
+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()));
+  }
+}
+
+async function listCommands(provider: string): Promise<Array<{ name: string }>> {
+  const missingDirectory = Object.assign(new Error('missing'), { code: 'ENOENT' });
+  const router = createCommandsRouter({
+    fileSystem: {
+      access: async () => { throw missingDirectory; },
+    } as unknown as typeof import('node:fs/promises'),
+    homeDirectory: () => '/home/test',
+    appRoot: '/app',
+    models: createModelsService() as never,
+    runtime: {
+      uptime: () => 0,
+      memoryUsage: () => ({ rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 }),
+      version: 'v24', 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/list`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ provider }),
+    });
+    assert.equal(response.status, 200);
+    const result = await response.json() as { builtIn: Array<{ name: string }> };
+    return result.builtIn;
+  } 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');
+});
+
+test('command list exposes native app-server commands only for Codex', async () => {
+  const codexNames = (await listCommands('codex')).map((command) => command.name);
+  const claudeNames = (await listCommands('claude')).map((command) => command.name);
+
+  assert.equal(codexNames.includes('/plan'), true);
+  assert.equal(codexNames.includes('/review'), true);
+  assert.equal(codexNames.includes('/compact'), true);
+  assert.equal(codexNames.includes('/model'), true);
+  assert.equal(codexNames.includes('/mcp'), true);
+  assert.equal(claudeNames.includes('/plan'), false);
+  assert.equal(claudeNames.includes('/review'), false);
+  assert.equal(claudeNames.includes('/compact'), false);
+});
+
+test('Codex help includes provider-native commands and model aliases use the model picker', async () => {
+  const help = await executeCommand('/help', { provider: 'codex' });
+  const model = await executeCommand('/model', { provider: 'codex' });
+  const helpData = help.data as { content: string };
+
+  assert.match(helpData.content, /Codex and CloudCLI Commands/);
+  assert.match(helpData.content, /\/plan/);
+  assert.equal(model.action, 'models');
+});

package/server/modules/database/connection.ts

@@ -0,0 +1,143 @@
+/**
+ * Database connection management.
+ *
+ * Owns the single SQLite connection used across all repositories.
+ * Handles path resolution, directory creation, legacy database migration,
+ * and eager app_config bootstrap so the auth middleware can read the
+ * JWT secret before the full schema is applied.
+ *
+ * Consumers should never create their own Database instance — they use
+ * `getConnection()` to obtain the shared singleton.
+ */
+
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { APP_CONFIG_TABLE_SCHEMA_SQL } from '@/modules/database/schema.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ---------------------------------------------------------------------------
+// Path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolves the database file path from environment or falls back
+ * to the legacy location inside the server/database/ folder.
+ *
+ * Priority:
+ *   1. DATABASE_PATH environment variable (set by cli.js or load-env-vars.js)
+ *   2. Legacy path: server/database/auth.db
+ */
+function resolveDatabasePath(): string {
+    // process.env.DATABASE_PATH is set by load-env-vars.js to either the .env value or a default(~/.cloudcli/auth.db) in the user's home directory. 
+    return process.env.DATABASE_PATH || resolveLegacyDatabasePath();
+}
+
+/**
+ * Resolves the legacy database path (always inside server/database/).
+ * Used for the one-time migration to the new external location.
+ */
+function resolveLegacyDatabasePath(): string {
+  const serverDir = path.resolve(__dirname, '..', '..', '..');
+  return path.join(serverDir, 'database', 'auth.db');
+}
+
+// ---------------------------------------------------------------------------
+// Directory & migration helpers
+// ---------------------------------------------------------------------------
+
+function ensureDatabaseDirectory(dbPath: string): void {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    console.log('Created database directory:', dir);
+  }
+}
+
+/**
+ * If the database was moved to an external location (e.g. ~/.cloudcli/)
+ * but the user still has a legacy auth.db inside the install directory,
+ * copy it to the new location as a one-time migration.
+ */
+function migrateLegacyDatabase(targetPath: string): void {
+  const legacyPath = resolveLegacyDatabasePath();
+
+  if (targetPath === legacyPath) return;
+  if (fs.existsSync(targetPath)) return;
+  if (!fs.existsSync(legacyPath)) return;
+
+  try {
+    fs.copyFileSync(legacyPath, targetPath);
+    console.log('Migrated legacy database', { from: legacyPath, to: targetPath });
+
+
+    // copy the write-ahead log and shared memory files (auth.db-wal, auth.db-shm) if they exist, to preserve any uncommitted transactions
+    for (const suffix of ['-wal', '-shm']) {
+      const src = legacyPath + suffix;
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, targetPath + suffix);
+      }
+    }
+  } catch (err: any) {
+    console.error('Could not migrate legacy database', { error: err.message });
+  }
+}
+
+
+// ---------------------------------------------------------------------------
+// Singleton connection
+// ---------------------------------------------------------------------------
+
+let instance: Database.Database | null = null;
+
+/**
+ * Returns the shared database connection, creating it on first call.
+ *
+ * The first invocation:
+ *   1. Resolves the target database path
+ *   2. Ensures the parent directory exists
+ *   3. Migrates from the legacy install-directory path if needed
+ *   4. Opens the SQLite connection
+ *   5. Eagerly creates the app_config table (auth reads JWT secret at import time)
+ *   6. Logs the database location
+ */
+export function getConnection(): Database.Database {
+  if (instance) return instance;
+
+  const dbPath = resolveDatabasePath();
+
+  ensureDatabaseDirectory(dbPath);
+  migrateLegacyDatabase(dbPath);
+
+  instance = new Database(dbPath);
+
+  // app_config must exist immediately — the auth middleware reads
+  // the JWT secret at module-load time, before initializeDatabase() runs.
+  instance.exec(APP_CONFIG_TABLE_SCHEMA_SQL);
+
+  return instance;
+}
+
+/**
+ * Returns the resolved database file path without opening a connection.
+ * Useful for diagnostics and CLI status commands.
+ */
+export function getDatabasePath(): string {
+  return resolveDatabasePath();
+}
+
+/**
+ * Closes the database connection and clears the singleton.
+ * Primarily used for graceful shutdown or testing.
+ */
+export function closeConnection(): void {
+  if (instance) {
+    instance.close();
+    instance = null;
+    console.log('Database connection closed');
+  }
+}

package/server/modules/database/index.ts

@@ -0,0 +1,17 @@
+export { initializeDatabase } from '@/modules/database/init-db.js';
+export { closeConnection, getConnection, getDatabasePath } from '@/modules/database/connection.js';
+export { apiKeysDb } from '@/modules/database/repositories/api-keys.js';
+export { appConfigDb } from '@/modules/database/repositories/app-config.js';
+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';
+// providerModelsDb: used by Providers to persist user-managed custom model rows.
+export { providerModelsDb } from '@/modules/database/repositories/provider-models.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';
+export { sessionsDb } from '@/modules/database/repositories/sessions.db.js';
+export { userDb } from '@/modules/database/repositories/users.js';
+export { vapidKeysDb } from '@/modules/database/repositories/vapid-keys.js';

package/server/modules/database/init-db.ts

@@ -0,0 +1,17 @@
+import { getConnection } from "@/modules/database/connection.js";
+import { runMigrations } from "@/modules/database/migrations.js";
+import { INIT_SCHEMA_SQL } from "@/modules/database/schema.js";
+
+// Initialize database with schema
+export const initializeDatabase = async () => {
+    try {
+        const db = getConnection();
+        db.exec(INIT_SCHEMA_SQL);
+        console.log('Database schema applied');
+        runMigrations(db);
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log('Database initialization failed', { error: message });
+        throw err;
+    }
+};