@koreanhole/opencodex 2.96.0 → 2.98.0

package/src/adapters/cli-agent/gemini/session-store.ts

@@ -0,0 +1,202 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getConfigDir } from "../../../config";
+import type { OcxMessage } from "../../../types";
+
+export interface GeminiSessionRecord {
+  keyHash: string;
+  vendorSessionId: string;
+  fingerprint: string;
+  modelId: string;
+  workspace: string;
+  historyCount: number;
+  historyHash: string;
+  lastUsed: number;
+  turnCount: number;
+}
+
+interface SessionDocument {
+  version: 1;
+  sessions: Record<string, GeminiSessionRecord>;
+  responses: Record<string, string>;
+}
+
+const sessions = new Map<string, GeminiSessionRecord>();
+const responses = new Map<string, string>();
+let loaded = false;
+
+function sessionPath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "gemini", "sessions.json");
+}
+
+function positiveInt(value: unknown, fallback: number): number {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  return typeof parsed === "number" && Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function ttlMs(env: NodeJS.ProcessEnv): number {
+  return positiveInt(env.OPENCODEX_GEMINI_SESSION_TTL_MS, 60 * 60 * 1000);
+}
+
+function maxSessions(env: NodeJS.ProcessEnv): number {
+  return positiveInt(env.OPENCODEX_GEMINI_SESSION_MAX, 32);
+}
+
+function parseRecord(value: unknown): GeminiSessionRecord | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const row = value as Record<string, unknown>;
+  const keyHash = typeof row.keyHash === "string" ? row.keyHash : undefined;
+  const vendorSessionId = typeof row.vendorSessionId === "string" ? row.vendorSessionId : undefined;
+  const fingerprint = typeof row.fingerprint === "string" ? row.fingerprint : undefined;
+  const modelId = typeof row.modelId === "string" ? row.modelId : undefined;
+  const workspace = typeof row.workspace === "string" ? row.workspace : undefined;
+  const historyHash = typeof row.historyHash === "string" ? row.historyHash : undefined;
+  const historyCount = typeof row.historyCount === "number" && Number.isInteger(row.historyCount) && row.historyCount >= 0 ? row.historyCount : undefined;
+  const lastUsed = typeof row.lastUsed === "number" && Number.isFinite(row.lastUsed) && row.lastUsed >= 0 ? row.lastUsed : undefined;
+  const turnCount = typeof row.turnCount === "number" && Number.isInteger(row.turnCount) && row.turnCount >= 0 ? row.turnCount : undefined;
+  if (!keyHash || !vendorSessionId || !fingerprint || !modelId || !workspace || !historyHash || historyCount === undefined || lastUsed === undefined || turnCount === undefined) return undefined;
+  return { keyHash, vendorSessionId, fingerprint, modelId, workspace, historyCount, historyHash, lastUsed, turnCount };
+}
+
+async function load(env: NodeJS.ProcessEnv): Promise<void> {
+  if (loaded) return;
+  loaded = true;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(await readFile(sessionPath(env), "utf8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+  const document = parsed as Partial<SessionDocument>;
+  if (document.version !== 1) return;
+  if (document.sessions && typeof document.sessions === "object") {
+    for (const [key, value] of Object.entries(document.sessions)) {
+      const record = parseRecord(value);
+      if (record) sessions.set(key, record);
+    }
+  }
+  if (document.responses && typeof document.responses === "object") {
+    for (const [responseId, keyHash] of Object.entries(document.responses)) {
+      if (typeof keyHash === "string") responses.set(responseId, keyHash);
+    }
+  }
+}
+
+async function persist(env: NodeJS.ProcessEnv): Promise<void> {
+  const path = sessionPath(env);
+  await mkdir(join(getConfigDir(env), "gemini"), { recursive: true, mode: 0o700 });
+  const document: SessionDocument = {
+    version: 1,
+    sessions: Object.fromEntries(sessions),
+    responses: Object.fromEntries(responses),
+  };
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify(document, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  await rename(temporary, path);
+}
+
+function safeWorkspace(workspace: string, env: NodeJS.ProcessEnv): boolean {
+  const root = join(getConfigDir(env), "gemini", "sessions");
+  return workspace.startsWith(`${root}/`);
+}
+
+async function removeWorkspace(record: GeminiSessionRecord, env: NodeJS.ProcessEnv): Promise<void> {
+  if (!safeWorkspace(record.workspace, env)) return;
+  await rm(record.workspace, { recursive: true, force: true }).catch(() => undefined);
+}
+
+export function hashConversationKey(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function hashMessages(messages: readonly OcxMessage[]): string {
+  return createHash("sha256")
+    .update(JSON.stringify(messages, (key, value) => key === "timestamp" ? undefined : value))
+    .digest("hex");
+}
+
+export function geminiSessionWorkspace(keyHash: string, env: NodeJS.ProcessEnv = process.env): string {
+  return join(getConfigDir(env), "gemini", "sessions", keyHash);
+}
+
+export async function findGeminiSessionByResponseId(
+  responseId: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<GeminiSessionRecord | undefined> {
+  await load(env);
+  const keyHash = responses.get(responseId);
+  return keyHash ? sessions.get(keyHash) : undefined;
+}
+
+export async function findGeminiSessionByKeyHash(
+  keyHash: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<GeminiSessionRecord | undefined> {
+  await load(env);
+  return sessions.get(keyHash);
+}
+
+export async function saveGeminiSession(
+  record: GeminiSessionRecord,
+  responseId: string | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  await load(env);
+  sessions.set(record.keyHash, record);
+  const previousResponses = [...responses].filter(([, key]) => key === record.keyHash);
+  for (const [id] of previousResponses.slice(0, Math.max(0, previousResponses.length - 1))) {
+    responses.delete(id);
+  }
+  if (responseId) responses.set(responseId, record.keyHash);
+  const cutoff = Date.now() - ttlMs(env);
+  for (const [key, value] of sessions) {
+    if (value.lastUsed < cutoff) {
+      sessions.delete(key);
+      for (const [id, mapped] of responses) if (mapped === key) responses.delete(id);
+      await removeWorkspace(value, env);
+    }
+  }
+  const limit = maxSessions(env);
+  while (sessions.size > limit) {
+    const oldest = [...sessions.values()].sort((left, right) => left.lastUsed - right.lastUsed)[0];
+    if (!oldest) break;
+    sessions.delete(oldest.keyHash);
+    for (const [id, mapped] of responses) if (mapped === oldest.keyHash) responses.delete(id);
+    await removeWorkspace(oldest, env);
+  }
+  await persist(env);
+}
+
+export async function deleteGeminiSession(
+  keyHash: string,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  await load(env);
+  const record = sessions.get(keyHash);
+  sessions.delete(keyHash);
+  for (const [id, mapped] of responses) if (mapped === keyHash) responses.delete(id);
+  if (record) await removeWorkspace(record, env);
+  await persist(env);
+}
+
+export async function reclaimGeminiSessions(env: NodeJS.ProcessEnv = process.env): Promise<void> {
+  await load(env);
+  const cutoff = Date.now() - ttlMs(env);
+  let changed = false;
+  for (const [key, record] of sessions) {
+    if (record.lastUsed >= cutoff) continue;
+    sessions.delete(key);
+    for (const [id, mapped] of responses) if (mapped === key) responses.delete(id);
+    await removeWorkspace(record, env);
+    changed = true;
+  }
+  if (changed) await persist(env);
+}
+
+export function resetGeminiSessionStoreForTests(): void {
+  sessions.clear();
+  responses.clear();
+  loaded = false;
+}

package/src/adapters/cli-agent/protocol.ts

@@ -108,7 +108,7 @@ export function buildSystemPrompt(parsed: OcxParsedRequest): string | undefined
 
 export function buildConversationInput(
   parsed: OcxParsedRequest,
-  options: { maxHistoryChars?: number; vendorNameByWire?: ReadonlyMap<string, string> } = {},
+  options: { maxHistoryChars?: number; maxChars?: number; vendorNameByWire?: ReadonlyMap<string, string> } = {},
 ): string[] {
   const messages = parsed.context.messages.filter(message => message.role !== "developer");
   if (messages.length === 0) {
@@ -117,14 +117,8 @@ export function buildConversationInput(
   if (messages.length === 1 && messages[0]!.role === "user") {
     return [JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: textOf(messages[0]!.content) }] } })];
   }
-  const history = messages.slice(0, -1)
-    .map(message => formatMessage(message, options.vendorNameByWire))
-    .filter(Boolean)
-    .join("\n\n");
-  const limit = options.maxHistoryChars ?? MAX_PROJECTED_HISTORY_CHARS;
-  const boundedHistory = history.length > limit
-    ? `[Earlier conversation history truncated for length...]\n\n${history.slice(-limit)}`
-    : history;
+  const limit = options.maxChars ?? options.maxHistoryChars ?? MAX_PROJECTED_HISTORY_CHARS;
+  const boundedHistory = projectHistory(messages.slice(0, -1), limit, options.vendorNameByWire);
   const current = messages.at(-1)!;
   const currentText = current.role === "toolResult"
     ? `${formatMessage(current)}\n\nPlease proceed based on the above tool result.`
@@ -138,4 +132,61 @@ export function buildConversationInput(
   })];
 }
 
+function projectHistory(
+  messages: readonly OcxMessage[],
+  limit: number,
+  vendorNameByWire?: ReadonlyMap<string, string>,
+): string {
+  const entries = messages.map((message, index) => {
+    const age = messages.length - index;
+    const priority = message.role === "toolResult"
+      ? age <= 2 ? 10 : 2
+      : message.role === "user"
+        ? 9
+        : message.role === "assistant" && message.content.every(part => part.type === "thinking")
+          ? 1
+          : message.role === "assistant" && age <= 2
+            ? 8
+            : 4;
+    return {
+      index,
+      age,
+      priority,
+      text: formatMessage(message, vendorNameByWire),
+    };
+  }).filter(entry => entry.text.length > 0);
+  let total = entries.reduce((sum, entry) => sum + entry.text.length + 2, 0);
+  if (total <= limit) return entries.map(entry => entry.text).join("\n\n");
+  const removed = new Set<number>();
+  const candidates = entries
+    .filter(entry => entry.priority < 10)
+    .sort((left, right) => left.priority - right.priority || right.age - left.age);
+  for (const entry of candidates) {
+    if (total <= limit) break;
+    removed.add(entry.index);
+    total -= entry.text.length + 2;
+  }
+  for (const entry of entries.filter(entry => !removed.has(entry.index)).sort((left, right) => right.age - left.age)) {
+    if (total <= limit) break;
+    removed.add(entry.index);
+    total -= entry.text.length + 2;
+  }
+  const kept = entries.filter(entry => !removed.has(entry.index)).map(entry => entry.text);
+  return [`[Earlier conversation history omitted: ${removed.size} messages]`, ...kept].filter(Boolean).join("\n\n");
+}
+
+export function buildConversationDelta(
+  parsed: OcxParsedRequest,
+  startIndex: number,
+  options: { vendorNameByWire?: ReadonlyMap<string, string> } = {},
+): string {
+  const messages = parsed.context.messages.filter(message => message.role !== "developer");
+  const delta = messages.slice(startIndex).map(message => formatMessage(message, options.vendorNameByWire)).filter(Boolean);
+  if (delta.length === 0) return "";
+  const text = delta.join("\n\n");
+  return messages.at(-1)?.role === "toolResult"
+    ? `${text}\n\nPlease proceed based on the above tool result.`
+    : text;
+}
+
 export type { AdapterEvent };

package/src/adapters/cli-agent/types.ts

@@ -1,5 +1,5 @@
 import type { ChildProcess, SpawnOptions } from "node:child_process";
-import type { AdapterEvent, OcxUsage } from "../../types";
+import type { OcxUsage } from "../../types";
 
 export type CliAgentSpawnFn = (
   command: string,
@@ -17,27 +17,6 @@ export interface CliAgentStreamState {
   lastError?: string;
 }
 
-export interface CliAgentFailure {
-  exitCode: number;
-  stderr: string;
-}
-
-export interface CliAgentTurnPlan {
-  label: string;
-  binary: string;
-  args: readonly string[];
-  env: Record<string, string>;
-  cwd: string;
-  stdin: string;
-  stdinFile?: string;
-  state: CliAgentStreamState;
-  parseLine: (message: Record<string, unknown>, state: CliAgentStreamState) => AdapterEvent[];
-  classifyFailure?: (failure: CliAgentFailure) => Extract<AdapterEvent, { type: "error" }>;
-  requireToolCall?: boolean;
-  toolBatchIdleMs?: number;
-  cleanup: () => Promise<void>;
-}
-
 export interface CliAgentTurnDeps {
   spawn?: CliAgentSpawnFn;
   platform?: NodeJS.Platform;

package/src/cli/index.ts

@@ -19,6 +19,7 @@ import {
 import { startServer } from "../server";
 import { loginClineAcp } from "../adapters/cli-agent/cline/acp";
 import { runCodingAgentMcpServer } from "../adapters/cli-agent/mcp-server";
+import { syncCodexCatalog } from "../lib/codex-catalog";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
@@ -61,6 +62,7 @@ function help(): string {
     "  start [--port <port>] [--host <host>] Start the proxy",
     "  status [--json]                        Check the running proxy",
     "  stop [--json]                          Stop the running proxy",
+    "  codex sync [--json]                    Refresh the Codex model catalog",
     "  version                                Print the package version",
     "  help                                   Show this help",
     "",
@@ -177,6 +179,20 @@ async function startCommand(args: string[]): Promise<number> {
     config.port = parsed;
   }
   if (host !== undefined) config.host = host;
+  try {
+    const catalog = await syncCodexCatalog({ env });
+    if (catalog.ok && catalog.written) {
+      console.log(`Codex catalog refreshed: ${catalog.path}`);
+      console.log("Restart the Codex app/app-server to reload the model picker.");
+      if (!catalog.configured) {
+        console.log(`Activate it with: model_catalog_json = "${catalog.path}"`);
+      }
+    } else if (!catalog.ok) {
+      console.warn(`[opencodex] Codex catalog was not refreshed: ${catalog.message}`);
+    }
+  } catch (error) {
+    console.warn(`[opencodex] Codex catalog refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const running = startServer(config, { env });
   await writeRuntimeState({ pid: process.pid, port: running.port, host: running.host, startedAt: new Date().toISOString() }, env);
   console.log(`opencodex listening on http://${running.host}:${running.port}/v1 (default provider: ${config.defaultProvider})`);
@@ -194,6 +210,31 @@ async function startCommand(args: string[]): Promise<number> {
   return 0;
 }
 
+async function codexCommand(args: string[]): Promise<number> {
+  const sub = args.shift();
+  if (sub !== "sync") throw new ConfigError(`Unknown codex command: ${sub ?? "(missing)"}. Expected sync.`);
+  const json = takeFlag(args, "--json");
+  if (args.length > 0) throw new ConfigError(`Unknown codex sync option: ${args[0]}`);
+  const result = await syncCodexCatalog({ env: process.env });
+  if (!result.ok) {
+    if (json) console.log(JSON.stringify({ ok: false, path: result.path, reason: result.reason, message: result.message }));
+    else console.error(`ocx: ${result.message}`);
+    return 1;
+  }
+  if (json) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(`Catalog: ${result.path}`);
+    console.log(`Models: ${result.modelCount} (Gemini ${result.geminiModelCount}, reasoning-enabled ${result.reasoningModelCount})`);
+    for (const warning of result.warnings) console.warn(`[opencodex] ${warning}`);
+    if (!result.configured) {
+      console.log(`Activate it with: model_catalog_json = "${result.path}"`);
+    }
+    console.log("Codex reload required: restart the Codex app or app-server model picker.");
+  }
+  return 0;
+}
+
 async function statusCommand(args: string[]): Promise<number> {
   const json = takeFlag(args, "--json");
   if (args.length > 0) throw new ConfigError(`Unknown status option: ${args[0]}`);
@@ -256,10 +297,11 @@ async function main(argv: string[]): Promise<number> {
   }
   if (command === "login") return await loginCommand(argv);
   if (command === "provider") return await providerCommand(argv);
+  if (command === "codex") return await codexCommand(argv);
   if (command === "start") return await startCommand(argv);
   if (command === "status") return await statusCommand(argv);
   if (command === "stop") return await stopCommand(argv);
-  throw new ConfigError(`Unknown command: ${command}. Expected login, provider, start, status, stop, version, or help.`);
+  throw new ConfigError(`Unknown command: ${command}. Expected login, provider, codex, start, status, stop, version, or help.`);
 }
 
 try {