codex-multi-auth 0.1.0

package/scripts/benchmark-render-dashboard.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import process from "node:process";
+import { renderDashboardHtml } from "./bench-format/render.mjs";
+
+function usage() {
+  console.log([
+    "Usage: node scripts/benchmark-render-dashboard.mjs --input=PATH [--output=PATH]",
+    "",
+    "Options:",
+    "  --input=PATH   Path to benchmark summary.json",
+    "  --output=PATH  Output HTML path (default: alongside input as dashboard.html)",
+  ].join("\n"));
+}
+
+function argValue(args, name) {
+  const prefix = `${name}=`;
+  const match = args.find((arg) => arg.startsWith(prefix));
+  return match ? match.slice(prefix.length) : undefined;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    usage();
+    return;
+  }
+
+  const inputRaw = argValue(args, "--input");
+  if (!inputRaw) {
+    usage();
+    process.exitCode = 1;
+    return;
+  }
+  const inputPath = resolve(inputRaw);
+  const outputPath = resolve(argValue(args, "--output") ?? inputPath.replace(/summary\.json$/i, "dashboard.html"));
+
+  const summary = JSON.parse(await readFile(inputPath, "utf8"));
+  const html = renderDashboardHtml(summary);
+  await writeFile(outputPath, html, "utf8");
+  console.log(`Dashboard written: ${outputPath}`);
+}
+
+main().catch((error) => {
+  console.error(`Render failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/scripts/codex-multi-auth.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { runCodexMultiAuthCli } from "../dist/lib/codex-manager.js";
+
+const exitCode = await runCodexMultiAuthCli(process.argv.slice(2));
+process.exit(exitCode);

package/scripts/codex-routing.js

@@ -0,0 +1,34 @@
+const AUTH_SUBCOMMANDS = new Set([
+	"login",
+	"list",
+	"status",
+	"switch",
+	"check",
+	"features",
+	"verify-flagged",
+	"forecast",
+	"report",
+	"fix",
+	"doctor",
+]);
+
+export function normalizeAuthAlias(args) {
+	if (args.length >= 2 && args[0] === "multi" && args[1] === "auth") {
+		return ["auth", ...args.slice(2)];
+	}
+	if (args.length >= 1 && (args[0] === "multi-auth" || args[0] === "multiauth")) {
+		return ["auth", ...args.slice(1)];
+	}
+	return args;
+}
+
+export function shouldHandleMultiAuthAuth(args) {
+	if (args[0] !== "auth") return false;
+	if (args.length === 1) return true;
+	const subcommand = args[1];
+	if (typeof subcommand !== "string") return false;
+	if (subcommand.startsWith("-")) return true;
+	return AUTH_SUBCOMMANDS.has(subcommand);
+}
+
+export { AUTH_SUBCOMMANDS };

package/scripts/codex.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { runCodexMultiAuthCli } from "../dist/lib/codex-manager.js";
+import { normalizeAuthAlias, shouldHandleMultiAuthAuth } from "./codex-routing.js";
+
+function resolveRealCodexBin() {
+	const override = (process.env.CODEX_MULTI_AUTH_REAL_CODEX_BIN ?? "").trim();
+	if (override.length > 0) {
+		if (existsSync(override)) return override;
+		console.error(
+			`CODEX_MULTI_AUTH_REAL_CODEX_BIN is set but missing: ${override}`,
+		);
+		return null;
+	}
+
+	try {
+		const require = createRequire(import.meta.url);
+		const resolved = require.resolve("@openai/codex/bin/codex.js");
+		if (existsSync(resolved)) return resolved;
+	} catch {
+		// Fall through to sibling lookup.
+	}
+
+	const searchRoots = [];
+	const scriptDir = dirname(fileURLToPath(import.meta.url));
+	searchRoots.push(join(scriptDir, "..", ".."));
+
+	const invokedScript = process.argv[1];
+	if (typeof invokedScript === "string" && invokedScript.length > 0) {
+		searchRoots.push(join(dirname(invokedScript), "..", ".."));
+	}
+
+	const npmPrefix = (process.env.npm_config_prefix ?? process.env.PREFIX ?? "").trim();
+	if (npmPrefix.length > 0) {
+		searchRoots.push(join(npmPrefix, "node_modules"));
+		searchRoots.push(join(npmPrefix, "lib", "node_modules"));
+	}
+
+	for (const root of searchRoots) {
+		const candidate = join(root, "@openai", "codex", "bin", "codex.js");
+		if (existsSync(candidate)) return candidate;
+	}
+
+	const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+	try {
+		const rootResult = spawnSync(npmCmd, ["root", "-g"], {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		});
+		if (rootResult.status === 0) {
+			const globalRoot = rootResult.stdout.trim();
+			if (globalRoot.length > 0) {
+				const globalBin = join(globalRoot, "@openai", "codex", "bin", "codex.js");
+				if (existsSync(globalBin)) return globalBin;
+			}
+		}
+	} catch {
+		// Ignore and fall through to null.
+	}
+
+	return null;
+}
+
+function forwardToRealCodex(codexBin, args) {
+	return new Promise((resolve) => {
+		const child = spawn(process.execPath, [codexBin, ...args], {
+			stdio: "inherit",
+			env: process.env,
+		});
+
+		child.once("error", (error) => {
+			console.error(`Failed to launch real Codex CLI: ${String(error)}`);
+			resolve(1);
+		});
+
+		child.once("exit", (code, signal) => {
+			if (signal) {
+				const signalNumber = signal === "SIGINT" ? 130 : 1;
+				resolve(signalNumber);
+				return;
+			}
+			resolve(typeof code === "number" ? code : 1);
+		});
+	});
+}
+
+const rawArgs = process.argv.slice(2);
+const normalizedArgs = normalizeAuthAlias(rawArgs);
+const bypass = (process.env.CODEX_MULTI_AUTH_BYPASS ?? "").trim() === "1";
+
+if (!bypass && shouldHandleMultiAuthAuth(normalizedArgs)) {
+	try {
+		const exitCode = await runCodexMultiAuthCli(normalizedArgs);
+		process.exit(exitCode);
+	} catch (error) {
+		console.error(
+			`codex-multi-auth runner failed: ${error instanceof Error ? error.message : String(error)}`,
+		);
+		process.exit(1);
+	}
+}
+
+const realCodexBin = resolveRealCodexBin();
+if (!realCodexBin) {
+	console.error(
+		[
+			"Could not locate the official Codex CLI binary (@openai/codex).",
+			"Install it globally: npm install -g @openai/codex",
+			"Or set CODEX_MULTI_AUTH_REAL_CODEX_BIN to a full bin/codex.js path.",
+		].join("\n"),
+	);
+	process.exit(1);
+}
+
+const forwardExitCode = await forwardToRealCodex(realCodexBin, rawArgs);
+process.exit(forwardExitCode);

package/scripts/copy-oauth-success.js

@@ -0,0 +1,37 @@
+import { promises as fs } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+function normalizePathForCompare(path) {
+	const resolved = resolve(path);
+	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function getDefaultPaths() {
+	const src = join(__dirname, "..", "lib", "oauth-success.html");
+	const dest = join(__dirname, "..", "dist", "lib", "oauth-success.html");
+	return { src, dest };
+}
+
+export async function copyOAuthSuccessHtml(options = {}) {
+	const defaults = getDefaultPaths();
+	const src = options.src ?? defaults.src;
+	const dest = options.dest ?? defaults.dest;
+
+	await fs.mkdir(dirname(dest), { recursive: true });
+	await fs.copyFile(src, dest);
+
+	return { src, dest };
+}
+
+const isDirectRun = (() => {
+	if (!process.argv[1]) return false;
+	return normalizePathForCompare(process.argv[1]) === normalizePathForCompare(__filename);
+})();
+
+if (isDirectRun) {
+	await copyOAuthSuccessHtml();
+}

package/scripts/install-opencode-codex-auth.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { readFile, writeFile, mkdir, copyFile, rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+const PLUGIN_NAME = "codex-multi-auth";
+
+const args = new Set(process.argv.slice(2));
+
+if (args.has("--help") || args.has("-h")) {
+	console.log(`Usage: ${PLUGIN_NAME} [--modern|--legacy] [--dry-run] [--no-cache-clear]\n\n` +
+		"Default behavior:\n" +
+		"  - Installs/updates global config at ~/.config/opencode/opencode.json\n" +
+		"  - Uses modern config (variants) by default\n" +
+		"  - Ensures plugin is unpinned (latest)\n" +
+		"  - Clears OpenCode plugin cache\n\n" +
+		"Options:\n" +
+		"  --modern           Force modern config (default)\n" +
+		"  --legacy           Use legacy config (older OpenCode versions)\n" +
+		"  --dry-run          Show actions without writing\n" +
+		"  --no-cache-clear   Skip clearing OpenCode cache\n"
+	);
+	process.exit(0);
+}
+
+const useLegacy = args.has("--legacy");
+const useModern = args.has("--modern") || !useLegacy;
+const dryRun = args.has("--dry-run");
+const skipCacheClear = args.has("--no-cache-clear");
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(scriptDir, "..");
+const templatePath = join(
+	repoRoot,
+	"config",
+	useLegacy ? "opencode-legacy.json" : "opencode-modern.json"
+);
+
+const configDir = join(homedir(), ".config", "opencode");
+const configPath = join(configDir, "opencode.json");
+const cacheDir = join(homedir(), ".cache", "opencode");
+const cacheNodeModules = join(cacheDir, "node_modules", PLUGIN_NAME);
+const cacheBunLock = join(cacheDir, "bun.lock");
+const cachePackageJson = join(cacheDir, "package.json");
+
+function log(message) {
+	console.log(message);
+}
+
+function normalizePluginList(list) {
+	const entries = Array.isArray(list) ? list.filter(Boolean) : [];
+	const filtered = entries.filter((entry) => {
+		if (typeof entry !== "string") return true;
+		return entry !== PLUGIN_NAME && !entry.startsWith(`${PLUGIN_NAME}@`);
+	});
+	return [...filtered, PLUGIN_NAME];
+}
+
+function formatJson(obj) {
+	return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+async function readJson(filePath) {
+	const content = await readFile(filePath, "utf-8");
+	return JSON.parse(content);
+}
+
+async function backupConfig(sourcePath) {
+	const timestamp = new Date()
+		.toISOString()
+		.replace(/[:.]/g, "-")
+		.replace("T", "_")
+		.replace("Z", "");
+	const backupPath = `${sourcePath}.bak-${timestamp}`;
+	if (!dryRun) {
+		await copyFile(sourcePath, backupPath);
+	}
+	return backupPath;
+}
+
+async function removePluginFromCachePackage() {
+	if (!existsSync(cachePackageJson)) {
+		return;
+	}
+
+	let cacheData;
+	try {
+		cacheData = await readJson(cachePackageJson);
+	} catch (error) {
+		log(`Warning: Could not parse ${cachePackageJson} (${error}). Skipping.`);
+		return;
+	}
+
+	const sections = [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies",
+		"optionalDependencies",
+	];
+
+	let changed = false;
+	for (const section of sections) {
+		const deps = cacheData?.[section];
+		if (deps && typeof deps === "object" && PLUGIN_NAME in deps) {
+			delete deps[PLUGIN_NAME];
+			changed = true;
+		}
+	}
+
+	if (!changed) {
+		return;
+	}
+
+	if (dryRun) {
+		log(`[dry-run] Would update ${cachePackageJson} to remove ${PLUGIN_NAME}`);
+		return;
+	}
+
+	await writeFile(cachePackageJson, formatJson(cacheData), "utf-8");
+}
+
+async function clearCache() {
+	if (skipCacheClear) {
+		log("Skipping cache clear (--no-cache-clear).");
+		return;
+	}
+
+	if (dryRun) {
+		log(`[dry-run] Would remove ${cacheNodeModules}`);
+		log(`[dry-run] Would remove ${cacheBunLock}`);
+	} else {
+		await rm(cacheNodeModules, { recursive: true, force: true });
+		await rm(cacheBunLock, { force: true });
+	}
+
+	await removePluginFromCachePackage();
+}
+
+async function main() {
+	if (!existsSync(templatePath)) {
+		throw new Error(`Config template not found at ${templatePath}`);
+	}
+
+	const template = await readJson(templatePath);
+	template.plugin = [PLUGIN_NAME];
+
+	let nextConfig = template;
+	if (existsSync(configPath)) {
+		const backupPath = await backupConfig(configPath);
+		log(`${dryRun ? "[dry-run] Would create backup" : "Backup created"}: ${backupPath}`);
+
+		try {
+			const existing = await readJson(configPath);
+			const merged = { ...existing };
+			merged.plugin = normalizePluginList(existing.plugin);
+			const provider = (existing.provider && typeof existing.provider === "object")
+				? { ...existing.provider }
+				: {};
+			provider.openai = template.provider.openai;
+			merged.provider = provider;
+			nextConfig = merged;
+		} catch (error) {
+			log(`Warning: Could not parse existing config (${error}). Replacing with template.`);
+			nextConfig = template;
+		}
+	} else {
+		log("No existing config found. Creating new global config.");
+	}
+
+	if (dryRun) {
+		log(`[dry-run] Would write ${configPath} using ${useLegacy ? "legacy" : "modern"} config`);
+	} else {
+		await mkdir(configDir, { recursive: true });
+		await writeFile(configPath, formatJson(nextConfig), "utf-8");
+		log(`Wrote ${configPath} (${useLegacy ? "legacy" : "modern"} config)`);
+	}
+
+	await clearCache();
+
+	log("\nDone. Restart OpenCode to (re)install the plugin.");
+	log("Example: opencode");
+	if (useLegacy) {
+		log("Note: Legacy config requires OpenCode v1.0.209 or older.");
+	}
+}
+
+main().catch((error) => {
+	console.error(`Installer failed: ${error instanceof Error ? error.message : error}`);
+	process.exit(1);
+});

package/scripts/test-all-models.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+node "${SCRIPT_DIR}/test-model-matrix.js" "$@"
+