@cloudcli-ai/cloudcli 1.36.2 → 1.37.0

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

@@ -0,0 +1,142 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { createProviderRuntimeService } from '@/modules/providers/services/provider-runtime.service.js';
+import type { IProvider, IProviderRuntime } from '@/shared/interfaces.js';
+import type { LLMProvider } from '@/shared/types.js';
+
+function createRuntime(overrides: Partial<IProviderRuntime> = {}): IProviderRuntime {
+  return {
+    async run() {
+      return undefined;
+    },
+    abort() {
+      return false;
+    },
+    ...overrides,
+  };
+}
+
+function createProvider(id: LLMProvider, runtime: IProviderRuntime): IProvider {
+  return {
+    id,
+    runtime,
+    auth: {
+      async getStatus() {
+        return {
+          provider: id,
+          installed: true,
+          authenticated: true,
+          method: 'test',
+          details: {},
+        };
+      },
+    },
+    sessions: {
+      normalizeMessage(raw: unknown, sessionId: string | null) {
+        return [{ kind: 'assistant', content: String(raw), sessionId, provider: id }];
+      },
+      async fetchHistory() {
+        return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+      },
+    },
+  } as unknown as IProvider;
+}
+
+function createService(providers: IProvider[]) {
+  const providerMap = new Map(providers.map((provider) => [provider.id, provider]));
+  return createProviderRuntimeService({
+    listProviders: () => providers,
+    resolveProvider(providerName) {
+      const provider = providerMap.get(providerName as LLMProvider);
+      if (!provider) {
+        throw new Error(`Missing provider: ${providerName}`);
+      }
+      return provider;
+    },
+    resolveProviderSessionId: (sessionId) => sessionId ? `native-${sessionId}` : null,
+    async resolveResumeModel(_provider, _sessionId, requestedModel) {
+      return requestedModel?.trim() || undefined;
+    },
+    async getProviderModels() {
+      return {
+        models: { OPTIONS: [], DEFAULT: 'default-model' },
+        cache: {
+          updatedAt: new Date(0).toISOString(),
+          expiresAt: new Date(0).toISOString(),
+          source: 'fresh',
+        },
+      };
+    },
+  });
+}
+
+test('providerRegistry owns one runtime for every registered provider', () => {
+  const providers = providerRegistry.listProviders();
+
+  assert.deepEqual(providers.map((provider) => provider.id), [
+    'claude',
+    'codex',
+    'cursor',
+    'opencode',
+  ]);
+  assert.equal(providers.every((provider) => typeof provider.runtime.run === 'function'), true);
+  assert.equal(providers.every((provider) => typeof provider.runtime.abort === 'function'), true);
+});
+
+test('dispatches runs and aborts through the runtime owned by providerRegistry', async () => {
+  const calls: unknown[][] = [];
+  const runtime = createRuntime({
+    async run(command, options, writer, context) {
+      calls.push(['run', command, options, writer]);
+      assert.equal(context.resolveProviderSessionId('session-1'), 'native-session-1');
+      assert.equal(await context.resolveResumeModel('session-1', 'sonnet'), 'sonnet');
+      assert.deepEqual(await context.getProviderModels(), { OPTIONS: [], DEFAULT: 'default-model' });
+      assert.equal(context.normalizeMessage('hello', 'session-1')[0]?.provider, 'claude');
+      assert.equal(await context.isProviderInstalled(), true);
+      return 'complete';
+    },
+    async abort(sessionId) {
+      calls.push(['abort', sessionId]);
+      return true;
+    },
+  });
+  const service = createService([createProvider('claude', runtime)]);
+  const writer = { send() {} };
+
+  assert.equal(service.hasRuntime('claude'), true);
+  assert.equal(service.hasRuntime('unknown'), false);
+  assert.equal(await service.getRunner('claude')('hello', { model: 'sonnet' }, writer), 'complete');
+  assert.equal(await service.abort('claude', 'session-1'), true);
+  assert.deepEqual(calls, [
+    ['run', 'hello', { model: 'sonnet' }, writer],
+    ['abort', 'session-1'],
+  ]);
+});
+
+test('routes permission decisions through provider-owned runtime capabilities', () => {
+  const decisions: unknown[][] = [];
+  const claudeRuntime = createRuntime({
+    permissions: {
+      resolve(requestId, decision) {
+        decisions.push([requestId, decision]);
+      },
+      listPending(sessionId) {
+        return [{ requestId: 'request-1', sessionId }];
+      },
+    },
+  });
+  const service = createService([
+    createProvider('claude', claudeRuntime),
+    createProvider('cursor', createRuntime()),
+  ]);
+  const decision = { allow: true, message: 'approved' };
+
+  service.resolveToolApproval('request-1', decision);
+
+  assert.deepEqual(decisions, [['request-1', decision]]);
+  assert.deepEqual(service.getPendingApprovalsForSession('session-1'), [
+    { requestId: 'request-1', sessionId: 'session-1' },
+  ]);
+});

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

