@galaxy-yearn/codex-deepseek-gateway 0.1.5 → 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,7 +70,7 @@ export function missingModelMessage(context) {
 }
 
 function configOverrideArgs(context) {
-  return [
+  const args = [
     '-c',
     `model_provider=${JSON.stringify(context.provider)}`,
     '-c',
@@ -71,21 +82,10 @@ function configOverrideArgs(context) {
     '-c',
     'model_reasoning_summary="auto"',
   ];
-}
-
-function configOverrideCommandParts(context) {
-  return [
-    '-c',
-    `model_provider=${context.provider}`,
-    '-c',
-    `model=${context.model}`,
-    '-c',
-    `model_reasoning_effort=${context.reasoningEffort}`,
-    '-c',
-    'model_supports_reasoning_summaries=true',
-    '-c',
-    '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) {
@@ -96,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));
   });
 }
@@ -118,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;
+  }
+  for (const line of lines) {
+    print(`\x1b[2K${line}\n`);
   }
-  output += '\nUp/Down select  Enter confirm  Left back  Esc quit\n';
-  print(output);
+  for (let index = lines.length; index < (state.renderedLineCount || 0); index += 1) {
+    print('\x1b[2K\n');
+  }
+  state.renderedLineCount = lines.length;
 }
 
 function openPickerScreen() {
@@ -147,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) => {
@@ -163,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);
     };
@@ -222,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));
@@ -233,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

@@ -27,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);
@@ -186,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) {
@@ -215,23 +215,35 @@ 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 = 'session';
     while (true) {
       if (step === 'session') {
-        const rows = [NEW_SESSION_ROW, ...sessionRows(listed)];
-        const result = await pick(`Choose Codex session`, rows, header);
+        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.index === 0 ? { newConversation: true } : listed[result.index - 1];
+        context.selectedSession = result.action === 'new' ? { newConversation: true } : allSessions[result.index];
         step = 'model';
       } else if (step === 'model') {
         const action = await pickModel(context);
@@ -273,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));
 }