oc-codex-multi-auth 6.0.0

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "oc-codex-multi-auth",
+  "version": "6.0.0",
+  "description": "OpenCode plugin for Codex-first GPT-5 workflows with ChatGPT Plus/Pro OAuth, multi-account rotation, and guided setup",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "license": "MIT",
+  "author": "Numman Ali",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ndycode/oc-codex-multi-auth.git"
+  },
+  "keywords": [
+    "typescript",
+    "nodejs",
+    "opencode",
+    "opencode-plugin",
+    "openai",
+    "chatgpt",
+    "chatgpt-plus",
+    "chatgpt-pro",
+    "oauth",
+    "oauth2",
+    "pkce",
+    "gpt-5",
+    "codex",
+    "multi-account",
+    "developer-tools",
+    "terminal"
+  ],
+  "homepage": "https://github.com/ndycode/oc-codex-multi-auth#readme",
+  "bugs": {
+    "url": "https://github.com/ndycode/oc-codex-multi-auth/issues"
+  },
+  "scripts": {
+    "build": "tsc && node scripts/copy-oauth-success.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "npm run lint:ts && npm run lint:scripts",
+    "lint:ts": "eslint . --ext .ts",
+    "lint:scripts": "eslint scripts --ext .js",
+    "lint:fix": "npm run lint:ts:fix && npm run lint:scripts:fix",
+    "lint:ts:fix": "eslint . --ext .ts --fix",
+    "lint:scripts:fix": "eslint scripts --ext .js --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "coverage": "vitest run --coverage",
+    "audit:prod": "npm audit --omit=dev --audit-level=high",
+    "audit:all": "npm audit --audit-level=high",
+    "audit:dev:allowlist": "node scripts/audit-dev-allowlist.js",
+    "audit:ci": "npm run audit:prod && npm run audit:dev:allowlist",
+    "prepublishOnly": "npm run build",
+    "prepare": "husky"
+  },
+  "bin": {
+    "oc-codex-multi-auth": "scripts/install-oc-codex-multi-auth.js"
+  },
+  "files": [
+    "dist/",
+    "assets/",
+    "config/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "lint-staged": {
+    "*.ts": [
+      "eslint --max-warnings=0 --fix --no-warn-ignored"
+    ],
+    "scripts/**/*.js": [
+      "eslint --max-warnings=0 --fix --no-warn-ignored"
+    ]
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "devDependencies": {
+    "@fast-check/vitest": "^0.2.4",
+    "@opencode-ai/sdk": "^1.2.10",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
+    "eslint": "^10.0.0",
+    "fast-check": "^4.5.3",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "typescript": "^5.9.3",
+    "typescript-language-server": "^5.1.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@openauthjs/openauth": "^0.4.3",
+    "@opencode-ai/plugin": "^1.2.9",
+    "hono": "4.12.8",
+    "zod": "^4.3.6"
+  },
+  "overrides": {
+    "flatted": "3.4.2",
+    "hono": "4.12.8",
+    "rollup": "4.60.0",
+    "vite": "^7.3.1",
+    "@typescript-eslint/typescript-estree": {
+      "minimatch": "^9.0.5"
+    }
+  }
+}