@@ -0,0 +1,185 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import Database from 'better-sqlite3';
+
+import { createProviderTokenUsageService } from '@/modules/providers/services/provider-token-usage.service.js';
+import { AppError } from '@/shared/utils.js';
+
+function createSessionRow(overrides: Record<string, unknown> = {}) {
+  return {
+    session_id: 'app-session',
+    provider: 'claude',
+    provider_session_id: 'provider-session',
+    project_path: null,
+    jsonl_path: null,
+    custom_name: null,
+    model: null,
+    isArchived: 0,
+    created_at: '2026-01-01T00:00:00.000Z',
+    updated_at: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+test('token usage lookup requires only the app-facing session id for Claude', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-claude-'));
+  const sessionFilePath = path.join(tempDirectory, 'provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          usage: {
+            input_tokens: 100,
+            cache_read_input_tokens: 20,
+            cache_creation_input_tokens: 5,
+            output_tokens: 30,
+          },
+        },
+      }),
+      '{incomplete',
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ jsonl_path: sessionFilePath }),
+      getClaudeContextWindow: () => '180000',
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 155,
+      total: 180_000,
+      inputTokens: 125,
+      outputTokens: 30,
+      cacheReadTokens: 20,
+      cacheCreationTokens: 5,
+      cacheTokens: 25,
+      breakdown: { input: 125, output: 30 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Codex token usage uses the latest token_count snapshot', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-codex-'));
+  const sessionFilePath = path.join(tempDirectory, 'rollout-provider-session.jsonl');
+
+  try {
+    await writeFile(sessionFilePath, [
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: {
+            total_token_usage: { input_tokens: 10, output_tokens: 4, total_tokens: 14 },
+            model_context_window: 100_000,
+          },
+        },
+      }),
+      JSON.stringify({
+        type: 'event_msg',
+        payload: {
+          type: 'token_count',
+          info: {
+            total_token_usage: { input_tokens: 40, output_tokens: 9, total_tokens: 49 },
+            model_context_window: 250_000,
+          },
+        },
+      }),
+    ].join('\n'));
+
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({
+        provider: 'codex',
+        jsonl_path: sessionFilePath,
+      }),
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 49,
+      total: 250_000,
+      inputTokens: 40,
+      outputTokens: 9,
+      breakdown: { input: 40, output: 9 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('OpenCode token usage resolves its provider-native id from the session row', async () => {
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'provider-token-usage-opencode-'));
+  const databasePath = path.join(tempDirectory, 'opencode.db');
+  const database = new Database(databasePath);
+
+  try {
+    database.exec(`
+      CREATE TABLE session (
+        id TEXT PRIMARY KEY,
+        tokens_input INTEGER,
+        tokens_output INTEGER,
+        tokens_reasoning INTEGER,
+        tokens_cache_read INTEGER,
+        tokens_cache_write INTEGER
+      )
+    `);
+    database.prepare(`
+      INSERT INTO session (
+        id,
+        tokens_input,
+        tokens_output,
+        tokens_reasoning,
+        tokens_cache_read,
+        tokens_cache_write
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run('provider-session', 12, 7, 3, 5, 2);
+  } finally {
+    database.close();
+  }
+
+  try {
+    const service = createProviderTokenUsageService({
+      getSessionById: () => createSessionRow({ provider: 'opencode' }),
+      getOpenCodeDatabasePath: () => databasePath,
+    });
+
+    assert.deepEqual(await service.getSessionTokenUsage('app-session'), {
+      used: 29,
+      inputTokens: 17,
+      outputTokens: 7,
+      breakdown: { input: 17, output: 7 },
+    });
+  } finally {
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+});
+
+test('Cursor returns an explicit unsupported token usage result', async () => {
+  const service = createProviderTokenUsageService({
+    getSessionById: () => createSessionRow({ provider: 'cursor' }),
+  });
+
+  const result = await service.getSessionTokenUsage('app-session');
+
+  assert.equal(result.unsupported, true);
+  assert.equal(result.used, 0);
+  assert.equal(result.total, 0);
+});
+
+test('token usage reports SESSION_NOT_FOUND for an unknown app session id', async () => {
+  const service = createProviderTokenUsageService({ getSessionById: () => null });
+
+  await assert.rejects(
+    () => service.getSessionTokenUsage('missing-session'),
+    (error: unknown) => (
+      error instanceof AppError
+      && error.code === 'SESSION_NOT_FOUND'
+      && error.statusCode === 404
+    ),
+  );
+});

package/server/modules/providers/tests/sessions-details.test.ts

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } 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';
+import { AppError, normalizeProjectPath } from '@/shared/utils.js';
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'sessions-details-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  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('getSessionDetailsById resolves the owning project for a disk-indexed session', async () => {
+  await withIsolatedDatabase(() => {
+    const projectPath = '/home/user/example-project';
+    const sessionId = sessionsDb.createSession('provider-abc', 'claude', projectPath, 'My session');
+    const projectRow = projectsDb.getProjectPath(projectPath);
+    assert.ok(projectRow, 'project row should exist after createSession');
+
+    const details = sessionsService.getSessionDetailsById(sessionId);
+
+    assert.equal(details.sessionId, sessionId);
+    assert.equal(details.provider, 'claude');
+    assert.equal(details.summary, 'My session');
+    assert.equal(details.isArchived, false);
+    assert.ok(details.project, 'project should be resolved');
+    assert.equal(details.project?.projectId, projectRow?.project_id);
+    // Paths are normalized to platform separators when stored.
+    assert.equal(details.project?.fullPath, normalizeProjectPath(projectPath));
+  });
+});
+
+test('getSessionDetailsById falls back to the provider-native id and returns the canonical app id', async () => {
+  await withIsolatedDatabase(() => {
+    const projectPath = '/home/user/alias-project';
+    const appSessionId = sessionsDb.createAppSession('app-session-1', 'claude', projectPath);
+    sessionsDb.assignProviderSessionId(appSessionId, 'provider-native-1');
+
+    const details = sessionsService.getSessionDetailsById('provider-native-1');
+
+    assert.equal(details.sessionId, appSessionId);
+    assert.equal(details.project?.fullPath, normalizeProjectPath(projectPath));
+  });
+});
+
+test('getSessionDetailsById throws SESSION_NOT_FOUND for unknown ids', async () => {
+  await withIsolatedDatabase(() => {
+    assert.throws(
+      () => sessionsService.getSessionDetailsById('does-not-exist'),
+      (error: unknown) => error instanceof AppError && error.code === 'SESSION_NOT_FOUND',
+    );
+  });
+});

package/server/modules/providers/tests/skills.test.ts

@@ -319,8 +319,8 @@ test('providerSkillsService lists claude user, project, and enabled plugin skill
 });
 
 /**
- * This test covers Codex repository/user/system skill folders and verifies that
- * repository lookup includes cwd, parent, and git root skill locations.
+ * This test covers Codex repository/user/system skill folders, including both
+ * supported user roots, and verifies repository lookup across cwd, parent, and git root.
  */
 test('providerSkillsService lists codex repository, user, and system skills', { concurrency: false }, async () => {
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'llm-skills-codex-'));
@@ -355,6 +355,12 @@ test('providerSkillsService lists codex repository, user, and system skills', {
       'codex-user',
       'Codex user skill',
     );
+    await writeSkill(
+      path.join(tempRoot, '.codex', 'skills'),
+      'codex-home-user-dir',
+      'codex-home-user',
+      'Codex home user skill',
+    );
     await writeSkill(
       path.join(tempRoot, '.codex', 'skills', '.system'),
       'codex-system-dir',
@@ -369,6 +375,7 @@ test('providerSkillsService lists codex repository, user, and system skills', {
     assert.equal(byName.get('codex-parent')?.scope, 'repo');
     assert.equal(byName.get('codex-root')?.scope, 'repo');
     assert.equal(byName.get('codex-user')?.scope, 'user');
+    assert.equal(byName.get('codex-home-user')?.scope, 'user');
     assert.equal(byName.get('codex-system')?.scope, 'system');
     assert.equal(byName.get('codex-root')?.command, '$codex-root');
   } finally {

package/server/modules/settings/index.ts

@@ -0,0 +1,2 @@
+// settingsRoutes: used by the server entrypoint to mount protected application-settings endpoints.
+export { settingsRoutes } from './settings.module.js';

package/server/modules/settings/settings.module.ts

@@ -0,0 +1,50 @@
+import {
+  apiKeysDb,
+  credentialsDb,
+  notificationPreferencesDb,
+  pushSubscriptionsDb,
+} from '@/modules/database/index.js';
+import {
+  createNotificationEvent,
+  getPublicKey,
+  notifyUserIfEnabled,
+} from '@/modules/notifications/index.js';
+
+import { createSettingsRouter } from './settings.routes.js';
+import { createSettingsService } from './settings.service.js';
+
+const settingsService = createSettingsService({
+  apiKeys: {
+    list: (userId) => apiKeysDb.getApiKeys(userId),
+    create: (userId, keyName) => apiKeysDb.createApiKey(userId, keyName),
+    remove: (userId, keyId) => apiKeysDb.deleteApiKey(userId, keyId),
+    toggle: (userId, keyId, isActive) => apiKeysDb.toggleApiKey(userId, keyId, isActive),
+  },
+  credentials: {
+    list: (userId, type) => credentialsDb.getCredentials(userId, type),
+    create: (userId, name, type, value, description) =>
+      credentialsDb.createCredential(userId, name, type, value, description),
+    remove: (userId, credentialId) => credentialsDb.deleteCredential(userId, credentialId),
+    toggle: (userId, credentialId, isActive) =>
+      credentialsDb.toggleCredential(userId, credentialId, isActive),
+  },
+  notifications: {
+    getPreferences: (userId) => notificationPreferencesDb.getPreferences(userId),
+    updatePreferences: (userId, preferences) =>
+      notificationPreferencesDb.updatePreferences(userId, preferences),
+    createEnabledEvent: () => createNotificationEvent({
+      provider: 'system', kind: 'info', code: 'push.enabled',
+      meta: { message: 'Push notifications are now enabled!' }, severity: 'info',
+    }),
+    notifyUser: (userId, event) => notifyUserIfEnabled({ userId, event }),
+  },
+  pushSubscriptions: {
+    save: (userId, endpoint, p256dh, auth) =>
+      pushSubscriptionsDb.saveSubscription(userId, endpoint, p256dh, auth),
+    remove: (endpoint) => pushSubscriptionsDb.removeSubscription(endpoint),
+  },
+  getVapidPublicKey: getPublicKey,
+});
+
+/** Settings router assembled for the authenticated server mount. */
+export const settingsRoutes = createSettingsRouter(settingsService);

package/server/modules/settings/settings.routes.ts

@@ -0,0 +1,51 @@
+import express from 'express';
+
+import type { createSettingsService } from './settings.service.js';
+
+type AuthenticatedRequest = express.Request & { user?: { id?: number | string } };
+
+function userId(req: express.Request): number {
+  return Number((req as AuthenticatedRequest).user?.id);
+}
+
+function queryString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+/** Creates thin Settings transport handlers around the application service. */
+export function createSettingsRouter(
+  service: ReturnType<typeof createSettingsService>,
+): express.Router {
+  const router = express.Router();
+  const respond = (operation: (req: express.Request) => unknown | Promise<unknown>) =>
+    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+      try { res.json(await operation(req)); } catch (error) { next(error); }
+    };
+
+  router.get('/api-keys', respond((req) => service.listApiKeys(userId(req))));
+  router.post('/api-keys', respond((req) => service.createApiKey(userId(req), req.body?.keyName)));
+  router.delete('/api-keys/:keyId', respond((req) => service.deleteApiKey(userId(req), Number(req.params.keyId))));
+  router.patch('/api-keys/:keyId/toggle', respond((req) => service.toggleApiKey(
+    userId(req), Number(req.params.keyId), req.body?.isActive,
+  )));
+  router.get('/credentials', respond((req) => service.listCredentials(
+    userId(req), queryString(req.query.type),
+  )));
+  router.post('/credentials', respond((req) => service.createCredential(userId(req), req.body ?? {})));
+  router.delete('/credentials/:credentialId', respond((req) => service.deleteCredential(
+    userId(req), Number(req.params.credentialId),
+  )));
+  router.patch('/credentials/:credentialId/toggle', respond((req) => service.toggleCredential(
+    userId(req), Number(req.params.credentialId), req.body?.isActive,
+  )));
+  router.get('/notification-preferences', respond((req) => service.getNotificationPreferences(userId(req))));
+  router.put('/notification-preferences', respond((req) => service.updateNotificationPreferences(
+    userId(req), req.body ?? {},
+  )));
+  router.get('/push/vapid-public-key', respond(() => service.getVapidPublicKey()));
+  router.post('/push/subscribe', respond((req) => service.subscribeToPush(userId(req), req.body ?? {})));
+  router.post('/push/unsubscribe', respond((req) => service.unsubscribeFromPush(
+    userId(req), req.body?.endpoint,
+  )));
+  return router;
+}