wind-agent-cli 1.37.2

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

@@ -0,0 +1,138 @@
+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 {
+        OPTIONS: [],
+        DEFAULT: 'default-model',
+      };
+    },
+  });
+}
+
+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,186 @@
+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,
+    effort: 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/provider.routes.test.ts

@@ -0,0 +1,244 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import type { AddressInfo } from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import express, { type NextFunction, type Request, type Response } from 'express';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import providerRouter from '@/modules/providers/provider.routes.js';
+import { AppError } from '@/shared/utils.js';
+
+async function withProviderServer(
+  run: (baseUrl: string, workspacePath: string) => Promise<void>,
+): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'provider-routes-'));
+
+  closeConnection();
+  process.env.DATABASE_PATH = path.join(tempDirectory, 'auth.db');
+  await writeFile(process.env.DATABASE_PATH, '');
+  await initializeDatabase();
+
+  const app = express().use(express.json()).use('/api/providers', providerRouter);
+  app.use((error: unknown, _req: Request, res: Response, _next: NextFunction) => {
+    if (error instanceof AppError) {
+      res.status(error.statusCode).json({
+        success: false,
+        error: { code: error.code, message: error.message },
+      });
+      return;
+    }
+    res.status(500).json({ success: false, error: { code: 'INTERNAL_ERROR' } });
+  });
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    await run(`http://127.0.0.1:${address.port}`, path.join(tempDirectory, 'workspace'));
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('session creation route names a CloudCLI session from the initial message', async () => {
+  await withProviderServer(async (baseUrl, workspacePath) => {
+    const response = await fetch(`${baseUrl}/api/providers/sessions`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        provider: 'codex',
+        projectPath: workspacePath,
+        initialMessage: 'abcd  efg\nhij klm nop',
+      }),
+    });
+    const payload = await response.json() as {
+      data: { sessionId: string; sessionName: string };
+    };
+
+    assert.equal(response.status, 201);
+    assert.equal(payload.data.sessionName, 'abcd efg hij klm');
+    assert.equal(
+      sessionsDb.getSessionById(payload.data.sessionId)?.custom_name,
+      'abcd efg hij klm',
+    );
+  });
+});
+
+test('conversation search streams title matches before transcript results', async () => {
+  await withProviderServer(async (baseUrl, workspacePath) => {
+    sessionsDb.createAppSession(
+      'title-only-session',
+      'codex',
+      workspacePath,
+      'Release planning notes',
+    );
+    const transcriptPath = path.join(path.dirname(workspacePath), 'codex-search.jsonl');
+    await writeFile(transcriptPath, `${JSON.stringify({
+      type: 'event_msg',
+      timestamp: '2026-08-12T09:00:00.000Z',
+      payload: {
+        type: 'user_message',
+        kind: 'plain',
+        message: 'Release planning also appears in this conversation.',
+      },
+    })}\n`);
+    sessionsDb.createSession(
+      'transcript-session',
+      'codex',
+      workspacePath,
+      'Unrelated session',
+      undefined,
+      undefined,
+      transcriptPath,
+    );
+
+    const response = await fetch(
+      `${baseUrl}/api/providers/search/sessions?q=release%20planning&limit=50`,
+    );
+    const eventStream = await response.text();
+    const titleEventIndex = eventStream.indexOf('event: title-results');
+    const conversationEventIndex = eventStream.indexOf('event: result');
+    const doneEventIndex = eventStream.indexOf('event: done');
+
+    assert.equal(response.status, 200);
+    assert.ok(titleEventIndex >= 0);
+    assert.ok(conversationEventIndex > titleEventIndex);
+    assert.ok(doneEventIndex > titleEventIndex);
+
+    const titleDataLine = eventStream
+      .slice(titleEventIndex, conversationEventIndex)
+      .split('\n')
+      .find((line) => line.startsWith('data: '));
+    assert.ok(titleDataLine);
+
+    const titlePayload = JSON.parse(titleDataLine.slice('data: '.length)) as {
+      titleResults: Array<{
+        sessionId: string;
+        sessionTitle: string;
+        provider: string;
+      }>;
+    };
+    assert.equal(titlePayload.titleResults.length, 1);
+    assert.equal(titlePayload.titleResults[0]?.sessionId, 'title-only-session');
+    assert.equal(titlePayload.titleResults[0]?.sessionTitle, 'Release planning notes');
+    assert.equal(titlePayload.titleResults[0]?.provider, 'codex');
+  });
+});
+
+test('reasoning effort is persisted and returned with the active session model', async () => {
+  await withProviderServer(async (baseUrl, workspacePath) => {
+    sessionsDb.createAppSession('effort-session', 'codex', workspacePath);
+
+    const updateResponse = await fetch(
+      `${baseUrl}/api/providers/codex/sessions/effort-session/active-effort`,
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ effort: 'ultra' }),
+      },
+    );
+    const updatePayload = await updateResponse.json() as {
+      data: { effort: string; sessionId: string };
+    };
+
+    assert.equal(updateResponse.status, 200);
+    assert.equal(updatePayload.data.effort, 'ultra');
+    assert.equal(sessionsDb.getSessionById('effort-session')?.effort, 'ultra');
+
+    const readResponse = await fetch(
+      `${baseUrl}/api/providers/codex/sessions/effort-session/active-model`,
+    );
+    const readPayload = await readResponse.json() as {
+      data: { effort: string | null; sessionId: string };
+    };
+
+    assert.equal(readResponse.status, 200);
+    assert.equal(readPayload.data.sessionId, 'effort-session');
+    assert.equal(readPayload.data.effort, 'ultra');
+  });
+});
+
+test('model routes expose immutable defaults and full custom model CRUD', async () => {
+  await withProviderServer(async (baseUrl) => {
+    const initialResponse = await fetch(`${baseUrl}/api/providers/codex/models`);
+    const initialPayload = await initialResponse.json() as {
+      data: {
+        cache?: unknown;
+        models: {
+          OPTIONS: Array<{ recordId?: number; value: string; isCustom: boolean }>;
+        };
+      };
+    };
+    assert.equal(initialResponse.status, 200);
+    assert.equal('cache' in initialPayload.data, false);
+    const predefined = initialPayload.data.models.OPTIONS[0];
+    assert.equal(predefined.isCustom, false);
+    assert.equal(predefined.recordId, undefined);
+
+    const createResponse = await fetch(`${baseUrl}/api/providers/codex/models`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model: 'Gateway GPT', id: 'gateway/gpt' }),
+    });
+    const createPayload = await createResponse.json() as {
+      data: { model: { recordId: number; value: string; label: string; isCustom: boolean } };
+    };
+    assert.equal(createResponse.status, 201);
+    assert.equal(createPayload.data.model.isCustom, true);
+    const customRecordId = createPayload.data.model.recordId;
+
+    const updateResponse = await fetch(
+      `${baseUrl}/api/providers/codex/models/${customRecordId}`,
+      {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model: 'Gateway GPT Updated', id: 'gateway/gpt-v2' }),
+      },
+    );
+    const updatePayload = await updateResponse.json() as {
+      data: { model: { value: string; label: string } };
+    };
+    assert.equal(updateResponse.status, 200);
+    assert.equal(updatePayload.data.model.value, 'gateway/gpt-v2');
+    assert.equal(updatePayload.data.model.label, 'Gateway GPT Updated');
+
+    const immutableResponse = await fetch(
+      `${baseUrl}/api/providers/codex/models/999999`,
+      {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ model: 'Changed', id: 'changed' }),
+      },
+    );
+    const immutablePayload = await immutableResponse.json() as { error: { code: string } };
+    assert.equal(immutableResponse.status, 404);
+    assert.equal(immutablePayload.error.code, 'MODEL_NOT_FOUND');
+
+    const deleteResponse = await fetch(
+      `${baseUrl}/api/providers/codex/models/${customRecordId}`,
+      { method: 'DELETE' },
+    );
+    const deletePayload = await deleteResponse.json() as {
+      data: { models: { OPTIONS: Array<{ recordId: number }> } };
+    };
+    assert.equal(deleteResponse.status, 200);
+    assert.equal(
+      deletePayload.data.models.OPTIONS.some((option) => option.recordId === customRecordId),
+      false,
+    );
+  });
+});

