pi-codex-search 0.1.1 → 0.1.3

package/src/config.ts

@@ -0,0 +1,287 @@
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { SearchContextSize } from "./codex.ts";
+
+export type SearchApi = "standalone" | "responses";
+
+export type Freshness = "live" | "cached" | "indexed";
+
+export type ConfigScope = "project" | "home";
+
+export interface PiCodexSearchConfig {
+  enabled?: boolean;
+  toolName?: string;
+  model?: string;
+  baseUrl?: string;
+  clientVersion?: string;
+  searchContextSize?: SearchContextSize;
+  freshness?: Freshness;
+  searchApi?: SearchApi;
+  standaloneEnabled?: boolean;
+  batchSize?: number;
+}
+
+export interface ResolvedConfig {
+  enabled: boolean;
+  toolName: string;
+  model?: string;
+  baseUrl?: string;
+  clientVersion?: string;
+  defaultSearchContextSize: SearchContextSize;
+  defaultFreshness: Freshness;
+  searchApi: SearchApi;
+  standaloneEnabled: boolean;
+  batchSize: number;
+  sources: {
+    project?: PiCodexSearchConfig;
+    home?: PiCodexSearchConfig;
+    env?: PiCodexSearchConfig;
+  };
+}
+
+export const DEFAULT_ENABLED = true;
+export const DEFAULT_TOOL_NAME = "codex_search";
+export const DEFAULT_SEARCH_CONTEXT_SIZE: SearchContextSize = "medium";
+export const DEFAULT_FRESHNESS: Freshness = "live";
+export const DEFAULT_SEARCH_API: SearchApi = "responses";
+export const DEFAULT_STANDALONE_ENABLED = false;
+export const STANDALONE_TOOL_NAME = "codex_standalone_web";
+export const DEFAULT_BATCH_SIZE = 5;
+export const CONFIG_FILE_NAME = "pi-codex-search.json";
+const TOOL_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/;
+const CONTEXT_SIZES: readonly SearchContextSize[] = ["low", "medium", "high"] as const;
+const FRESHNESS_VALUES: readonly Freshness[] = ["live", "cached", "indexed"] as const;
+const SEARCH_API_VALUES: readonly SearchApi[] = ["standalone", "responses"] as const;
+export const MIN_BATCH_SIZE = 1;
+export const MAX_BATCH_SIZE = 32;
+
+export function getConfigPath(scope: ConfigScope, cwd: string): string {
+  if (scope === "project") return join(cwd, ".pi", CONFIG_FILE_NAME);
+  return join(homedir(), ".pi", CONFIG_FILE_NAME);
+}
+
+export function isProjectTrustedContext(ctx: unknown): boolean {
+  if (ctx === null || ctx === undefined || typeof ctx !== "object") return true;
+  const maybe = ctx as { isProjectTrusted?: unknown };
+  if (typeof maybe.isProjectTrusted === "boolean") return maybe.isProjectTrusted;
+  if (typeof maybe.isProjectTrusted !== "function") return true;
+  try {
+    return Boolean(maybe.isProjectTrusted());
+  } catch {
+    return false;
+  }
+}
+
+export async function loadConfig(cwd: string, isProjectTrusted = true): Promise<ResolvedConfig> {
+  const homeConfig = await readConfigFile(getConfigPath("home", cwd));
+  const projectConfig = isProjectTrusted
+    ? await readConfigFile(getConfigPath("project", cwd))
+    : undefined;
+  const envConfig = readEnvConfig();
+
+  const merged: PiCodexSearchConfig = {
+    ...homeConfig,
+    ...projectConfig,
+    ...envConfig,
+  };
+
+  const resolved: ResolvedConfig = {
+    enabled: merged.enabled ?? DEFAULT_ENABLED,
+    toolName: merged.toolName ?? DEFAULT_TOOL_NAME,
+    defaultSearchContextSize: merged.searchContextSize ?? DEFAULT_SEARCH_CONTEXT_SIZE,
+    defaultFreshness: merged.freshness ?? DEFAULT_FRESHNESS,
+    searchApi: DEFAULT_SEARCH_API,
+    standaloneEnabled:
+      merged.standaloneEnabled ??
+      (merged.searchApi === "standalone" ? true : DEFAULT_STANDALONE_ENABLED),
+    batchSize: merged.batchSize ?? DEFAULT_BATCH_SIZE,
+    sources: {},
+  };
+  if (merged.model !== undefined) resolved.model = merged.model;
+  if (merged.baseUrl !== undefined) resolved.baseUrl = merged.baseUrl;
+  if (merged.clientVersion !== undefined) resolved.clientVersion = merged.clientVersion;
+  if (homeConfig) resolved.sources.home = homeConfig;
+  if (projectConfig) resolved.sources.project = projectConfig;
+  if (envConfig && Object.keys(envConfig).length > 0) resolved.sources.env = envConfig;
+
+  return resolved;
+}
+
+export async function saveConfig(
+  scope: ConfigScope,
+  cwd: string,
+  config: PiCodexSearchConfig,
+): Promise<string> {
+  validateConfig(config, `<save:${scope}>`);
+  const filePath = getConfigPath(scope, cwd);
+  const clean = stripUndefined(config);
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(clean, null, 2)}\n`, "utf-8");
+  return filePath;
+}
+
+export async function deleteConfig(scope: ConfigScope, cwd: string): Promise<boolean> {
+  const filePath = getConfigPath(scope, cwd);
+  try {
+    await unlink(filePath);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+async function readConfigFile(filePath: string): Promise<PiCodexSearchConfig | undefined> {
+  let raw: string;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw new Error(`Failed to read ${filePath}: ${(error as Error).message}`);
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON in ${filePath}: ${(error as Error).message}`);
+  }
+  if (!isPlainObject(parsed)) {
+    throw new Error(`Invalid config in ${filePath}: expected a JSON object`);
+  }
+  const config = parsed as PiCodexSearchConfig;
+  validateConfig(config, filePath);
+  return config;
+}
+
+function readEnvConfig(): PiCodexSearchConfig | undefined {
+  const env: PiCodexSearchConfig = {};
+  const enabled = booleanEnv("PI_CODEX_WEB_SEARCH_ENABLED");
+  if (enabled !== undefined) env.enabled = enabled;
+  const toolName = trimmedEnv("PI_CODEX_WEB_SEARCH_TOOL_NAME");
+  if (toolName !== undefined) env.toolName = toolName;
+  const model = trimmedEnv("PI_CODEX_WEB_SEARCH_MODEL");
+  if (model !== undefined) env.model = model;
+  const baseUrl = trimmedEnv("PI_CODEX_WEB_SEARCH_BASE_URL");
+  if (baseUrl !== undefined) env.baseUrl = baseUrl;
+  const clientVersion = trimmedEnv("PI_CODEX_WEB_SEARCH_CLIENT_VERSION");
+  if (clientVersion !== undefined) env.clientVersion = clientVersion;
+  const searchContextSize = trimmedEnv("PI_CODEX_WEB_SEARCH_CONTEXT_SIZE");
+  if (searchContextSize !== undefined) {
+    env.searchContextSize = searchContextSize as SearchContextSize;
+  }
+  const freshness = trimmedEnv("PI_CODEX_WEB_SEARCH_FRESHNESS");
+  if (freshness !== undefined) env.freshness = freshness as Freshness;
+  const searchApi = trimmedEnv("PI_CODEX_WEB_SEARCH_API");
+  if (searchApi !== undefined) env.searchApi = searchApi as SearchApi;
+  const standaloneEnabled = booleanEnv("PI_CODEX_WEB_STANDALONE_ENABLED");
+  if (standaloneEnabled !== undefined) env.standaloneEnabled = standaloneEnabled;
+  const batchSize = integerEnv("PI_CODEX_WEB_SEARCH_BATCH_SIZE");
+  if (batchSize !== undefined) env.batchSize = batchSize;
+
+  if (Object.keys(env).length === 0) return undefined;
+  validateConfig(env, "<env>");
+  return env;
+}
+
+function validateConfig(config: PiCodexSearchConfig, sourceLabel: string): void {
+  if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
+    throw new Error(
+      `Invalid enabled in ${sourceLabel}: ${JSON.stringify(config.enabled)}. Must be a boolean.`,
+    );
+  }
+  if (config.toolName !== undefined && !TOOL_NAME_PATTERN.test(config.toolName)) {
+    throw new Error(
+      `Invalid toolName in ${sourceLabel}: ${JSON.stringify(config.toolName)}. ` +
+        `Must match ${TOOL_NAME_PATTERN.source}.`,
+    );
+  }
+  if (config.model !== undefined && !isNonEmptyString(config.model)) {
+    throw new Error(`Invalid model in ${sourceLabel}: must be a non-empty string.`);
+  }
+  if (config.baseUrl !== undefined && !isNonEmptyString(config.baseUrl)) {
+    throw new Error(`Invalid baseUrl in ${sourceLabel}: must be a non-empty string.`);
+  }
+  if (config.clientVersion !== undefined && !isNonEmptyString(config.clientVersion)) {
+    throw new Error(`Invalid clientVersion in ${sourceLabel}: must be a non-empty string.`);
+  }
+  if (config.searchContextSize !== undefined && !CONTEXT_SIZES.includes(config.searchContextSize)) {
+    throw new Error(
+      `Invalid searchContextSize in ${sourceLabel}: ${JSON.stringify(config.searchContextSize)}. ` +
+        `Expected one of ${CONTEXT_SIZES.join(", ")}.`,
+    );
+  }
+  if (config.freshness !== undefined && !FRESHNESS_VALUES.includes(config.freshness)) {
+    throw new Error(
+      `Invalid freshness in ${sourceLabel}: ${JSON.stringify(config.freshness)}. ` +
+        `Expected one of ${FRESHNESS_VALUES.join(", ")}.`,
+    );
+  }
+  if (config.standaloneEnabled !== undefined && typeof config.standaloneEnabled !== "boolean") {
+    throw new Error(
+      `Invalid standaloneEnabled in ${sourceLabel}: ${JSON.stringify(config.standaloneEnabled)}. Must be a boolean.`,
+    );
+  }
+  if (config.searchApi !== undefined && !SEARCH_API_VALUES.includes(config.searchApi)) {
+    throw new Error(
+      `Invalid searchApi in ${sourceLabel}: ${JSON.stringify(config.searchApi)}. ` +
+        `Expected one of ${SEARCH_API_VALUES.join(", ")}.`,
+    );
+  }
+  if (config.batchSize !== undefined) {
+    if (
+      !Number.isInteger(config.batchSize) ||
+      config.batchSize < MIN_BATCH_SIZE ||
+      config.batchSize > MAX_BATCH_SIZE
+    ) {
+      throw new Error(
+        `Invalid batchSize in ${sourceLabel}: ${JSON.stringify(config.batchSize)}. ` +
+          `Expected an integer between ${MIN_BATCH_SIZE} and ${MAX_BATCH_SIZE}.`,
+      );
+    }
+  }
+}
+
+function trimmedEnv(name: string): string | undefined {
+  const raw = process.env[name];
+  if (raw === undefined) return undefined;
+  const trimmed = raw.trim();
+  return trimmed.length === 0 ? undefined : trimmed;
+}
+
+function booleanEnv(name: string): boolean | undefined {
+  const raw = trimmedEnv(name);
+  if (raw === undefined) return undefined;
+  const lower = raw.toLowerCase();
+  if (lower === "true") return true;
+  if (lower === "false") return false;
+  throw new Error(`Invalid ${name}: ${JSON.stringify(raw)}. Expected 'true' or 'false'.`);
+}
+
+function integerEnv(name: string): number | undefined {
+  const raw = trimmedEnv(name);
+  if (raw === undefined) return undefined;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed)) {
+    throw new Error(`Invalid ${name}: ${JSON.stringify(raw)}. Expected an integer.`);
+  }
+  return parsed;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function stripUndefined(config: PiCodexSearchConfig): PiCodexSearchConfig {
+  const clean: PiCodexSearchConfig = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== undefined) {
+      (clean as Record<string, unknown>)[key] = value;
+    }
+  }
+  return clean;
+}