package/scripts/audit-dev-allowlist.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { execSync } from "node:child_process";
+
+const ALLOWED_HIGH_OR_CRITICAL_PACKAGES = new Set([
+	"eslint",
+	"ajv",
+	"@eslint-community/eslint-utils",
+	"@typescript-eslint/eslint-plugin",
+	"@typescript-eslint/parser",
+	"@typescript-eslint/type-utils",
+	"@typescript-eslint/typescript-estree",
+	"@typescript-eslint/utils",
+	"minimatch",
+]);
+
+function summarizeVia(via) {
+	if (!Array.isArray(via)) return [];
+	return via
+		.map((item) => {
+			if (typeof item === "string") return item;
+			if (!item || typeof item !== "object") return "unknown";
+			const name = typeof item.name === "string" ? item.name : "unknown";
+			const range = typeof item.range === "string" ? item.range : "";
+			return range ? `${name}:${range}` : name;
+		})
+		.slice(0, 5);
+}
+
+let rawAuditOutput = "";
+try {
+	rawAuditOutput = execSync("npm audit --json", {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+} catch (error) {
+	const execError = error;
+	const stdout =
+		execError &&
+		typeof execError === "object" &&
+		"stdout" in execError &&
+		typeof execError.stdout === "string"
+			? execError.stdout
+			: "";
+	const stderr =
+		execError &&
+		typeof execError === "object" &&
+		"stderr" in execError &&
+		typeof execError.stderr === "string"
+			? execError.stderr
+			: "";
+	rawAuditOutput = stdout.trim() || stderr.trim();
+}
+
+if (!rawAuditOutput) {
+	console.error("Failed to read npm audit JSON output.");
+	process.exit(1);
+}
+
+let auditJson;
+try {
+	auditJson = JSON.parse(rawAuditOutput.replace(/^\uFEFF/, ""));
+} catch (error) {
+	console.error("Failed to parse npm audit JSON output.");
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+}
+
+const vulnerabilities =
+	auditJson && typeof auditJson === "object" && auditJson.vulnerabilities && typeof auditJson.vulnerabilities === "object"
+		? auditJson.vulnerabilities
+		: {};
+
+const unexpected = [];
+const allowlisted = [];
+
+for (const [name, details] of Object.entries(vulnerabilities)) {
+	if (!details || typeof details !== "object") continue;
+	const severity = typeof details.severity === "string" ? details.severity : "unknown";
+	if (severity !== "high" && severity !== "critical") continue;
+
+	const entry = {
+		name,
+		severity,
+		via: summarizeVia(details.via),
+		fixAvailable: details.fixAvailable ?? false,
+	};
+
+	if (ALLOWED_HIGH_OR_CRITICAL_PACKAGES.has(name)) {
+		allowlisted.push(entry);
+		continue;
+	}
+	unexpected.push(entry);
+}
+
+if (unexpected.length > 0) {
+	console.error("Unexpected high/critical vulnerabilities detected in dev dependency audit:");
+	for (const entry of unexpected) {
+		console.error(
+			`- ${entry.name} (${entry.severity}) via ${entry.via.join(", ") || "unknown"} fixAvailable=${String(entry.fixAvailable)}`,
+		);
+	}
+	process.exit(1);
+}
+
+if (allowlisted.length > 0) {
+	console.warn("Allowlisted high/critical dev vulnerabilities detected:");
+	for (const entry of allowlisted) {
+		console.warn(
+			`- ${entry.name} (${entry.severity}) via ${entry.via.join(", ") || "unknown"} fixAvailable=${String(entry.fixAvailable)}`,
+		);
+	}
+	console.warn("No unexpected high/critical vulnerabilities found.");
+}

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-oc-codex-multi-auth-core.js

@@ -0,0 +1,381 @@
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE_NAME = "oc-codex-multi-auth";
+const LEGACY_PACKAGE_NAMES = ["oc-chatgpt-multi-auth"];
+const WINDOWS_RENAME_RETRY_ATTEMPTS = 5;
+const WINDOWS_RENAME_RETRY_BASE_DELAY_MS = 10;
+
+function getManagedPackageNames() {
+	return [PACKAGE_NAME, ...LEGACY_PACKAGE_NAMES];
+}
+
+function printHelp() {
+	console.log(`Usage: ${PACKAGE_NAME} [--modern|--legacy] [--dry-run] [--no-cache-clear]\n\n` +
+		"Default behavior:\n" +
+		"  - Installs/updates global config at ~/.config/opencode/opencode.json\n" +
+		"  - Uses full catalog config by default (9 base models + 34 explicit presets)\n" +
+		"  - Ensures plugin is unpinned (latest)\n" +
+		"  - Clears OpenCode plugin cache\n\n" +
+		"Options:\n" +
+		"  --modern           Force compact modern config (9 base models + --variant presets)\n" +
+		"  --legacy           Force explicit legacy config (34 preset model entries)\n" +
+		"  --dry-run          Show actions without writing\n" +
+		"  --no-cache-clear   Skip clearing OpenCode cache\n"
+	);
+}
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(scriptDir, "..");
+const modernTemplatePath = join(repoRoot, "config", "opencode-modern.json");
+const legacyTemplatePath = join(repoRoot, "config", "opencode-legacy.json");
+
+function log(message) {
+	console.log(message);
+}
+
+function delay(ms) {
+	return new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+
+function isWindowsLockError(error) {
+	const code = error?.code;
+	return code === "EPERM" || code === "EBUSY";
+}
+
+function formatErrorForLog(error) {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+function resolveHomeDirectory(env = process.env) {
+	return env.HOME || env.USERPROFILE || homedir();
+}
+
+function buildPaths(homeDir) {
+	const configDir = join(homeDir, ".config", "opencode");
+	const cacheDir = join(homeDir, ".cache", "opencode");
+	return {
+		configDir,
+		configPath: join(configDir, "opencode.json"),
+		cacheDir,
+		cacheNodeModulesPaths: getManagedPackageNames().map((name) => join(cacheDir, "node_modules", name)),
+		cacheBunLock: join(cacheDir, "bun.lock"),
+		cachePackageJson: join(cacheDir, "package.json"),
+		modernTemplatePath,
+		legacyTemplatePath,
+	};
+}
+
+function parseCliArgs(argv = process.argv.slice(2)) {
+	const args = new Set(argv);
+	if (args.has("--help") || args.has("-h")) {
+		return {
+			wantsHelp: true,
+		};
+	}
+
+	const requestedModern = args.has("--modern");
+	const requestedLegacy = args.has("--legacy");
+
+	if (requestedModern && requestedLegacy) {
+		throw new Error("Choose only one of --modern or --legacy.");
+	}
+
+	return {
+		wantsHelp: false,
+		dryRun: args.has("--dry-run"),
+		skipCacheClear: args.has("--no-cache-clear"),
+		configMode: requestedModern ? "modern" : requestedLegacy ? "legacy" : "full",
+	};
+}
+
+function normalizePluginList(list) {
+	const entries = Array.isArray(list) ? list.filter(Boolean) : [];
+	const managedNames = getManagedPackageNames();
+	const filtered = entries.filter((entry) => {
+		if (typeof entry !== "string") return true;
+		return !managedNames.some((name) => entry === name || entry.startsWith(`${name}@`));
+	});
+	return [...filtered, PACKAGE_NAME];
+}
+
+function formatJson(obj) {
+	return `${JSON.stringify(obj, null, 2)}\n`;
+}
+
+function mergeFullTemplate(modernTemplate, legacyTemplate) {
+	const modernModels = modernTemplate.provider?.openai?.models ?? {};
+	const legacyModels = legacyTemplate.provider?.openai?.models ?? {};
+	const overlappingKeys = Object.keys(modernModels).filter((key) => Object.hasOwn(legacyModels, key));
+
+	if (overlappingKeys.length > 0) {
+		throw new Error(`Full config template collision for model keys: ${overlappingKeys.join(", ")}`);
+	}
+
+	return {
+		...modernTemplate,
+		provider: {
+			...(modernTemplate.provider ?? {}),
+			openai: {
+				...(modernTemplate.provider?.openai ?? {}),
+				models: {
+					...modernModels,
+					...legacyModels,
+				},
+			},
+		},
+	};
+}
+
+async function readJson(filePath) {
+	const content = await readFile(filePath, "utf-8");
+	return JSON.parse(content);
+}
+
+async function renameWithWindowsRetry(sourcePath, destinationPath) {
+	let lastError = null;
+
+	for (let attempt = 0; attempt < WINDOWS_RENAME_RETRY_ATTEMPTS; attempt += 1) {
+		try {
+			await rename(sourcePath, destinationPath);
+			return;
+		} catch (error) {
+			if (isWindowsLockError(error)) {
+				lastError = error;
+				await delay(WINDOWS_RENAME_RETRY_BASE_DELAY_MS * 2 ** attempt);
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	if (lastError) {
+		throw lastError;
+	}
+}
+
+async function writeFileAtomic(filePath, content) {
+	const uniqueSuffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+	const tempPath = `${filePath}.${uniqueSuffix}.tmp`;
+
+	try {
+		await mkdir(dirname(filePath), { recursive: true });
+		await writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
+		await renameWithWindowsRetry(tempPath, filePath);
+	} catch (error) {
+		await rm(tempPath, { force: true }).catch(() => {});
+		throw error;
+	}
+}
+
+async function loadTemplate(mode, paths) {
+	if (mode === "modern") {
+		return readJson(paths.modernTemplatePath);
+	}
+	if (mode === "legacy") {
+		return readJson(paths.legacyTemplatePath);
+	}
+
+	const [modernTemplate, legacyTemplate] = await Promise.all([
+		readJson(paths.modernTemplatePath),
+		readJson(paths.legacyTemplatePath),
+	]);
+
+	return mergeFullTemplate(modernTemplate, legacyTemplate);
+}
+
+async function copyFileWithWindowsRetry(sourcePath, destinationPath) {
+	let lastError = null;
+
+	for (let attempt = 0; attempt < WINDOWS_RENAME_RETRY_ATTEMPTS; attempt += 1) {
+		try {
+			await copyFile(sourcePath, destinationPath);
+			return;
+		} catch (error) {
+			if (isWindowsLockError(error)) {
+				lastError = error;
+				await delay(WINDOWS_RENAME_RETRY_BASE_DELAY_MS * 2 ** attempt);
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	if (lastError) {
+		throw lastError;
+	}
+}
+
+async function backupConfig(sourcePath, dryRun) {
+	const timestamp = new Date()
+		.toISOString()
+		.replace(/[:.]/g, "-")
+		.replace("T", "_")
+		.replace("Z", "");
+	const backupPath = `${sourcePath}.bak-${timestamp}`;
+	if (!dryRun) {
+		await copyFileWithWindowsRetry(sourcePath, backupPath);
+	}
+	return backupPath;
+}
+
+async function removePluginFromCachePackage(paths, dryRun) {
+	if (!existsSync(paths.cachePackageJson)) {
+		return;
+	}
+
+	let cacheData;
+	try {
+		cacheData = await readJson(paths.cachePackageJson);
+	} catch (error) {
+		log(`Warning: Could not parse ${paths.cachePackageJson} (${formatErrorForLog(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") {
+			for (const name of getManagedPackageNames()) {
+				if (name in deps) {
+					delete deps[name];
+					changed = true;
+				}
+			}
+		}
+	}
+
+	if (!changed) {
+		return;
+	}
+
+	if (dryRun) {
+		log(`[dry-run] Would update ${paths.cachePackageJson} to remove ${getManagedPackageNames().join(", ")}`);
+		return;
+	}
+
+	await writeFileAtomic(paths.cachePackageJson, formatJson(cacheData));
+}
+
+async function clearCache(paths, dryRun, skipCacheClear) {
+	if (skipCacheClear) {
+		log("Skipping cache clear (--no-cache-clear).");
+		await removePluginFromCachePackage(paths, dryRun);
+		return;
+	}
+
+	if (dryRun) {
+		for (const cacheNodeModulesPath of paths.cacheNodeModulesPaths) {
+			log(`[dry-run] Would remove ${cacheNodeModulesPath}`);
+		}
+		log(`[dry-run] Would remove ${paths.cacheBunLock}`);
+	} else {
+		for (const cacheNodeModulesPath of paths.cacheNodeModulesPaths) {
+			await rm(cacheNodeModulesPath, { recursive: true, force: true });
+		}
+		await rm(paths.cacheBunLock, { force: true });
+	}
+
+	await removePluginFromCachePackage(paths, dryRun);
+}
+
+export async function runInstaller(argv = process.argv.slice(2), options = {}) {
+	const parsed = parseCliArgs(argv);
+	if (parsed.wantsHelp) {
+		printHelp();
+		return { exitCode: 0, action: "help" };
+	}
+
+	const { env = process.env } = options;
+	const { configMode, dryRun, skipCacheClear } = parsed;
+	const paths = buildPaths(resolveHomeDirectory(env));
+	const requiredTemplatePaths = configMode === "modern"
+		? [paths.modernTemplatePath]
+		: configMode === "legacy"
+			? [paths.legacyTemplatePath]
+			: [paths.modernTemplatePath, paths.legacyTemplatePath];
+
+	for (const templatePath of requiredTemplatePaths) {
+		if (!existsSync(templatePath)) {
+			throw new Error(`Config template not found at ${templatePath}`);
+		}
+	}
+
+	const template = await loadTemplate(configMode, paths);
+	template.plugin = [PACKAGE_NAME];
+
+	let nextConfig = template;
+	if (existsSync(paths.configPath)) {
+		const backupPath = await backupConfig(paths.configPath, dryRun);
+		log(`${dryRun ? "[dry-run] Would create backup" : "Backup created"}: ${backupPath}`);
+
+		try {
+			const existing = await readJson(paths.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 (${formatErrorForLog(error)}). Replacing with template.`);
+			nextConfig = template;
+		}
+	} else {
+		log("No existing config found. Creating new global config.");
+	}
+
+	if (dryRun) {
+		log(`[dry-run] Would write ${paths.configPath} using ${configMode} config`);
+	} else {
+		await writeFileAtomic(paths.configPath, formatJson(nextConfig));
+		log(`Wrote ${paths.configPath} (${configMode} config)`);
+	}
+
+	await clearCache(paths, dryRun, skipCacheClear);
+
+	log("\nDone. Restart OpenCode to (re)install the plugin.");
+	log("Example: opencode");
+	if (configMode === "modern") {
+		log("Note: Modern config intentionally shows 9 base model entries; use --variant to access all 34 shipped presets.");
+	}
+	if (configMode === "legacy") {
+		log("Note: Legacy config writes 34 explicit preset entries and is also safe for older OpenCode versions.");
+	}
+	if (configMode === "full") {
+		log("Note: Full config installs both modern base models and explicit preset entries so the full shipped catalog is visible by default.");
+	}
+
+	return {
+		exitCode: 0,
+		action: "install",
+		configMode,
+		configPath: paths.configPath,
+	};
+}
+
+export const __test = {
+	buildPaths,
+	backupConfig,
+	copyFileWithWindowsRetry,
+	mergeFullTemplate,
+	parseCliArgs,
+	writeFileAtomic,
+	renameWithWindowsRetry,
+	resolveHomeDirectory,
+};

package/scripts/install-oc-codex-multi-auth.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runInstaller } from "./install-oc-codex-multi-auth-core.js";
+
+export * from "./install-oc-codex-multi-auth-core.js";
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+	runInstaller().catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`Installer failed: ${message}`);
+		process.exit(1);
+	});
+}