@workbench-ai/agent-driver-openai-codex 0.0.44

package/dist/integrations.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderIntegrationCatalog, ProviderIntegrationUpdate } from "@workbench-ai/agent-driver";
+export declare function listCodexIntegrations(codexHomeDir: string): Promise<ProviderIntegrationCatalog>;
+export declare function updateCodexIntegrations(args: {
+    codexHomeDir: string;
+    update: ProviderIntegrationUpdate;
+}): Promise<ProviderIntegrationCatalog>;
+export declare function projectCodexIntegrations(args: {
+    sourceCodexHomeDir: string;
+    targetCodexHomeDir: string;
+}): Promise<void>;
+export declare function clearCodexLegacySkillRoots(codexHomeDir: string): Promise<void>;
+//# sourceMappingURL=integrations.d.ts.map

package/dist/integrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../src/integrations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,0BAA0B,EAE1B,yBAAyB,EAC1B,MAAM,4BAA4B,CAAC;AAYpC,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,0BAA0B,CAAC,CAOrC;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,yBAAyB,CAAC;CACnC,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAStC;AAED,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;CAC5B,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhB;AAED,wBAAsB,0BAA0B,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKpF"}

package/dist/integrations.js

@@ -0,0 +1,233 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function listCodexIntegrations(codexHomeDir) {
+    const integrations = await listCodexMcpIntegrations(codexHomeDir);
+    return {
+        providerId: "openai/codex",
+        providerLabel: "OpenAI Codex",
+        integrations: integrations.map(toIntegrationEntry),
+    };
+}
+export async function updateCodexIntegrations(args) {
+    const integrations = await listCodexMcpIntegrations(args.codexHomeDir);
+    validateRequestedIds(integrations, args.update.enabledIds);
+    await applyCodexIntegrationSelection(args.codexHomeDir, integrations, new Set(args.update.enabledIds));
+    return await listCodexIntegrations(args.codexHomeDir);
+}
+export async function projectCodexIntegrations(args) {
+    const integrations = await listCodexMcpIntegrations(args.sourceCodexHomeDir);
+    await appendEnabledCodexMcpServers(args.sourceCodexHomeDir, args.targetCodexHomeDir, integrations.filter((integration) => integration.enabled));
+}
+export async function clearCodexLegacySkillRoots(codexHomeDir) {
+    await Promise.all([
+        fs.rm(path.join(codexHomeDir, "skills"), { recursive: true, force: true }),
+        fs.rm(path.join(codexHomeDir, ".disabled-skills"), { recursive: true, force: true }),
+    ]);
+}
+function toIntegrationEntry(integration) {
+    return {
+        id: integration.id,
+        label: integration.label,
+        enabled: integration.enabled,
+    };
+}
+async function listCodexMcpIntegrations(codexHomeDir) {
+    const configPath = path.join(codexHomeDir, "config.toml");
+    const raw = await readFileOrEmpty(configPath);
+    if (!raw.trim()) {
+        return [];
+    }
+    const lines = raw.split(/\n/u);
+    const sections = parseTomlSections(lines);
+    const groups = new Map();
+    for (const section of sections) {
+        if (section.path[0] !== "mcp_servers" || !section.path[1]) {
+            continue;
+        }
+        const integrationId = section.path[1];
+        const existing = groups.get(integrationId) ?? {
+            id: integrationId,
+            label: integrationId,
+            enabled: true,
+            ranges: [],
+        };
+        existing.ranges.push({
+            start: section.start,
+            end: section.end,
+        });
+        if (section.path.length === 2) {
+            existing.enabled = parseCodexMcpEnabled(lines, section.start, section.end);
+        }
+        groups.set(integrationId, existing);
+    }
+    return [...groups.values()].sort((left, right) => left.label.localeCompare(right.label));
+}
+async function applyCodexIntegrationSelection(codexHomeDir, integrations, enabledIds) {
+    const configPath = path.join(codexHomeDir, "config.toml");
+    const raw = await readFileOrEmpty(configPath);
+    const lines = raw.split(/\n/u);
+    const sections = parseTomlSections(lines);
+    const rootRanges = integrations
+        .map((integration) => {
+        const range = sections.find((section) => section.path[0] === "mcp_servers" &&
+            section.path[1] === integration.id &&
+            section.path.length === 2);
+        return range ? { integration, range } : null;
+    })
+        .filter((entry) => entry !== null)
+        .sort((left, right) => right.range.start - left.range.start);
+    for (const entry of rootRanges) {
+        const shouldEnable = enabledIds.has(entry.integration.id);
+        const updatedSection = setCodexMcpEnabled(lines.slice(entry.range.start, entry.range.end + 1), shouldEnable);
+        lines.splice(entry.range.start, entry.range.end - entry.range.start + 1, ...updatedSection);
+    }
+    await fs.mkdir(codexHomeDir, { recursive: true });
+    await fs.writeFile(configPath, `${trimTrailingEmptyLines(lines).join("\n")}\n`, "utf8");
+}
+async function appendEnabledCodexMcpServers(sourceCodexHomeDir, targetCodexHomeDir, enabledIntegrations) {
+    if (enabledIntegrations.length === 0) {
+        return;
+    }
+    const sourceRaw = await readFileOrEmpty(path.join(sourceCodexHomeDir, "config.toml"));
+    if (!sourceRaw.trim()) {
+        return;
+    }
+    const sourceLines = sourceRaw.split(/\n/u);
+    const sections = parseTomlSections(sourceLines);
+    const sectionLookup = new Map(sections
+        .filter((section) => section.path[0] === "mcp_servers" && section.path[1])
+        .map((section) => [sectionKey(section), section]));
+    const blocks = enabledIntegrations
+        .map((integration) => integration.ranges
+        .map((range) => {
+        const section = sectionLookup.get(`${integration.id}:${range.start}:${range.end}`);
+        if (!section) {
+            return "";
+        }
+        return sourceLines.slice(section.start, section.end + 1).join("\n").trimEnd();
+    })
+        .filter(Boolean)
+        .join("\n\n"))
+        .filter(Boolean);
+    if (blocks.length === 0) {
+        return;
+    }
+    const targetConfigPath = path.join(targetCodexHomeDir, "config.toml");
+    const targetRaw = await readFileOrEmpty(targetConfigPath);
+    const prefix = targetRaw.trimEnd();
+    const suffix = blocks.join("\n\n");
+    await fs.mkdir(targetCodexHomeDir, { recursive: true });
+    await fs.writeFile(targetConfigPath, `${prefix ? `${prefix}\n\n` : ""}${suffix}\n`, "utf8");
+}
+function parseCodexMcpEnabled(lines, start, end) {
+    for (let index = start + 1; index <= end; index += 1) {
+        const match = lines[index]?.match(/^\s*enabled\s*=\s*(true|false)\s*(?:#.*)?$/u);
+        if (!match) {
+            continue;
+        }
+        return match[1] !== "false";
+    }
+    return true;
+}
+function setCodexMcpEnabled(sectionLines, enabled) {
+    const nextLines = [...sectionLines];
+    const enabledLine = `enabled = ${enabled ? "true" : "false"}`;
+    for (let index = 1; index < nextLines.length; index += 1) {
+        if (/^\s*\[.+\]\s*$/u.test(nextLines[index] ?? "")) {
+            nextLines.splice(index, 0, enabledLine);
+            return nextLines;
+        }
+        if (/^\s*enabled\s*=/u.test(nextLines[index] ?? "")) {
+            nextLines[index] = enabledLine;
+            return nextLines;
+        }
+    }
+    nextLines.splice(1, 0, enabledLine);
+    return nextLines;
+}
+function parseTomlSections(lines) {
+    const sections = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = lines[index]?.match(/^\s*\[(.+)\]\s*$/u);
+        const rawPath = match?.[1];
+        if (!rawPath) {
+            continue;
+        }
+        const parsedPath = parseTomlPath(rawPath);
+        if (parsedPath.length === 0) {
+            continue;
+        }
+        const previous = sections.at(-1);
+        if (previous) {
+            previous.end = index - 1;
+        }
+        sections.push({
+            path: parsedPath,
+            start: index,
+            end: lines.length - 1,
+        });
+    }
+    return sections;
+}
+function parseTomlPath(raw) {
+    const segments = [];
+    let current = "";
+    let inQuotes = false;
+    let escaped = false;
+    for (const char of raw.trim()) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "\"") {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (char === "." && !inQuotes) {
+            if (current.trim().length > 0) {
+                segments.push(current.trim());
+            }
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim().length > 0) {
+        segments.push(current.trim());
+    }
+    return segments;
+}
+function sectionKey(section) {
+    return `${section.path[1] ?? ""}:${section.start}:${section.end}`;
+}
+async function readFileOrEmpty(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function trimTrailingEmptyLines(lines) {
+    const nextLines = [...lines];
+    while (nextLines.length > 0 && nextLines.at(-1)?.trim() === "") {
+        nextLines.pop();
+    }
+    return nextLines;
+}
+function validateRequestedIds(integrations, requestedIds) {
+    const knownIds = new Set(integrations.map((integration) => integration.id));
+    const unknown = requestedIds.filter((id) => !knownIds.has(id));
+    if (unknown.length === 0) {
+        return;
+    }
+    throw new Error(`Unknown integration ids: ${unknown.join(", ")}`);
+}

package/dist/package-version.d.ts

@@ -0,0 +1,2 @@
+export declare const codexHarnessPackageVersion: string;
+//# sourceMappingURL=package-version.d.ts.map

package/dist/package-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-version.d.ts","sourceRoot":"","sources":["../src/package-version.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,0BAA0B,QAAsB,CAAC"}

package/dist/package-version.js

@@ -0,0 +1,4 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const packageJson = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+export const codexHarnessPackageVersion = packageJson.version;

package/dist/workbench-auth.d.ts

@@ -0,0 +1,28 @@
+export declare const codexWorkbenchProviderAuth: {
+    readonly apiKey: {
+        readonly envName: "OPENAI_API_KEY";
+    };
+    readonly profile: {
+        readonly required: readonly [".codex/auth.json"];
+        readonly optional: readonly [];
+    };
+    readonly harnessDefaults: {
+        readonly config: {
+            readonly sandbox_mode: "danger-full-access";
+        };
+    };
+    readonly toHarnessAuth: (auth: {
+        kind: "profile" | "api_key" | "bedrock";
+        root?: string;
+    }) => {
+        strategy: string;
+        ref: string;
+        path?: undefined;
+    } | {
+        strategy: string;
+        path: string;
+        ref?: undefined;
+    } | null;
+    readonly staleErrorPatterns: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+};
+//# sourceMappingURL=workbench-auth.d.ts.map

package/dist/workbench-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench-auth.d.ts","sourceRoot":"","sources":["../src/workbench-auth.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;mCAajB;QAAE,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;CA+BtE,CAAC"}

package/dist/workbench-auth.js

@@ -0,0 +1,45 @@
+export const codexWorkbenchProviderAuth = {
+    apiKey: {
+        envName: "OPENAI_API_KEY",
+    },
+    profile: {
+        required: [".codex/auth.json"],
+        optional: [],
+    },
+    harnessDefaults: {
+        config: {
+            sandbox_mode: "danger-full-access",
+        },
+    },
+    toHarnessAuth(auth) {
+        if (auth.kind === "api_key") {
+            return {
+                strategy: "secret_ref",
+                ref: "OPENAI_API_KEY",
+            };
+        }
+        if (auth.kind === "bedrock") {
+            return null;
+        }
+        if (!auth.root) {
+            return null;
+        }
+        return {
+            strategy: "profile_path",
+            path: auth.root,
+        };
+    },
+    staleErrorPatterns: [
+        /not logged in/iu,
+        /login required/iu,
+        /authentication required/iu,
+        /failed to authenticate/iu,
+        /authentication_error/iu,
+        /api error:\s*401/iu,
+        /invalid.*session/iu,
+        /invalid bearer token/iu,
+        /session.*expired/iu,
+        /oauth.*expired/iu,
+        /unauthorized/iu,
+    ],
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@workbench-ai/agent-driver-openai-codex",
+  "version": "0.0.44",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/workbench-ai/workbench-monorepo.git",
+    "directory": "products/agent-drivers/packages/openai-codex"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./workbench-auth": {
+      "types": "./dist/workbench-auth.d.ts",
+      "default": "./dist/workbench-auth.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^4.1.5",
+    "@workbench-ai/agent-driver": "0.0.44"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "format": "prettier --check 'src/**/*.ts'"
+  }
+}