package/src/cookies.ts

@@ -0,0 +1,131 @@
+/**
+ * Process-local Cloudflare cookie store for ChatGPT endpoints.
+ *
+ * Mirrors the constraints in codex chatgpt_cloudflare_cookies.rs:
+ * - HTTPS only
+ * - ChatGPT host allowlist
+ * - Cloudflare infrastructure cookie name allowlist only
+ * - Never store account/session/auth cookies
+ */
+
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+interface Cookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  secure: boolean;
+}
+
+const ALLOWED_HOSTS = ["chatgpt.com", "chat.openai.com", "chatgpt-staging.com"];
+const HOST_SUFFIXES = [".chatgpt.com", ".chatgpt-staging.com"];
+
+const ALLOWED_COOKIE_NAMES = new Set([
+  "__cf_bm",
+  "__cflb",
+  "__cfruid",
+  "__cfseq",
+  "__cfwaitingroom",
+  "_cfuvid",
+  "cf_clearance",
+  "cf_ob_info",
+  "cf_use_ob",
+]);
+
+function isAllowedHost(host: string): boolean {
+  if (ALLOWED_HOSTS.includes(host)) return true;
+  return HOST_SUFFIXES.some((suffix) => host.endsWith(suffix));
+}
+
+function isAllowedCookieName(name: string): boolean {
+  if (ALLOWED_COOKIE_NAMES.has(name)) return true;
+  return name.startsWith("cf_chl_");
+}
+
+function parseSetCookieHeader(header: string, url: URL): Cookie | undefined {
+  const [firstPart] = header.split(";");
+  if (!firstPart) return undefined;
+  const eqIndex = firstPart.indexOf("=");
+  if (eqIndex <= 0) return undefined;
+  const name = firstPart.slice(0, eqIndex).trim();
+  const value = firstPart.slice(eqIndex + 1).trim();
+  if (!isAllowedCookieName(name)) return undefined;
+  return {
+    name,
+    value,
+    domain: url.hostname,
+    path: "/",
+    secure: true,
+  };
+}
+
+function cookieKey(cookie: Cookie): string {
+  return `${cookie.domain}:${cookie.path}:${cookie.name}`;
+}
+
+export class ChatGptCloudflareCookieStore {
+  private cookies = new Map<string, Cookie>();
+
+  setCookies(setCookieHeaders: string[], url: URL): void {
+    if (url.protocol !== "https:") return;
+    if (!isAllowedHost(url.hostname)) return;
+    for (const header of setCookieHeaders) {
+      const cookie = parseSetCookieHeader(header, url);
+      if (cookie) {
+        this.cookies.set(cookieKey(cookie), cookie);
+      }
+    }
+  }
+
+  cookiesForUrl(url: URL): string | undefined {
+    if (url.protocol !== "https:") return undefined;
+    if (!isAllowedHost(url.hostname)) return undefined;
+    const parts: string[] = [];
+    for (const cookie of this.cookies.values()) {
+      if (cookie.domain === url.hostname) {
+        parts.push(`${cookie.name}=${cookie.value}`);
+      }
+    }
+    return parts.length > 0 ? parts.join("; ") : undefined;
+  }
+}
+
+const SHARED_STORE = new ChatGptCloudflareCookieStore();
+
+export function getSharedCookieStore(): ChatGptCloudflareCookieStore {
+  return SHARED_STORE;
+}
+
+export function wrapFetchWithCookies(fetchImpl: FetchLike): FetchLike {
+  return async (input, init) => {
+    const url = new URL(
+      typeof input === "string" ? input : input instanceof URL ? input.href : input.url,
+    );
+    const cookieHeader = SHARED_STORE.cookiesForUrl(url);
+    const headers = new Headers(input instanceof Request ? input.headers : undefined);
+    new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
+    if (cookieHeader) {
+      const existing = headers.get("cookie");
+      headers.set("cookie", existing ? `${existing}; ${cookieHeader}` : cookieHeader);
+    }
+
+    const response = await fetchImpl(input, { ...init, headers });
+
+    const setCookie =
+      response.headers.getSetCookie?.() ?? parseSetCookieLegacy(response.headers.get("set-cookie"));
+    if (setCookie.length > 0) {
+      SHARED_STORE.setCookies(setCookie, url);
+    }
+    return response;
+  };
+}
+
+function parseSetCookieLegacy(value: string | null): string[] {
+  if (!value) return [];
+  // Split on comma, but Set-Cookie values rarely contain bare commas in CF cookies.
+  return value
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}

