wind-agent-cli 1.37.2 → 1.37.3

package/server/modules/commands/index.ts

@@ -1,2 +1,2 @@
-// commandsRoutes: used by the server entrypoint to mount protected slash-command endpoints.
-export { commandsRoutes } from './commands.module.js';
+// 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

@@ -1,75 +1,75 @@
-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,
-  };
-}
-
+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()));
-  }
+  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 }>> {
@@ -104,45 +104,45 @@ async function listCommands(provider: string): Promise<Array<{ name: string }>>
     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('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');
+  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/connection.ts

@@ -1,143 +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');
-  }
-}
+/**
+ * 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

@@ -1,17 +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';
+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

@@ -1,17 +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;
-    }
-};
+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;
+    }
+};