wind-agent-cli 1.37.2

package/server/modules/providers/tests/codex-native-command.service.test.ts

@@ -0,0 +1,223 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { CodexAppServerClient } from '@/modules/providers/list/codex/codex-app-server.client.js';
+import { parseCodexNativeCommand } from '@/modules/providers/list/codex/codex-native-command.service.js';
+import { codexNativeRuntime } from '@/modules/providers/list/codex/codex-native-runtime.provider.js';
+import type { ProviderRuntimeContext } from '@/shared/types.js';
+
+type FakeAppServer = {
+  request(method: string, params?: unknown): Promise<any>;
+  onNotification(listener: (event: any) => void): () => void;
+  onRequest(listener: (event: any) => boolean): () => void;
+  onExit(listener: (event: { error: Error }) => void): () => void;
+  respond(id: number, result: unknown): void;
+  close(): void;
+};
+
+function createRuntimeContext(): ProviderRuntimeContext {
+  return {
+    resolveProviderSessionId: () => null,
+    resolveResumeModel: async () => 'gpt-test',
+    getProviderModels: async () => ({
+      DEFAULT: 'gpt-test',
+      OPTIONS: [{ value: 'gpt-test', label: 'GPT Test' }],
+    }),
+    normalizeMessage: () => [],
+    isProviderInstalled: async () => true,
+  };
+}
+
+async function withFakeAppServer(fake: FakeAppServer, run: () => Promise<void>): Promise<void> {
+  const originalStart = CodexAppServerClient.start;
+  CodexAppServerClient.start = async () => fake as CodexAppServerClient;
+  try {
+    await run();
+  } finally {
+    CodexAppServerClient.start = originalStart;
+  }
+}
+
+test('parses supported Codex native commands case-insensitively', () => {
+  assert.deepEqual(parseCodexNativeCommand('/plan'), {
+    kind: 'plan',
+    prompt: '',
+  });
+  assert.deepEqual(parseCodexNativeCommand('/PLAN design the migration'), {
+    kind: 'plan',
+    prompt: 'design the migration',
+  });
+  assert.deepEqual(parseCodexNativeCommand('/review'), {
+    kind: 'review',
+    prompt: '',
+  });
+  assert.deepEqual(parseCodexNativeCommand('/review focus on authentication'), {
+    kind: 'review',
+    prompt: 'focus on authentication',
+  });
+  assert.deepEqual(parseCodexNativeCommand('/compact'), {
+    kind: 'compact',
+  });
+});
+
+test('does not intercept ordinary prompts or unsupported slash commands', () => {
+  assert.equal(parseCodexNativeCommand('plan the work'), null);
+  assert.equal(parseCodexNativeCommand('/planner'), null);
+  assert.equal(parseCodexNativeCommand('/compact now'), null);
+  assert.equal(parseCodexNativeCommand('/my-project-command value'), null);
+});
+
+test('bare plan command toggles plan mode without starting a Codex turn', async () => {
+  const messages: Array<Record<string, any>> = [];
+  const writer = { send: (message: unknown) => messages.push(message as Record<string, any>) };
+  const context = {} as ProviderRuntimeContext;
+  const options = { sessionId: 'plan-toggle-test-session' };
+
+  await codexNativeRuntime.run('/plan', options, writer, context);
+  await codexNativeRuntime.run('/plan', options, writer, context);
+
+  assert.deepEqual(messages.map((message) => message.kind), [
+    'text',
+    'complete',
+    'text',
+    'complete',
+  ]);
+  assert.equal(messages[0]?.content, 'Plan mode enabled.');
+  assert.equal(messages[2]?.content, 'Plan mode disabled.');
+});
+
+test('plan turns bridge app-server command approvals through the runtime gateway', { concurrency: false }, async () => {
+  let notificationListener = (_event: any) => {};
+  let requestListener = (_event: any) => false;
+  const responses: Array<{ id: number; result: unknown }> = [];
+  const fake: FakeAppServer = {
+    async request(method) {
+      if (method === 'thread/start') {
+        return { thread: { id: 'native-approval-thread' } };
+      }
+      if (method === 'turn/start') {
+        setImmediate(() => requestListener({
+          id: 41,
+          method: 'item/commandExecution/requestApproval',
+          params: { command: 'git status', cwd: 'D:/workspace' },
+        }));
+        return { turn: { id: 'turn-approval' } };
+      }
+      return {};
+    },
+    onNotification(listener) {
+      notificationListener = listener;
+      return () => {};
+    },
+    onRequest(listener) {
+      requestListener = listener;
+      return () => {};
+    },
+    onExit() {
+      return () => {};
+    },
+    respond(id, result) {
+      responses.push({ id, result });
+      if (id === 41) {
+        setImmediate(() => requestListener({
+          id: 42,
+          method: 'item/tool/requestUserInput',
+          params: {
+            questions: [{
+              id: 'scope',
+              header: 'Scope',
+              question: 'Which area?',
+              options: [{ label: 'Backend', description: 'Server code' }],
+            }],
+          },
+        }));
+      } else {
+        setImmediate(() => notificationListener({
+          method: 'turn/completed',
+          params: { turn: { status: 'completed' } },
+        }));
+      }
+    },
+    close() {},
+  };
+  const messages: Array<Record<string, any>> = [];
+
+  await withFakeAppServer(fake, async () => {
+    const run = codexNativeRuntime.run(
+      '/plan inspect the repository',
+      { sessionId: 'approval-app-session', projectPath: 'D:/workspace' },
+      { send: (message) => messages.push(message as Record<string, any>) },
+      createRuntimeContext(),
+    ) as Promise<void>;
+    for (let attempt = 0; attempt < 10 && !messages.some((message) => message.kind === 'permission_request'); attempt += 1) {
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+    const approval = messages.find((message) => message.kind === 'permission_request');
+    assert.ok(approval?.requestId);
+    codexNativeRuntime.permissions?.resolve(approval.requestId as string, { allow: true });
+    for (let attempt = 0; attempt < 10 && messages.filter((message) => message.kind === 'permission_request').length < 2; attempt += 1) {
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+    const userInput = messages.filter((message) => message.kind === 'permission_request').at(-1);
+    assert.equal(userInput?.toolName, 'AskUserQuestion');
+    assert.equal(userInput?.provider, 'codex');
+    assert.deepEqual(userInput?.input?.questions, [{
+      id: 'scope',
+      header: 'Scope',
+      question: 'Which area?',
+      multiSelect: false,
+      options: [{ label: 'Backend', description: 'Server code' }],
+    }]);
+    codexNativeRuntime.permissions?.resolve(userInput?.requestId as string, {
+      allow: true,
+      updatedInput: { answers: { scope: { answers: ['Backend'] } } },
+    });
+    await run;
+  });
+
+  assert.deepEqual(responses, [
+    { id: 41, result: { decision: 'accept' } },
+    { id: 42, result: { answers: { scope: { answers: ['Backend'] } } } },
+  ]);
+  assert.equal(messages.at(-1)?.kind, 'complete');
+  assert.equal(messages.at(-1)?.success, true);
+});
+
+test('an unexpected app-server exit terminates the chat run with an error', { concurrency: false }, async () => {
+  let exitListener = (_event: { error: Error }) => {};
+  const fake: FakeAppServer = {
+    async request(method) {
+      if (method === 'thread/start') {
+        return { thread: { id: 'native-crash-thread' } };
+      }
+      if (method === 'turn/start') {
+        setImmediate(() => exitListener({ error: new Error('simulated app-server crash') }));
+        return { turn: { id: 'turn-crash' } };
+      }
+      return {};
+    },
+    onNotification: () => () => {},
+    onRequest: () => () => {},
+    onExit(listener) {
+      exitListener = listener;
+      return () => {};
+    },
+    respond() {},
+    close() {},
+  };
+  const messages: Array<Record<string, any>> = [];
+
+  await withFakeAppServer(fake, async () => {
+    await codexNativeRuntime.run(
+      '/plan inspect safely',
+      { sessionId: 'crash-app-session', projectPath: 'D:/workspace' },
+      { send: (message) => messages.push(message as Record<string, any>) },
+      createRuntimeContext(),
+    );
+  });
+
+  assert.equal(messages.some((message) => message.kind === 'error'
+    && String(message.content).includes('simulated app-server crash')), true);
+  assert.equal(messages.at(-1)?.kind, 'complete');
+  assert.equal(messages.at(-1)?.success, false);
+});

package/server/modules/providers/tests/codex-sdk-windows-hide-patch.test.ts

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { addWindowsHideToCodexSdk } from '../../../../scripts/fix-codex-sdk-windows-hide.js';
+
+const sdkSpawnSource = `
+const child = spawn(this.executablePath, commandArgs, {
+  env,
+  signal: args.signal
+});
+`;
+
+test('Codex SDK patch adds windowsHide to the CLI spawn options', () => {
+  const result = addWindowsHideToCodexSdk(sdkSpawnSource);
+
+  assert.equal(result.status, 'patched');
+  assert.match(result.source, /windowsHide:\s*true/);
+});
+
+test('Codex SDK patch is idempotent', () => {
+  const first = addWindowsHideToCodexSdk(sdkSpawnSource);
+  const second = addWindowsHideToCodexSdk(first.source);
+
+  assert.equal(second.status, 'already-patched');
+  assert.equal(second.source, first.source);
+});
+
+test('Codex SDK patch rejects an unknown SDK layout', () => {
+  const result = addWindowsHideToCodexSdk('const child = customSpawn();');
+
+  assert.equal(result.status, 'unsupported');
+  assert.equal(result.source, 'const child = customSpawn();');
+});

package/server/modules/providers/tests/codex-sdk-windows-hide.test.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+
+test('installed Codex SDK hides its CLI console on Windows', {
+  skip: process.platform !== 'win32',
+}, async () => {
+  const sdkEntryPath = new URL(import.meta.resolve('@openai/codex-sdk'));
+  const sdkSource = await readFile(sdkEntryPath, 'utf8');
+  const spawnCall = sdkSource.match(
+    /spawn\(this\.executablePath, commandArgs, \{[\s\S]*?\n\s*\}\);/,
+  )?.[0];
+
+  assert.ok(spawnCall, 'Could not locate the Codex SDK CLI spawn call');
+  assert.match(
+    spawnCall,
+    /windowsHide:\s*true/,
+    'Codex SDK must hide the subprocess console to prevent MCP terminal popups',
+  );
+});

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

@@ -0,0 +1,231 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { CodexSessionSynchronizer } from '@/modules/providers/list/codex/codex-session-synchronizer.provider.js';
+import { CodexSessionsProvider } from '@/modules/providers/list/codex/codex-sessions.provider.js';
+
+const patchHomeDir = (nextHomeDir: string) => {
+  const original = os.homedir;
+  (os as any).homedir = () => nextHomeDir;
+  return () => {
+    (os as any).homedir = original;
+  };
+};
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(os.tmpdir(), 'codex-provider-db-'));
+  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 });
+  }
+}
+
+/**
+ * Writes one Codex rollout transcript. `firstUserMessage` mirrors the
+ * `event_msg`/`user_message` payload the runtime records for the prompt the
+ * user typed; omitting it produces a transcript with no user turn.
+ */
+const writeCodexTranscript = async (
+  homeDir: string,
+  codexSessionId: string,
+  workspacePath: string,
+  firstUserMessage?: string,
+): Promise<string> => {
+  const sessionsDir = path.join(homeDir, '.codex', 'sessions', '2026', '07', '07');
+  await mkdir(sessionsDir, { recursive: true });
+
+  const lines: string[] = [
+    JSON.stringify({ type: 'session_meta', payload: { id: codexSessionId, cwd: workspacePath } }),
+  ];
+  if (firstUserMessage !== undefined) {
+    lines.push(JSON.stringify({ type: 'event_msg', payload: { type: 'user_message', message: firstUserMessage } }));
+  }
+
+  const filePath = path.join(sessionsDir, `rollout-${codexSessionId}.jsonl`);
+  await writeFile(filePath, `${lines.join('\n')}\n`, 'utf8');
+  return filePath;
+};
+
+test('Codex synchronizer preserves the title assigned when CloudCLI creates a session', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-app-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    await writeCodexTranscript(tempRoot, 'codex-app-1', workspacePath, 'Provider transcript title must not win');
+    await withIsolatedDatabase(async () => {
+      // The app allocates its own id and later maps the provider id onto it,
+      // exactly as a message sent from cloudcli does.
+      sessionsDb.createAppSession('app-1', 'codex', workspacePath, 'Fix the login redirect');
+      sessionsDb.assignProviderSessionId('app-1', 'codex-app-1');
+
+      const synchronizer = new CodexSessionSynchronizer();
+      await synchronizer.synchronize();
+
+      assert.equal(sessionsDb.getSessionById('app-1')?.custom_name, 'Fix the login redirect');
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex synchronizer skips sub-agent rollout files', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-subagent-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    // Codex >=0.144 spawn_agent threads write their own rollout files into the
+    // same sessions tree, marked via thread_source/source in session_meta.
+    const sessionsDir = path.join(tempRoot, '.codex', 'sessions', '2026', '07', '07');
+    await mkdir(sessionsDir, { recursive: true });
+    await writeFile(
+      path.join(sessionsDir, 'rollout-codex-subagent-1.jsonl'),
+      `${JSON.stringify({
+        type: 'session_meta',
+        payload: {
+          id: 'codex-subagent-1',
+          cwd: workspacePath,
+          thread_source: 'subagent',
+          parent_thread_id: 'codex-parent-1',
+          source: { subagent: { thread_spawn: { parent_thread_id: 'codex-parent-1', depth: 1 } } },
+        },
+      })}\n`,
+      'utf8'
+    );
+    await writeCodexTranscript(tempRoot, 'codex-parent-1', workspacePath);
+
+    await withIsolatedDatabase(async () => {
+      const synchronizer = new CodexSessionSynchronizer();
+      const processed = await synchronizer.synchronize();
+
+      assert.equal(processed, 1);
+      assert.ok(sessionsDb.getSessionById('codex-parent-1'));
+      assert.equal(sessionsDb.getSessionById('codex-subagent-1'), null);
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex synchronizer leaves indexed sessions untitled when no name is available', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-session-sync-indexed-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    // A CLI-created session has no app row; its first user message must NOT be
+    // used as the title, preserving the existing indexing behavior.
+    await writeCodexTranscript(tempRoot, 'codex-indexed-1', workspacePath, 'This prompt should be ignored');
+    await withIsolatedDatabase(async () => {
+      const synchronizer = new CodexSessionSynchronizer();
+      await synchronizer.synchronize();
+
+      assert.equal(sessionsDb.getSessionById('codex-indexed-1')?.custom_name, 'Untitled Codex Session');
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('Codex history preserves wrapped exec tool calls and results', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'codex-exec-history-'));
+  const workspacePath = path.join(tempRoot, 'workspace');
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    const providerSessionId = 'codex-exec-1';
+    const transcriptPath = await writeCodexTranscript(tempRoot, providerSessionId, workspacePath);
+    const wrappedCalls = [
+      {
+        callId: 'shell-command-1',
+        input: 'const cmds = ["echo one", "echo two"]; await Promise.all(cmds.map(command => tools.shell_command({ command })));',
+        expectedToolName: 'Bash',
+        expectedToolInput: JSON.stringify({ command: 'echo one\necho two' }),
+      },
+      {
+        callId: 'json-shell-command-1',
+        input: 'const r = await tools.shell_command({"command":"Get-Content -Raw README.md","workdir":"C:\\\\workspace","timeout_ms":10000}); text(r)',
+        expectedToolName: 'Bash',
+        expectedToolInput: JSON.stringify({ command: 'Get-Content -Raw README.md' }),
+      },
+      {
+        callId: 'exec-command-1',
+        input: 'await tools.exec_command({"command":"echo current"});',
+        expectedToolName: 'Bash',
+        expectedToolInput: JSON.stringify({ command: 'echo current' }),
+      },
+      { callId: 'apply-patch-1', input: 'await tools.apply_patch("*** Begin Patch\\n*** End Patch");' },
+      { callId: 'web-run-1', input: 'await tools.web__run({ search_query: [{ q: "Codex" }] });' },
+      { callId: 'update-plan-1', input: 'await tools.update_plan({ plan: [] });' },
+      { callId: 'unknown-1', input: 'await tools.unknown_wrapper({ value: true });' },
+    ];
+    const transcriptLines = [
+      JSON.stringify({ type: 'session_meta', payload: { id: providerSessionId, cwd: workspacePath } }),
+    ];
+    for (const call of wrappedCalls) {
+      transcriptLines.push(
+        JSON.stringify({
+          type: 'response_item',
+          payload: { type: 'custom_tool_call', name: 'exec', call_id: call.callId, input: call.input },
+        }),
+        JSON.stringify({
+          type: 'response_item',
+          payload: { type: 'custom_tool_call_output', call_id: call.callId, output: `result:${call.callId}` },
+        }),
+      );
+    }
+    await writeFile(transcriptPath, `${transcriptLines.join('\n')}\n`, 'utf8');
+
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-exec-1', 'codex', workspacePath);
+      sessionsDb.assignProviderSessionId('app-exec-1', providerSessionId);
+      await new CodexSessionSynchronizer().synchronize();
+
+      const history = await new CodexSessionsProvider().fetchHistory('app-exec-1');
+      const toolUses = history.messages.filter((message) => message.kind === 'tool_use');
+      const toolResults = history.messages.filter((message) => message.kind === 'tool_result');
+      const toolUsesById = new Map(toolUses.map((message) => [message.toolId, message]));
+      const toolResultsById = new Map(toolResults.map((message) => [message.toolId, message]));
+
+      assert.equal(toolUses.length, wrappedCalls.length);
+      assert.equal(toolResults.length, wrappedCalls.length);
+      for (const call of wrappedCalls) {
+        const toolUse = toolUsesById.get(call.callId);
+        assert.ok(toolUse);
+        assert.equal(toolUse.toolName, call.expectedToolName || 'exec');
+        assert.equal(toolUse.toolInput, call.expectedToolInput || call.input);
+        assert.equal(toolUse.toolResult?.content, `result:${call.callId}`);
+        assert.equal(toolResultsById.get(call.callId)?.content, `result:${call.callId}`);
+      }
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});