@gakr-gakr/codex 0.1.0 → 0.1.1

package/src/app-server/image-payload-sanitizer.ts

@@ -1,167 +0,0 @@
-const DATA_URL_PREFIX = "data:";
-const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
-
-function startsWithDataUrl(value: string): boolean {
-  return value.slice(0, DATA_URL_PREFIX.length).toLowerCase() === DATA_URL_PREFIX;
-}
-
-function canonicalizeBase64(base64: string): string | undefined {
-  let cleaned = "";
-  let padding = 0;
-  let sawPadding = false;
-  for (let i = 0; i < base64.length; i += 1) {
-    const code = base64.charCodeAt(i);
-    if (code <= 0x20) {
-      continue;
-    }
-    if (code === 0x3d) {
-      padding += 1;
-      if (padding > 2) {
-        return undefined;
-      }
-      sawPadding = true;
-      cleaned += "=";
-      continue;
-    }
-    const isBase64DataChar =
-      (code >= 0x41 && code <= 0x5a) ||
-      (code >= 0x61 && code <= 0x7a) ||
-      (code >= 0x30 && code <= 0x39) ||
-      code === 0x2b ||
-      code === 0x2f;
-    if (sawPadding || !isBase64DataChar) {
-      return undefined;
-    }
-    cleaned += base64[i];
-  }
-  if (!cleaned || cleaned.length % 4 !== 0) {
-    return undefined;
-  }
-  return cleaned;
-}
-
-function sniffImageMime(buffer: Buffer): string | undefined {
-  if (
-    buffer.length >= 8 &&
-    buffer[0] === 0x89 &&
-    buffer[1] === 0x50 &&
-    buffer[2] === 0x4e &&
-    buffer[3] === 0x47 &&
-    buffer[4] === 0x0d &&
-    buffer[5] === 0x0a &&
-    buffer[6] === 0x1a &&
-    buffer[7] === 0x0a
-  ) {
-    return "image/png";
-  }
-  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
-    return "image/jpeg";
-  }
-  if (
-    buffer.length >= 12 &&
-    buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
-    buffer.subarray(8, 12).toString("ascii") === "WEBP"
-  ) {
-    return "image/webp";
-  }
-  if (
-    buffer.length >= 6 &&
-    (buffer.subarray(0, 6).toString("ascii") === "GIF87a" ||
-      buffer.subarray(0, 6).toString("ascii") === "GIF89a")
-  ) {
-    return "image/gif";
-  }
-  return undefined;
-}
-
-export function sanitizeInlineImageDataUrl(imageUrl: string): string | undefined {
-  if (!startsWithDataUrl(imageUrl)) {
-    return imageUrl;
-  }
-  const commaIndex = imageUrl.indexOf(",");
-  if (commaIndex < 0) {
-    return undefined;
-  }
-
-  const metadata = imageUrl.slice(DATA_URL_PREFIX.length, commaIndex);
-  const payload = imageUrl.slice(commaIndex + 1);
-  const metadataParts = metadata.split(";").map((part) => part.trim());
-  const declaredMimeType = metadataParts[0]?.toLowerCase();
-  if (!declaredMimeType?.startsWith("image/")) {
-    return undefined;
-  }
-  if (!metadataParts.slice(1).some((part) => part.toLowerCase() === "base64")) {
-    return undefined;
-  }
-
-  const canonicalPayload = canonicalizeBase64(payload);
-  if (!canonicalPayload) {
-    return undefined;
-  }
-  const sniffedMimeType = sniffImageMime(Buffer.from(canonicalPayload, "base64"));
-  if (!sniffedMimeType) {
-    return undefined;
-  }
-  return `data:${sniffedMimeType};base64,${canonicalPayload}`;
-}
-
-export function invalidInlineImageText(label: string): string {
-  return `[${label}] ${IMAGE_OMITTED_TEXT}`;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-function sanitizeImageContentRecord(
-  record: Record<string, unknown>,
-  label: string,
-): Record<string, unknown> | undefined {
-  if (record.type === "image" && typeof record.data === "string") {
-    const mimeType = typeof record.mimeType === "string" ? record.mimeType : "image/png";
-    const imageUrl = sanitizeInlineImageDataUrl(`data:${mimeType};base64,${record.data}`);
-    if (!imageUrl) {
-      return { type: "text", text: invalidInlineImageText(label) };
-    }
-    const commaIndex = imageUrl.indexOf(",");
-    const metadata = imageUrl.slice(DATA_URL_PREFIX.length, commaIndex);
-    const mime = metadata.split(";")[0] ?? mimeType;
-    return { ...record, mimeType: mime, data: imageUrl.slice(commaIndex + 1) };
-  }
-
-  if (record.type === "inputImage" && typeof record.imageUrl === "string") {
-    const imageUrl = sanitizeInlineImageDataUrl(record.imageUrl);
-    return imageUrl
-      ? { ...record, imageUrl }
-      : { type: "inputText", text: invalidInlineImageText(label) };
-  }
-
-  if (record.type === "input_image" && typeof record.image_url === "string") {
-    const imageUrl = sanitizeInlineImageDataUrl(record.image_url);
-    return imageUrl
-      ? { ...record, image_url: imageUrl }
-      : { type: "input_text", text: invalidInlineImageText(label) };
-  }
-
-  return undefined;
-}
-
-export function sanitizeCodexHistoryImagePayloads<T>(value: T, label: string): T {
-  if (Array.isArray(value)) {
-    return value.map((entry) => sanitizeCodexHistoryImagePayloads(entry, label)) as T;
-  }
-  if (!isRecord(value)) {
-    return value;
-  }
-
-  const imageRecord = sanitizeImageContentRecord(value, label);
-  if (imageRecord) {
-    return imageRecord as T;
-  }
-
-  const next: Record<string, unknown> = {};
-  for (const [key, child] of Object.entries(value)) {
-    next[key] = sanitizeCodexHistoryImagePayloads(child, label);
-  }
-  return next as T;
-}

package/src/app-server/local-runtime-attribution.ts

@@ -1,39 +0,0 @@
-import type { EmbeddedRunAttemptParams } from "autobot/plugin-sdk/agent-harness-runtime";
-
-const OPENAI_PROVIDER_ID = "openai";
-const OPENAI_RESPONSES_API = "openai-responses";
-const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
-const OPENAI_CODEX_RESPONSES_API = "openai-codex-responses";
-
-export type CodexLocalRuntimeAttribution = {
-  provider: string;
-  api?: string;
-};
-
-function normalizeRuntimeId(value: string | undefined): string {
-  return value?.trim().toLowerCase() ?? "";
-}
-
-export function resolveCodexLocalRuntimeAttribution(
-  params: EmbeddedRunAttemptParams,
-): CodexLocalRuntimeAttribution {
-  const authProfileProvider = normalizeRuntimeId(
-    params.runtimePlan?.auth?.authProfileProviderForAuth,
-  );
-  if (
-    normalizeRuntimeId(params.runtimePlan?.observability.harnessId) === "codex" &&
-    authProfileProvider !== OPENAI_PROVIDER_ID &&
-    normalizeRuntimeId(params.model.provider) === OPENAI_PROVIDER_ID &&
-    normalizeRuntimeId(params.model.api) === OPENAI_RESPONSES_API
-  ) {
-    return {
-      provider: OPENAI_CODEX_PROVIDER_ID,
-      api: OPENAI_CODEX_RESPONSES_API,
-    };
-  }
-
-  return {
-    provider: params.provider,
-    api: params.model.api,
-  };
-}

package/src/app-server/managed-binary.ts

@@ -1,193 +0,0 @@
-import { constants as fsConstants, readFileSync } from "node:fs";
-import { access } from "node:fs/promises";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import type { CodexAppServerStartOptions } from "./config.js";
-import { MANAGED_CODEX_APP_SERVER_PACKAGE } from "./version.js";
-
-const CODEX_APP_SERVER_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-const CODEX_PLUGIN_ROOT = resolveDefaultCodexPluginRoot(CODEX_APP_SERVER_MODULE_DIR);
-
-type ManagedCodexAppServerPaths = {
-  commandPath: string;
-  candidateCommandPaths: string[];
-};
-
-type ResolveManagedCodexAppServerOptions = {
-  platform?: NodeJS.Platform;
-  pluginRoot?: string;
-  pathExists?: (filePath: string, platform: NodeJS.Platform) => Promise<boolean>;
-};
-
-export async function resolveManagedCodexAppServerStartOptions(
-  startOptions: CodexAppServerStartOptions,
-  options: ResolveManagedCodexAppServerOptions = {},
-): Promise<CodexAppServerStartOptions> {
-  if (startOptions.transport !== "stdio" || startOptions.commandSource !== "managed") {
-    return startOptions;
-  }
-
-  const platform = options.platform ?? process.platform;
-  const paths = resolveManagedCodexAppServerPaths({
-    platform,
-    pluginRoot: options.pluginRoot,
-  });
-  const pathExists = options.pathExists ?? commandPathExists;
-  const commandPath = await findManagedCodexAppServerCommandPath({
-    candidateCommandPaths: paths.candidateCommandPaths,
-    pathExists,
-    platform,
-  });
-
-  return {
-    ...startOptions,
-    command: commandPath,
-    commandSource: "resolved-managed",
-  };
-}
-
-export function resolveManagedCodexAppServerPaths(params: {
-  platform?: NodeJS.Platform;
-  pluginRoot?: string;
-}): ManagedCodexAppServerPaths {
-  const platform = params.platform ?? process.platform;
-  const candidateCommandPaths = resolveManagedCodexAppServerCommandCandidates(
-    params.pluginRoot ?? CODEX_PLUGIN_ROOT,
-    platform,
-  );
-  return {
-    commandPath: candidateCommandPaths[0] ?? "",
-    candidateCommandPaths,
-  };
-}
-
-function resolveManagedCodexAppServerCommandCandidates(
-  pluginRoot: string,
-  platform: NodeJS.Platform,
-): string[] {
-  const pathApi = pathForPlatform(platform);
-  const commandName = platform === "win32" ? "codex.cmd" : "codex";
-  const roots = resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform);
-  return [
-    ...new Set([
-      ...roots.map((root) => pathApi.join(root, "node_modules", ".bin", commandName)),
-      ...resolveManagedCodexPackageBinCandidates(roots, platform),
-    ]),
-  ];
-}
-
-function resolveDefaultCodexPluginRoot(moduleDir: string): string {
-  const moduleBaseName = path.basename(moduleDir);
-  if (moduleBaseName === "dist" || moduleBaseName === "dist-runtime") {
-    return path.dirname(moduleDir);
-  }
-  return path.resolve(moduleDir, "..", "..");
-}
-
-function resolveManagedCodexAppServerCandidateRoots(
-  pluginRoot: string,
-  platform: NodeJS.Platform,
-): string[] {
-  const pathApi = pathForPlatform(platform);
-  return [
-    pluginRoot,
-    pathApi.dirname(pluginRoot),
-    pathApi.dirname(pathApi.dirname(pluginRoot)),
-    isDistExtensionRoot(pluginRoot, platform)
-      ? pathApi.dirname(pathApi.dirname(pathApi.dirname(pluginRoot)))
-      : null,
-  ].filter((root): root is string => Boolean(root));
-}
-
-function resolveManagedCodexPackageBinCandidates(
-  roots: readonly string[],
-  platform: NodeJS.Platform,
-): string[] {
-  if (platform === "win32") {
-    return [];
-  }
-
-  const candidates: string[] = [];
-  for (const root of roots) {
-    const candidate = resolveManagedCodexPackageBinCandidate(root);
-    if (candidate) {
-      candidates.push(candidate);
-    }
-  }
-  return candidates;
-}
-
-function resolveManagedCodexPackageBinCandidate(root: string): string | null {
-  try {
-    const requireFromRoot = createRequire(path.join(root, "package.json"));
-    const packageJsonPath = requireFromRoot.resolve(
-      `${MANAGED_CODEX_APP_SERVER_PACKAGE}/package.json`,
-    );
-    const packageRoot = path.dirname(packageJsonPath);
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
-      bin?: unknown;
-    };
-    const binPath =
-      typeof packageJson.bin === "string"
-        ? packageJson.bin
-        : isRecord(packageJson.bin) && typeof packageJson.bin.codex === "string"
-          ? packageJson.bin.codex
-          : null;
-    return binPath ? path.resolve(packageRoot, binPath) : null;
-  } catch {
-    return null;
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-export const testing = {
-  resolveDefaultCodexPluginRoot,
-};
-
-function isDistExtensionRoot(pluginRoot: string, platform: NodeJS.Platform): boolean {
-  const pathApi = pathForPlatform(platform);
-  const extensionsDir = pathApi.dirname(pluginRoot);
-  const distDir = pathApi.dirname(extensionsDir);
-  return (
-    pathApi.basename(extensionsDir) === "extensions" &&
-    (pathApi.basename(distDir) === "dist" || pathApi.basename(distDir) === "dist-runtime")
-  );
-}
-
-function pathForPlatform(platform: NodeJS.Platform): typeof path {
-  return platform === "win32" ? path.win32 : path.posix;
-}
-
-async function findManagedCodexAppServerCommandPath(params: {
-  candidateCommandPaths: readonly string[];
-  pathExists: (filePath: string, platform: NodeJS.Platform) => Promise<boolean>;
-  platform: NodeJS.Platform;
-}): Promise<string> {
-  for (const commandPath of params.candidateCommandPaths) {
-    if (await params.pathExists(commandPath, params.platform)) {
-      return commandPath;
-    }
-  }
-
-  throw new Error(
-    [
-      `Managed Codex app-server binary was not found for ${MANAGED_CODEX_APP_SERVER_PACKAGE}.`,
-      "Reinstall or update AutoBot, or run pnpm install in a source checkout.",
-      "Set plugins.entries.codex.config.appServer.command or AUTOBOT_CODEX_APP_SERVER_BIN to use a custom Codex binary.",
-    ].join(" "),
-  );
-}
-
-async function commandPathExists(filePath: string, platform: NodeJS.Platform): Promise<boolean> {
-  try {
-    await access(filePath, platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-export { testing as __testing };

package/src/app-server/models.ts

@@ -1,172 +0,0 @@
-import type { resolveCodexAppServerAuthProfileIdForAgent } from "./auth-bridge.js";
-import type { CodexAppServerClient } from "./client.js";
-import type { CodexAppServerStartOptions } from "./config.js";
-import { readCodexModelListResponse } from "./protocol-validators.js";
-import type { CodexModel, CodexReasoningEffortOption } from "./protocol.js";
-
-export type CodexAppServerModel = {
-  id: string;
-  model: string;
-  displayName?: string;
-  description?: string;
-  hidden?: boolean;
-  isDefault?: boolean;
-  inputModalities: string[];
-  supportedReasoningEfforts: string[];
-  defaultReasoningEffort?: string;
-};
-
-export type CodexAppServerModelListResult = {
-  models: CodexAppServerModel[];
-  nextCursor?: string;
-  truncated?: boolean;
-};
-
-export type CodexAppServerListModelsOptions = {
-  limit?: number;
-  cursor?: string;
-  includeHidden?: boolean;
-  timeoutMs?: number;
-  startOptions?: CodexAppServerStartOptions;
-  authProfileId?: string;
-  agentDir?: string;
-  config?: Parameters<typeof resolveCodexAppServerAuthProfileIdForAgent>[0]["config"];
-  sharedClient?: boolean;
-};
-
-export async function listCodexAppServerModels(
-  options: CodexAppServerListModelsOptions = {},
-): Promise<CodexAppServerModelListResult> {
-  return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) =>
-    requestModelListPage(client, { ...options, timeoutMs }),
-  );
-}
-
-export async function listAllCodexAppServerModels(
-  options: CodexAppServerListModelsOptions & { maxPages?: number } = {},
-): Promise<CodexAppServerModelListResult> {
-  const maxPages = normalizeMaxPages(options.maxPages);
-  return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
-    const models: CodexAppServerModel[] = [];
-    let cursor = options.cursor;
-    let nextCursor: string | undefined;
-    for (let page = 0; page < maxPages; page += 1) {
-      const result = await requestModelListPage(client, {
-        ...options,
-        timeoutMs,
-        cursor,
-      });
-      models.push(...result.models);
-      nextCursor = result.nextCursor;
-      if (!nextCursor) {
-        return { models };
-      }
-      cursor = nextCursor;
-    }
-    return { models, nextCursor, truncated: true };
-  });
-}
-
-async function withCodexAppServerModelClient<T>(
-  options: CodexAppServerListModelsOptions,
-  run: (params: { client: CodexAppServerClient; timeoutMs: number }) => Promise<T>,
-): Promise<T> {
-  const timeoutMs = options.timeoutMs ?? 2500;
-  const useSharedClient = options.sharedClient !== false;
-  const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } =
-    await import("./shared-client.js");
-  const client = useSharedClient
-    ? await getSharedCodexAppServerClient({
-        startOptions: options.startOptions,
-        timeoutMs,
-        authProfileId: options.authProfileId,
-        agentDir: options.agentDir,
-        config: options.config,
-      })
-    : await createIsolatedCodexAppServerClient({
-        startOptions: options.startOptions,
-        timeoutMs,
-        authProfileId: options.authProfileId,
-        agentDir: options.agentDir,
-        config: options.config,
-      });
-  try {
-    return await run({ client, timeoutMs });
-  } finally {
-    if (!useSharedClient) {
-      client.close();
-    }
-  }
-}
-
-async function requestModelListPage(
-  client: CodexAppServerClient,
-  options: CodexAppServerListModelsOptions & { timeoutMs: number },
-): Promise<CodexAppServerModelListResult> {
-  const response = await client.request(
-    "model/list",
-    {
-      limit: options.limit ?? null,
-      cursor: options.cursor ?? null,
-      includeHidden: options.includeHidden ?? null,
-    },
-    { timeoutMs: options.timeoutMs },
-  );
-  return readModelListResult(response);
-}
-
-export function readModelListResult(value: unknown): CodexAppServerModelListResult {
-  const response = readCodexModelListResponse(value);
-  if (!response) {
-    return { models: [] };
-  }
-  const models = response.data
-    .map((entry) => readCodexModel(entry))
-    .filter((entry): entry is CodexAppServerModel => entry !== undefined);
-  const nextCursor = response.nextCursor ?? undefined;
-  return { models, ...(nextCursor ? { nextCursor } : {}) };
-}
-
-function readCodexModel(value: CodexModel): CodexAppServerModel | undefined {
-  const id = readNonEmptyString(value.id);
-  const model = readNonEmptyString(value.model) ?? id;
-  if (!id || !model) {
-    return undefined;
-  }
-  return {
-    id,
-    model,
-    ...(readNonEmptyString(value.displayName)
-      ? { displayName: readNonEmptyString(value.displayName) }
-      : {}),
-    ...(readNonEmptyString(value.description)
-      ? { description: readNonEmptyString(value.description) }
-      : {}),
-    hidden: value.hidden,
-    isDefault: value.isDefault,
-    inputModalities: value.inputModalities,
-    supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
-    ...(readNonEmptyString(value.defaultReasoningEffort)
-      ? { defaultReasoningEffort: readNonEmptyString(value.defaultReasoningEffort) }
-      : {}),
-  };
-}
-
-function readReasoningEfforts(value: CodexReasoningEffortOption[]): string[] {
-  const efforts = value
-    .map((entry) => readNonEmptyString(entry.reasoningEffort))
-    .filter((entry): entry is string => entry !== undefined);
-  return [...new Set(efforts)];
-}
-
-function readNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed || undefined;
-}
-
-function normalizeMaxPages(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;
-}