package/src/errors.ts

@@ -0,0 +1,56 @@
+export type CodexErrorKind = "auth" | "rate_limit" | "transport" | "timeout" | "schema" | "unknown";
+
+export class CodexError extends Error {
+  readonly kind: CodexErrorKind;
+  readonly status?: number;
+
+  constructor(kind: CodexErrorKind, message: string, status?: number) {
+    super(message);
+    this.name = "CodexError";
+    this.kind = kind;
+    if (status !== undefined) this.status = status;
+  }
+}
+
+export function classifyError(error: unknown): CodexErrorKind {
+  if (error instanceof CodexError) return error.kind;
+  if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    return "timeout";
+  }
+  return "unknown";
+}
+
+export function classifyHttpStatus(status: number): CodexErrorKind {
+  if (status === 401 || status === 403) return "auth";
+  if (status === 429) return "rate_limit";
+  return "transport";
+}
+
+export function formatHttpErrorBody(text: string, mode: "responses" | "standalone"): string {
+  if (isCloudflareChallenge(text)) {
+    const advice =
+      mode === "standalone"
+        ? "Use codex_search for search, or retry after Codex/ChatGPT has refreshed its Cloudflare clearance."
+        : "Retry after Codex/ChatGPT has refreshed its Cloudflare clearance.";
+    return `Cloudflare challenge blocked the Codex request. ${advice}`;
+  }
+  return text;
+}
+
+export function isCloudflareChallenge(text: string): boolean {
+  const lower = text.toLowerCase();
+  return (
+    lower.includes("/cdn-cgi/challenge-platform/") ||
+    lower.includes("cf_chl_") ||
+    lower.includes("enable javascript and cookies to continue")
+  );
+}
+
+export function classifyEventErrorMessage(message: string): CodexErrorKind {
+  const lower = message.toLowerCase();
+  if (/rate[- ]?limit|too many requests|quota|429/.test(lower)) return "rate_limit";
+  if (/auth|unauthori[sz]ed|forbidden|401|403/.test(lower)) return "auth";
+  if (/timeout|timed out/.test(lower)) return "timeout";
+  if (/network|connection|disconnect|transport|fetch failed/.test(lower)) return "transport";
+  return "unknown";
+}