pi-codex-search 0.1.1 → 0.1.3

package/src/modes/types.ts

@@ -0,0 +1,41 @@
+export type SearchContextSize = "low" | "medium" | "high";
+export type Freshness = "live" | "cached" | "indexed";
+export type StandaloneExternalWebAccess = boolean | "indexed";
+export type ResponseLength = "short" | "medium" | "long";
+
+export interface CodexCitation {
+  title?: string;
+  url: string;
+  startIndex?: number;
+  endIndex?: number;
+}
+
+export interface CodexSearchCall {
+  id?: string;
+  status?: string;
+  query?: string;
+  url?: string;
+  actionType?: string;
+  refId?: string;
+}
+
+export interface CodexWebSearchResult {
+  responseId?: string;
+  model: string;
+  text: string;
+  searchCalls: CodexSearchCall[];
+  citations: CodexCitation[];
+  refIds?: Record<string, string>;
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+  };
+  encryptedOutput?: string;
+}
+
+export interface CodexModel {
+  id: string;
+  name?: string;
+  isDefault?: boolean;
+}

package/src/ref-store.ts

@@ -0,0 +1,74 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export interface RefStore {
+  resolveRefId(url: string): string | undefined;
+  remember(url: string, refId: string): Promise<void>;
+  load(sessionDir: string): Promise<void>;
+}
+
+interface StoredRefs {
+  urlToRefId: Record<string, string>;
+}
+
+const STORE_FILE = "pi-codex-search-refs.json";
+const PERSIST_QUEUES = new Map<string, Promise<void>>();
+
+export function createRefStore(): RefStore {
+  const urlToRefId = new Map<string, string>();
+  let sessionDir: string | undefined;
+
+  return {
+    resolveRefId(url: string): string | undefined {
+      return urlToRefId.get(url) ?? undefined;
+    },
+
+    async remember(url: string, refId: string): Promise<void> {
+      urlToRefId.set(url, refId);
+      if (sessionDir) {
+        await enqueuePersist(sessionDir, urlToRefId);
+      }
+    },
+
+    async load(dir: string): Promise<void> {
+      sessionDir = dir;
+      const stored = await loadStored(dir);
+      for (const [url, refId] of Object.entries(stored.urlToRefId)) {
+        urlToRefId.set(url, refId);
+      }
+    },
+  };
+}
+
+async function loadStored(dir: string): Promise<StoredRefs> {
+  try {
+    const raw = await readFile(join(dir, STORE_FILE), "utf-8");
+    const parsed = JSON.parse(raw) as StoredRefs;
+    return { urlToRefId: parsed.urlToRefId ?? {} };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { urlToRefId: {} };
+    throw error;
+  }
+}
+
+async function enqueuePersist(dir: string, map: Map<string, string>): Promise<void> {
+  const previous = PERSIST_QUEUES.get(dir) ?? Promise.resolve();
+  const next = previous.catch(() => undefined).then(() => persistMerged(dir, map));
+  PERSIST_QUEUES.set(dir, next);
+  try {
+    await next;
+  } finally {
+    if (PERSIST_QUEUES.get(dir) === next) PERSIST_QUEUES.delete(dir);
+  }
+}
+
+async function persistMerged(dir: string, map: Map<string, string>): Promise<void> {
+  const current = await loadStored(dir);
+  const stored: StoredRefs = {
+    urlToRefId: {
+      ...current.urlToRefId,
+      ...Object.fromEntries(map),
+    },
+  };
+  await writeFile(join(dir, STORE_FILE), JSON.stringify(stored, null, 2), "utf-8");
+}

package/src/transport.ts

