@galaxy-yearn/codex-deepseek-gateway 0.1.4 → 0.1.6

package/src/codex-launch.js

@@ -1,13 +1,23 @@
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { clearScreenDown, cursorTo } from 'node:readline';
 import { readCodexConfig } from './codex-config.js';
 
 export const DEFAULT_PROVIDER = 'deepseek-gateway';
 export const REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
-const SELECTED_ROW = '\x1b[38;5;81m';
+const SELECTED_ROW = '\x1b[38;2;91;124;255m';
 const RESET_STYLE = '\x1b[0m';
+const require = createRequire(import.meta.url);
+const CODEX_PLATFORM_PACKAGE_BY_TARGET = {
+  'x86_64-unknown-linux-musl': '@openai/codex-linux-x64',
+  'aarch64-unknown-linux-musl': '@openai/codex-linux-arm64',
+  'x86_64-apple-darwin': '@openai/codex-darwin-x64',
+  'aarch64-apple-darwin': '@openai/codex-darwin-arm64',
+  'x86_64-pc-windows-msvc': '@openai/codex-win32-x64',
+  'aarch64-pc-windows-msvc': '@openai/codex-win32-arm64',
+};
 
 function print(message = '') {
   process.stdout.write(message);
@@ -46,6 +56,7 @@ export function createLaunchContext(options) {
     all: options.all,
     codexHome,
     installDir: options.dir,
+    modelCatalogPath: join(options.dir, 'config', 'codex-model-catalog.json'),
     models,
     projectRoot: findProjectRoot(process.cwd()),
     provider: options.provider || DEFAULT_PROVIDER,
@@ -59,25 +70,22 @@ export function missingModelMessage(context) {
 }
 
 function configOverrideArgs(context) {
-  return [
+  const args = [
     '-c',
     `model_provider=${JSON.stringify(context.provider)}`,
     '-c',
     `model=${JSON.stringify(context.model)}`,
     '-c',
     `model_reasoning_effort=${JSON.stringify(context.reasoningEffort)}`,
-  ];
-}
-
-function configOverrideCommandParts(context) {
-  return [
-    '-c',
-    `model_provider=${context.provider}`,
     '-c',
-    `model=${context.model}`,
+    'model_supports_reasoning_summaries=true',
     '-c',
-    `model_reasoning_effort=${context.reasoningEffort}`,
+    'model_reasoning_summary="auto"',
   ];
+  if (context.provider === DEFAULT_PROVIDER && context.modelCatalogPath) {
+    args.push('-c', `model_catalog_json=${JSON.stringify(context.modelCatalogPath)}`);
+  }
+  return args;
 }
 
 export function codexNewArgs(context) {
@@ -88,20 +96,146 @@ export function codexResumeArgs(sessionId, context) {
   return ['resume', sessionId, ...configOverrideArgs(context)];
 }
 
-export function codexNewCommand(context) {
-  return ['codex', ...configOverrideCommandParts(context)].join(' ');
+function quoteShellArg(arg) {
+  const value = String(arg);
+  if (/^[A-Za-z0-9_./:=@%+,-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 
 export function codexResumeCommand(sessionId, context) {
-  return ['codex', 'resume', sessionId, ...configOverrideCommandParts(context)].join(' ');
+  return ['codex', ...codexResumeArgs(sessionId, context)].map(quoteShellArg).join(' ');
+}
+
+function codexTargetTriple(platform = process.platform, arch = process.arch) {
+  if ((platform === 'linux' || platform === 'android') && arch === 'x64') return 'x86_64-unknown-linux-musl';
+  if ((platform === 'linux' || platform === 'android') && arch === 'arm64') return 'aarch64-unknown-linux-musl';
+  if (platform === 'darwin' && arch === 'x64') return 'x86_64-apple-darwin';
+  if (platform === 'darwin' && arch === 'arm64') return 'aarch64-apple-darwin';
+  if (platform === 'win32' && arch === 'x64') return 'x86_64-pc-windows-msvc';
+  if (platform === 'win32' && arch === 'arm64') return 'aarch64-pc-windows-msvc';
+  return '';
+}
+
+function pathEntries(env = process.env) {
+  const pathValue = env.PATH || env.Path || env.path || '';
+  return pathValue.split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
+}
+
+function candidateExecutables(command, env = process.env) {
+  if (command.includes('/') || command.includes('\\')) return [command];
+  const extensions = process.platform === 'win32'
+    ? (env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+    : [''];
+  const names = process.platform === 'win32'
+    ? extensions.map((extension) => `${command}${extension.toLowerCase()}`)
+    : [command];
+  return pathEntries(env).flatMap((entry) => names.map((name) => join(entry, name)));
+}
+
+function npmShimCodexPackageRoot(shimPath) {
+  const base = dirname(shimPath);
+  const packageRoot = join(base, 'node_modules', '@openai', 'codex');
+  return existsSync(join(packageRoot, 'package.json')) ? packageRoot : '';
+}
+
+function ancestorCodexPackageRoot(filePath) {
+  try {
+    let current = dirname(realpathSync(filePath));
+    while (true) {
+      const packageJson = join(current, 'package.json');
+      if (existsSync(packageJson)) {
+        try {
+          const parsed = JSON.parse(readFileSync(packageJson, 'utf8'));
+          if (parsed?.name === '@openai/codex') return current;
+        } catch {
+          // Keep walking; this is only a best-effort executable locator.
+        }
+      }
+      const parent = dirname(current);
+      if (parent === current) return '';
+      current = parent;
+    }
+  } catch {
+    return '';
+  }
+}
+
+function codexPackageRoot() {
+  try {
+    return dirname(require.resolve('@openai/codex/package.json'));
+  } catch {
+    for (const candidate of candidateExecutables('codex')) {
+      const packageRoot = npmShimCodexPackageRoot(candidate) || ancestorCodexPackageRoot(candidate);
+      if (packageRoot) return packageRoot;
+    }
+    return '';
+  }
+}
+
+function codexPlatformPackageJson(packageRoot, platformPackage) {
+  try {
+    return createRequire(join(packageRoot, 'package.json')).resolve(`${platformPackage}/package.json`);
+  } catch {
+    const nested = join(packageRoot, 'node_modules', platformPackage, 'package.json');
+    return existsSync(nested) ? nested : '';
+  }
+}
+
+export function resolveCodexExecutable() {
+  const packageRoot = codexPackageRoot();
+  const targetTriple = codexTargetTriple();
+  const platformPackage = CODEX_PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+  if (packageRoot && targetTriple && platformPackage) {
+    const packageJson = codexPlatformPackageJson(packageRoot, platformPackage);
+    if (existsSync(packageJson)) {
+      const executable = join(
+        dirname(packageJson),
+        'vendor',
+        targetTriple,
+        'bin',
+        process.platform === 'win32' ? 'codex.exe' : 'codex',
+      );
+      if (existsSync(executable)) return executable;
+    }
+    const bundledExecutable = join(
+      packageRoot,
+      'vendor',
+      targetTriple,
+      'bin',
+      process.platform === 'win32' ? 'codex.exe' : 'codex',
+    );
+    if (existsSync(bundledExecutable)) return bundledExecutable;
+  }
+
+  for (const candidate of candidateExecutables('codex')) {
+    if (existsSync(candidate) && !candidate.endsWith('.cmd') && !candidate.endsWith('.bat') && !candidate.endsWith('.ps1')) {
+      return candidate;
+    }
+  }
+  return 'codex';
+}
+
+export function codexProcessEnv() {
+  const packageRoot = codexPackageRoot();
+  if (!packageRoot) return process.env;
+  return {
+    ...process.env,
+    CODEX_MANAGED_BY_NPM: '1',
+    CODEX_MANAGED_PACKAGE_ROOT: realpathSync(packageRoot),
+  };
 }
 
 export async function runCodex(args) {
-  const child = spawn('codex', args, {
+  const child = spawn(resolveCodexExecutable(), args, {
     stdio: 'inherit',
-    shell: process.platform === 'win32',
+    shell: false,
+    env: codexProcessEnv(),
   });
   process.exitCode = await new Promise((resolveChild) => {
+    child.on('error', (error) => {
+      process.stderr.write(`Failed to launch codex: ${error.message}\n`);
+      resolveChild(1);
+    });
     child.on('exit', (exitCode) => resolveChild(exitCode ?? 0));
   });
 }
@@ -110,25 +244,73 @@ function rowOffset(header) {
   return header ? 4 : 2;
 }
 
-function renderRow(state, index) {
-  cursorTo(process.stdout, 0, rowOffset(state.header) + index);
-  const row = `${index === state.selected ? '>' : ' '} ${state.rows[index]}`;
-  const styled = index === state.selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row;
+export function pickerWindow(rows, selected, windowSize, currentOffset = 0) {
+  const allRows = Array.isArray(rows) ? rows : [];
+  const size = Math.max(1, Math.trunc(Number(windowSize) || allRows.length || 1));
+  const clampedSelected = Math.min(Math.max(0, selected), Math.max(0, allRows.length - 1));
+  const maxOffset = Math.max(0, allRows.length - size);
+  let offset = Math.min(Math.max(0, Math.trunc(Number(currentOffset) || 0)), maxOffset);
+  if (clampedSelected < offset) {
+    offset = clampedSelected;
+  } else if (clampedSelected >= offset + size) {
+    offset = clampedSelected - size + 1;
+  }
+  return {
+    offset,
+    rows: allRows.slice(offset, offset + size),
+  };
+}
+
+function pickerControls(shortcuts = []) {
+  const labels = shortcuts.map((shortcut) => shortcut.label).filter(Boolean);
+  return [...labels, '↑/↓ select', '← back', 'Enter confirm', 'Esc quit'].join('  ');
+}
+
+function renderRow(state, absoluteIndex) {
+  if (absoluteIndex < state.offset || absoluteIndex >= state.offset + state.visibleRows.length) return;
+  const visibleIndex = absoluteIndex - state.offset;
+  cursorTo(process.stdout, 0, rowOffset(state.header) + visibleIndex);
+  const row = `${absoluteIndex === state.selected ? '>' : ' '} ${state.rows[absoluteIndex]}`;
+  const styled = absoluteIndex === state.selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row;
   print(`\x1b[2K${styled}`);
 }
 
-function renderPicker(state) {
-  const { title, rows, selected, header } = state;
+function pickerLines(state) {
+  const { title, rows, selected, header, emptyMessage, shortcuts } = state;
+  const window = pickerWindow(rows, selected, state.windowSize, state.offset);
+  state.offset = window.offset;
+  state.visibleRows = window.rows;
+  const lines = [title, ''];
+  if (header) lines.push(`  ${header}`, `  ${'-'.repeat(header.length)}`);
+  for (const [visibleIndex, rowText] of state.visibleRows.entries()) {
+    const absoluteIndex = state.offset + visibleIndex;
+    const row = `${absoluteIndex === selected ? '>' : ' '} ${rowText}`;
+    lines.push(absoluteIndex === selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row);
+  }
+  if (!rows.length && emptyMessage) lines.push(emptyMessage);
+  if (rows.length > state.visibleRows.length) {
+    lines.push('', `  Showing ${state.offset + 1}-${state.offset + state.visibleRows.length} of ${rows.length}`);
+  }
+  lines.push('', `  ${pickerControls(shortcuts)}`);
+  return lines;
+}
+
+function renderPicker(state, { clear = true } = {}) {
+  const lines = pickerLines(state);
   cursorTo(process.stdout, 0, 0);
-  clearScreenDown(process.stdout);
-  let output = `${title}\n\n`;
-  if (header) output += `  ${header}\n  ${'-'.repeat(header.length)}\n`;
-  for (const [index] of rows.entries()) {
-    const row = `${index === selected ? '>' : ' '} ${rows[index]}`;
-    output += `${index === selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row}\n`;
+  if (clear) {
+    clearScreenDown(process.stdout);
+    print(`${lines.join('\n')}\n`);
+    state.renderedLineCount = lines.length;
+    return;
   }
-  output += '\n↑/↓ select  Enter confirm  ← back  Esc quit\n';
-  print(output);
+  for (const line of lines) {
+    print(`\x1b[2K${line}\n`);
+  }
+  for (let index = lines.length; index < (state.renderedLineCount || 0); index += 1) {
+    print('\x1b[2K\n');
+  }
+  state.renderedLineCount = lines.length;
 }
 
 function openPickerScreen() {
@@ -139,11 +321,23 @@ function closePickerScreen() {
   process.stdout.write('\x1b[?25h\x1b[?1049l');
 }
 
-export async function pick(title, rows, header = '') {
-  if (!rows.length) return { action: 'back' };
+export async function pick(title, rows, header = '', options = {}) {
+  const shortcuts = Array.isArray(options.shortcuts) ? options.shortcuts : [];
+  if (!rows.length && !shortcuts.length) return { action: 'back' };
   let selected = 0;
   const stdin = process.stdin;
-  const state = { title, rows, selected, header };
+  const state = {
+    title,
+    rows,
+    selected,
+    header,
+    shortcuts,
+    windowSize: options.windowSize,
+    emptyMessage: options.emptyMessage,
+    offset: 0,
+    visibleRows: [],
+    renderedLineCount: 0,
+  };
   renderPicker(state);
 
   return await new Promise((resolvePick) => {
@@ -155,13 +349,25 @@ export async function pick(title, rows, header = '') {
       const key = chunk.toString('utf8');
       if (key === '\u0003' || key === '\u001b') return done({ action: 'cancel' });
       if (key === '\u001b[D') return done({ action: 'back' });
-      if (key === '\r' || key === '\n') return done({ action: 'select', index: selected });
+      for (const shortcut of shortcuts) {
+        if (key.toLowerCase() === String(shortcut.key || '').toLowerCase()) {
+          return done({ action: shortcut.action || shortcut.key });
+        }
+      }
+      if ((key === '\r' || key === '\n') && rows.length) return done({ action: 'select', index: selected });
+      if (!rows.length) return;
       const previous = selected;
+      const previousOffset = state.offset;
       if (key === '\u001b[A') selected = Math.max(0, selected - 1);
       else if (key === '\u001b[B') selected = Math.min(rows.length - 1, selected + 1);
       else return;
       if (selected === previous) return;
       state.selected = selected;
+      const nextWindow = pickerWindow(rows, selected, state.windowSize, state.offset);
+      if (nextWindow.offset !== previousOffset) {
+        renderPicker(state, { clear: false });
+        return;
+      }
       renderRow(state, previous);
       renderRow(state, selected);
     };
@@ -214,6 +420,7 @@ export async function chooseLaunchContext(context) {
 }
 
 export async function newConversation(options) {
+  if (options.print) throw new Error('--print is only supported with sessions');
   const context = createLaunchContext(options);
   if (!context.model) {
     print(missingModelMessage(context));
@@ -225,9 +432,5 @@ export async function newConversation(options) {
     const selected = await chooseLaunchContext(context);
     if (!selected) return;
   }
-  if (options.print || (!hasLaunchOverrides && !canPick)) {
-    print(`${codexNewCommand(context)}\n`);
-    return;
-  }
   await runCodex(codexNewArgs(context));
 }

package/src/codex-sessions.js

@@ -5,6 +5,7 @@ import {
   readFileSync,
   readdirSync,
   readSync,
+  statSync,
 } from 'node:fs';
 import { join, resolve } from 'node:path';
 import {
@@ -26,7 +27,7 @@ const ID_WIDTH = 36;
 const TITLE_WIDTH = 16;
 const TABLE_INDENT = '    ';
 const COLUMN_GAP = '  ';
-const NEW_SESSION_ROW = '[New conversation]';
+export const DEFAULT_SESSION_LIMIT = 15;
 
 function print(message = '') {
   process.stdout.write(message);
@@ -60,6 +61,48 @@ function parseJsonLine(line) {
   }
 }
 
+function isSubagentSession(meta) {
+  return meta?.thread_source === 'subagent' || Boolean(meta?.parent_thread_id);
+}
+
+function timestampFromUserMessage(row) {
+  const payload = row?.payload;
+  if (row?.type === 'event_msg' && payload?.type === 'user_message') return row.timestamp || '';
+  if (row?.type === 'response_item' && payload?.type === 'message' && payload.role === 'user') return row.timestamp || '';
+  return '';
+}
+
+function readLastUserMessageTimestamp(file, chunkSize = 256 * 1024) {
+  const handle = openSync(file, 'r');
+  try {
+    let position = statSync(file).size;
+    let suffix = Buffer.alloc(0);
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      const read = readSync(handle, buffer, 0, length, position);
+      let data = buffer.subarray(0, read);
+      if (suffix.length) data = Buffer.concat([data, suffix]);
+
+      let lineEnd = data.length;
+      for (let index = data.length - 1; index >= 0; index -= 1) {
+        if (data[index] !== 10) continue;
+        const row = parseJsonLine(data.subarray(index + 1, lineEnd).toString('utf8').trim());
+        const timestamp = timestampFromUserMessage(row);
+        if (timestamp) return timestamp;
+        lineEnd = index;
+      }
+      suffix = data.subarray(0, lineEnd);
+    }
+
+    const row = parseJsonLine(suffix.toString('utf8').trim());
+    return timestampFromUserMessage(row);
+  } finally {
+    closeSync(handle);
+  }
+}
+
 function readSessionIndex(codexHome) {
   const file = join(codexHome, 'session_index.jsonl');
   const byId = new Map();
@@ -118,16 +161,17 @@ function isInsideProject(cwd, projectRoot) {
   return sessionCwd === root || sessionCwd.startsWith(`${root}${process.platform === 'win32' ? '\\' : '/'}`);
 }
 
-function readSession(file, indexById) {
+export function readSession(file, indexById) {
   const lines = readStart(file).split(/\r?\n/).filter(Boolean);
   const meta = parseJsonLine(lines[0])?.payload;
   if (!meta?.id) return null;
+  if (isSubagentSession(meta)) return null;
   const index = indexById.get(meta.id) || {};
   return {
     id: meta.id,
     provider: meta.model_provider || '',
     cwd: meta.cwd || '',
-    updatedAt: index.updated_at || meta.timestamp || '',
+    updatedAt: readLastUserMessageTimestamp(file) || index.updated_at || meta.timestamp || '',
     title: index.thread_name || firstUserPreview(lines) || '(untitled)',
   };
 }
@@ -142,7 +186,7 @@ function resolveSessionSelection(selection, sessionsList) {
 }
 
 function printSessions(sessionsList, options, context) {
-  const listed = sessionsList.slice(0, options.limit || 20);
+  const listed = sessionsList.slice(0, options.limit || DEFAULT_SESSION_LIMIT);
   print(`Codex sessions ${options.all ? `under ${context.codexHome}` : `for project ${context.projectRoot}`}\n`);
   print(`Target: ${context.provider} / ${context.model} / ${context.reasoningEffort}\n\n`);
   if (!listed.length) {
@@ -171,18 +215,37 @@ function sessionRows(sessionsList) {
   return sessionsList.map((session) => sessionRow(session));
 }
 
+export function sessionPickerRows(allSessions) {
+  return sessionRows(allSessions);
+}
+
 async function chooseSessionFlow(allSessions, context, limit) {
   if (!context.models.length) {
     print(missingModelMessage(context));
     return null;
   }
 
-  const listed = allSessions.slice(0, limit);
   const header = sessionHeader();
+  const windowSize = limit || DEFAULT_SESSION_LIMIT;
   return await withPickerScreen(async () => {
-    let step = 'model';
+    let step = 'session';
     while (true) {
-      if (step === 'model') {
+      if (step === 'session') {
+        const result = await pick(
+          `Choose Codex session`,
+          sessionPickerRows(allSessions),
+          header,
+          {
+            windowSize,
+            emptyMessage: 'No matching sessions found.',
+            shortcuts: [{ key: 'n', action: 'new', label: 'N new' }],
+          },
+        );
+        if (result.action === 'cancel') return null;
+        if (result.action === 'back') return null;
+        context.selectedSession = result.action === 'new' ? { newConversation: true } : allSessions[result.index];
+        step = 'model';
+      } else if (step === 'model') {
         const action = await pickModel(context);
         if (action !== 'select') return null;
         step = 'reasoning';
@@ -190,14 +253,7 @@ async function chooseSessionFlow(allSessions, context, limit) {
         const action = await pickReasoning(context);
         if (action === 'cancel') return null;
         if (action === 'back') step = 'model';
-        else step = 'session';
-      } else {
-        const rows = [NEW_SESSION_ROW, ...sessionRows(listed)];
-        const result = await pick(`Choose Codex session for ${context.provider} / ${context.model} / ${context.reasoningEffort}`, rows, header);
-        if (result.action === 'cancel') return null;
-        if (result.action === 'back') step = 'reasoning';
-        else if (result.index === 0) return { newConversation: true };
-        else return listed[result.index - 1];
+        else return context.selectedSession;
       }
     }
   });
@@ -229,7 +285,7 @@ export async function sessions(options) {
     return;
   }
 
-  const selected = await chooseSessionFlow(allSessions, context, options.limit || 20);
+  const selected = await chooseSessionFlow(allSessions, context, options.limit || DEFAULT_SESSION_LIMIT);
   if (selected?.newConversation) await runCodex(codexNewArgs(context));
   else if (selected) await runCodex(codexResumeArgs(selected.id, context));
 }

package/src/config.js

@@ -25,7 +25,7 @@ export function loadConfig(env = process.env) {
     tavilyBaseUrl: mergedEnv.TAVILY_BASE_URL || 'https://api.tavily.com',
     tavilySearchDepth: mergedEnv.TAVILY_SEARCH_DEPTH || 'basic',
     tavilyMaxResults: Number(mergedEnv.TAVILY_MAX_RESULTS || 5),
-    tavilyMaxSearchRounds: Number(mergedEnv.TAVILY_MAX_SEARCH_ROUNDS || 2),
+    tavilyMaxSearchRounds: Number(mergedEnv.TAVILY_MAX_SEARCH_ROUNDS || 10),
     tavilyTimeoutMs: Number(mergedEnv.TAVILY_TIMEOUT_MS || 15000),
     tavilySnippetChars: Number(mergedEnv.TAVILY_SNIPPET_CHARS || 650),
     tavilyResultMaxChars: Number(mergedEnv.TAVILY_RESULT_MAX_CHARS || 6000),

package/src/firecrawl.js

@@ -304,12 +304,12 @@ export function formatFirecrawlScrapeResult({ url = '', title = '', summary = ''
     if (links?.length) {
       lines.push('Page links:');
       for (const [index, link] of links.entries()) {
-        lines.push(`[L${index + 1}] ${link.title || link.url}`);
+        lines.push(`Link ${index + 1}: ${link.title || link.url}`);
         lines.push(`URL: ${link.url}`);
       }
     }
   }
-  lines.push('Use this opened page only as source text. Cite it with the source number assigned by the search result when available.');
+  lines.push('Use this opened page only as source text. If it supports the answer, include the page title and URL.');
   const text = lines.filter(Boolean).join('\n');
   const maxChars = Number(config.firecrawlResultMaxChars) || DEFAULT_TOTAL_CHARS;
   if (text.length <= maxChars) return text;