package/server/modules/providers/tests/session-watch-scheduler.test.ts

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { SessionWatchScheduler } from '@/modules/providers/services/session-watch-scheduler.js';
+
+const event = {
+  eventType: 'change',
+  provider: 'codex',
+  filePath: 'C:/sessions/example.jsonl',
+} satisfies Parameters<SessionWatchScheduler['enqueue']>[0];
+
+const wait = (milliseconds: number) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+test('coalesces filesystem noise and serializes synchronization by artifact', async () => {
+  let active = 0;
+  let maxActive = 0;
+  let calls = 0;
+  const scheduler = new SessionWatchScheduler({
+    platform: 'win32',
+    synchronize: async () => {
+      calls += 1;
+      active += 1;
+      maxActive = Math.max(maxActive, active);
+      await wait(12);
+      active -= 1;
+      return { indexed: true, sessionId: 'session-1' };
+    },
+    onSynchronized: () => undefined,
+    onError: (queuedEvent, error) => assert.fail(`${queuedEvent.filePath}: ${String(error)}`),
+  }, { debounceMs: 5, maxWaitMs: 20, addRetryDelaysMs: [] });
+
+  scheduler.enqueue(event);
+  scheduler.enqueue({ ...event, filePath: 'c:/SESSIONS/example.jsonl' });
+  await wait(8);
+  scheduler.enqueue(event);
+  await wait(40);
+  await scheduler.close();
+
+  assert.equal(calls, 2);
+  assert.equal(maxActive, 1);
+});
+
+test('retries an incomplete add with bounded delays', async () => {
+  let calls = 0;
+  const synchronized: string[] = [];
+  const scheduler = new SessionWatchScheduler({
+    synchronize: async () => {
+      calls += 1;
+      return { indexed: calls === 3, sessionId: calls === 3 ? 'session-2' : null };
+    },
+    onSynchronized: (_queuedEvent, result) => synchronized.push(result.sessionId ?? ''),
+    onError: (_queuedEvent, error) => assert.fail(String(error)),
+  }, { debounceMs: 1, maxWaitMs: 5, addRetryDelaysMs: [2, 3, 4] });
+
+  scheduler.enqueue({ ...event, eventType: 'add' });
+  await wait(50);
+  await scheduler.close();
+
+  assert.equal(calls, 3);
+  assert.deepEqual(synchronized, ['session-2']);
+});
+
+test('close cancels pending work and waits for an active synchronization', async () => {
+  let release!: () => void;
+  let calls = 0;
+  const scheduler = new SessionWatchScheduler({
+    synchronize: async () => {
+      calls += 1;
+      await new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      return { indexed: true, sessionId: 'session-3' };
+    },
+    onSynchronized: () => undefined,
+    onError: (_queuedEvent, error) => assert.fail(String(error)),
+  }, { debounceMs: 1, maxWaitMs: 5 });
+
+  scheduler.enqueue(event);
+  await wait(5);
+  const closing = scheduler.close();
+  scheduler.enqueue({ ...event, filePath: 'C:/sessions/ignored.jsonl' });
+  release();
+  await closing;
+  await wait(5);
+
+  assert.equal(calls, 1);
+});