@@ -0,0 +1,110 @@
+/**
+ * Codex-faithful HTTP transport.
+ *
+ * Builds the same headers and cookie behavior used by the codex Rust client:
+ * - originator: codex_cli_rs
+ * - User-Agent: codex_cli_rs/{ver} (os ver; arch) terminal
+ * - Authorization: Bearer {token}
+ * - ChatGPT-Account-ID: {account_id}
+ * - ChatGPT Cloudflare cookie store on all outbound/inbound requests
+ */
+
+import { getCodexOriginator, buildCodexUserAgent } from "./ua.ts";
+import { wrapFetchWithCookies, type FetchLike } from "./cookies.ts";
+
+export interface TransportOptions {
+  token: string;
+  accountId: string;
+  baseUrl?: string;
+  fetchImpl?: FetchLike;
+}
+
+export const DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
+export const DEFAULT_CLIENT_VERSION = "1.0.0";
+
+export interface CodexTransport {
+  fetch: FetchLike;
+  baseUrl: string;
+  token: string;
+  accountId: string;
+  buildHeaders(accept: string): Headers;
+  resolveEndpoint(path: "models" | "responses"): string;
+  resolveSearchEndpoint(): string;
+}
+
+export function normalizeCodexBaseUrl(baseUrl: string | undefined): string {
+  const raw = baseUrl?.trim() ? baseUrl : DEFAULT_BASE_URL;
+  let normalized = raw.replace(/\/+$/, "");
+  if (normalized.endsWith("/codex/responses")) {
+    normalized = normalized.slice(0, -"/codex/responses".length);
+  }
+  if (normalized.endsWith("/codex")) {
+    normalized = normalized.slice(0, -"/codex".length);
+  }
+  return normalized;
+}
+
+function isOpenAiRootBaseUrl(baseUrl: string): boolean {
+  try {
+    const url = new URL(baseUrl);
+    return url.hostname === "api.openai.com" && (url.pathname === "" || url.pathname === "/");
+  } catch {
+    return false;
+  }
+}
+
+export function resolveCodexEndpoint(
+  baseUrl: string | undefined,
+  path: "models" | "responses",
+): string {
+  return `${normalizeCodexBaseUrl(baseUrl)}/codex/${path}`;
+}
+
+export function resolveCodexSearchEndpoint(baseUrl: string | undefined): string {
+  const raw = baseUrl?.trim() ? baseUrl : DEFAULT_BASE_URL;
+  let normalized = raw.replace(/\/+$/, "");
+  if (normalized.endsWith("/codex/responses")) {
+    normalized = normalized.slice(0, -"/responses".length);
+  }
+  if (normalized.endsWith("/codex/models")) {
+    normalized = normalized.slice(0, -"/models".length);
+  }
+  if (normalized.endsWith("/codex/alpha/search") || normalized.endsWith("/alpha/search")) {
+    return normalized;
+  }
+  if (normalized.endsWith("/codex")) return `${normalized}/alpha/search`;
+  if (normalized.endsWith("/v1")) return `${normalized}/alpha/search`;
+  if (isOpenAiRootBaseUrl(normalized)) return `${normalized}/v1/alpha/search`;
+  return `${normalized}/codex/alpha/search`;
+}
+
+export function createTransport(options: TransportOptions): CodexTransport {
+  const baseUrl = normalizeCodexBaseUrl(options.baseUrl);
+  const rawFetch: FetchLike = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  const fetch = wrapFetchWithCookies(rawFetch);
+
+  return {
+    fetch,
+    baseUrl,
+    token: options.token,
+    accountId: options.accountId,
+    buildHeaders(accept: string): Headers {
+      const headers = new Headers();
+      headers.set("Authorization", `Bearer ${options.token}`);
+      headers.set("chatgpt-account-id", options.accountId);
+      headers.set("originator", getCodexOriginator());
+      headers.set("accept", accept);
+      if (accept === "text/event-stream") {
+        headers.set("content-type", "application/json");
+      }
+      headers.set("User-Agent", buildCodexUserAgent());
+      return headers;
+    },
+    resolveEndpoint(path) {
+      return resolveCodexEndpoint(baseUrl, path);
+    },
+    resolveSearchEndpoint() {
+      return resolveCodexSearchEndpoint(baseUrl);
+    },
+  };
+}

package/src/ua.ts

@@ -0,0 +1,67 @@
+import { release } from "node:os";
+
+export const DEFAULT_CODEX_VERSION = "0.143.0";
+export const DEFAULT_CODEX_ORIGINATOR = "codex_cli_rs";
+
+function mapPlatform(platform: string): string {
+  switch (platform) {
+    case "darwin":
+      return "Mac OS";
+    case "win32":
+      return "Windows";
+    case "linux":
+      return "Linux";
+    case "freebsd":
+      return "FreeBSD";
+    default:
+      return platform;
+  }
+}
+
+function mapArch(arch: string): string {
+  switch (arch) {
+    case "x64":
+      return "x86_64";
+    case "arm64":
+      return "arm64";
+    case "arm":
+      return "arm";
+    default:
+      return arch;
+  }
+}
+
+function terminalUserAgent(): string {
+  const program = process.env.TERM_PROGRAM;
+  if (program) {
+    const version = process.env.TERM_PROGRAM_VERSION;
+    const suffix = version ? ` ${version}` : "";
+    return `${program}${suffix}`.trim();
+  }
+  if (process.env.WT_SESSION) {
+    return "WindowsTerminal";
+  }
+  if (process.env.KITTY_WINDOW_ID) {
+    return "kitty";
+  }
+  if (process.env.TMUX) {
+    return "tmux";
+  }
+  const term = process.env.TERM;
+  if (term && term !== "dumb") {
+    return term;
+  }
+  return "unknown";
+}
+
+export function buildCodexUserAgent(version = DEFAULT_CODEX_VERSION): string {
+  const osType = mapPlatform(process.platform);
+  const osVersion = release();
+  const arch = mapArch(process.arch);
+  const terminal = terminalUserAgent();
+  return `${DEFAULT_CODEX_ORIGINATOR}/${version} (${osType} ${osVersion}; ${arch}) ${terminal}`;
+}
+
+export function getCodexOriginator(): string {
+  return DEFAULT_CODEX_ORIGINATOR;
+}