oh-my-opencode 4.7.5 → 4.8.0

package/packages/omo-codex/plugin/scripts/auto-update.mjs

@@ -1,29 +1,54 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from "node:child_process";
-import { appendFile, mkdir, open, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+	DEFAULT_LOCK_STALE_MS,
+	acquireLock,
+	appendUpdateLog,
+	readState,
+	resolveLockPath,
+	resolveStatePath,
+	writeState,
+} from "./auto-update-state.mjs";
 import { migrateCodexConfig } from "./migrate-codex-config.mjs";
+import { resolveSpawnInvocation } from "./spawn-command.mjs";
 
 const DEFAULT_INTERVAL_MS = 24 * 60 * 60 * 1_000;
-const DEFAULT_LOCK_STALE_MS = 10 * 60 * 1_000;
+const DEFAULT_RETRY_INTERVAL_MS = 30 * 60 * 1_000;
+const DEFAULT_UPDATE_COMMAND = "npx";
+const DEFAULT_UPDATE_ARGS = ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--codex-autonomous"];
+const INSTALLED_VERSION_FILE = "lazycodex-install.json";
 
-export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt } = {}) {
+export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), lastCheckedAt, lastAttemptedAt, lastStatus } = {}) {
 	if (env.LAZYCODEX_AUTO_UPDATE_DISABLED === "1" || env.OMO_CODEX_AUTO_UPDATE_DISABLED === "1") {
 		return { shouldRun: false, reason: "disabled" };
 	}
 
 	const intervalMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_INTERVAL_MS, DEFAULT_INTERVAL_MS);
-	if (typeof lastCheckedAt === "number" && intervalMs > 0 && now - lastCheckedAt < intervalMs) {
+	const successStatus = lastStatus === undefined || lastStatus === "success";
+	if (successStatus && typeof lastCheckedAt === "number" && intervalMs > 0 && now - lastCheckedAt < intervalMs) {
 		return { shouldRun: false, reason: "throttled" };
 	}
+	const retryIntervalMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_RETRY_INTERVAL_MS, DEFAULT_RETRY_INTERVAL_MS);
+	if (!successStatus && typeof lastAttemptedAt === "number" && retryIntervalMs > 0 && now - lastAttemptedAt < retryIntervalMs) {
+		return { shouldRun: false, reason: "retry-throttled" };
+	}
 
-	return {
-		shouldRun: true,
+	const updatePlan = resolveLazyCodexUpdatePlan({
+		currentVersion: resolveCurrentVersion(env),
+		latestVersion: resolveLatestVersion(env),
 		command: resolveCommand(env),
 		args: resolveArgs(env),
+	});
+	if (!updatePlan.shouldUpdate) return { shouldRun: false, reason: updatePlan.reason };
+
+	return {
+		shouldRun: true,
+		command: updatePlan.command,
+		args: updatePlan.args,
 		env: {
 			...env,
 			LAZYCODEX_AUTO_UPDATE_DISABLED: "1",
@@ -32,35 +57,88 @@ export function resolveAutoUpdatePlan({ env = process.env, now = Date.now(), las
 	};
 }
 
+export function resolveLazyCodexUpdatePlan({ currentVersion, latestVersion, command = DEFAULT_UPDATE_COMMAND, args = DEFAULT_UPDATE_ARGS } = {}) {
+	const current = parseVersion(currentVersion);
+	if (current === null) return { shouldUpdate: false, reason: "unknown-current" };
+	const latest = parseVersion(latestVersion);
+	if (latest === null) return { shouldUpdate: false, reason: "unknown-latest" };
+	if (compareVersions(latest, current) <= 0) return { shouldUpdate: false, reason: "up-to-date" };
+	return { shouldUpdate: true, command, args };
+}
+
+export async function runLazyCodexManualUpdate({ env = process.env, dryRun = false, log = console.log, runCommand } = {}) {
+	const commandRunner = runCommand ?? defaultRunCommandForManualUpdate;
+	const currentVersion = resolveCurrentVersion(env);
+	const latestVersion = resolveLatestVersion(env);
+	const plan = resolveLazyCodexUpdatePlan({
+		currentVersion,
+		latestVersion,
+		command: resolveCommand(env),
+		args: resolveArgs(env),
+	});
+	if (!plan.shouldUpdate) {
+		const printableVersion = currentVersion ?? "unknown";
+		log(plan.reason === "up-to-date"
+			? `lazycodex-ai ${printableVersion} is already up to date.`
+			: `Unable to check lazycodex-ai updates (${plan.reason}).`);
+		return plan.reason === "up-to-date" ? 0 : 1;
+	}
+	if (dryRun) {
+		log(`${plan.command} ${plan.args.join(" ")}`);
+		return 0;
+	}
+	await commandRunner(plan.command, plan.args, { cwd: process.cwd(), env });
+	return 0;
+}
+
 export async function runAutoUpdateCheck({ env = process.env, now = Date.now() } = {}) {
 	await runConfigMigration({ env });
 	const statePath = resolveStatePath(env);
 	const state = await readState(statePath);
-	const plan = resolveAutoUpdatePlan({ env, now, lastCheckedAt: state.lastCheckedAt });
-	if (!plan.shouldRun) return { started: false, reason: plan.reason };
+	const plan = resolveAutoUpdatePlan({
+		env,
+		now,
+		lastCheckedAt: state.lastCheckedAt,
+		lastAttemptedAt: state.lastAttemptedAt,
+		lastStatus: state.lastStatus,
+	});
+	if (!plan.shouldRun) {
+		await appendUpdateLog(env, now, "skipped", { reason: plan.reason });
+		if (plan.reason === "up-to-date") {
+			await writeState(statePath, { ...state, lastCheckedAt: now, lastStatus: "success" });
+		}
+		return { started: false, reason: plan.reason };
+	}
 
-	const lock = await acquireLock(resolveLockPath(env, statePath), now, env);
+	const lockStaleMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS, DEFAULT_LOCK_STALE_MS);
+	const lock = await acquireLock(resolveLockPath(env, statePath), now, lockStaleMs);
 	if (lock === null) {
 		await appendUpdateLog(env, now, "locked");
 		return { started: false, reason: "locked" };
 	}
 	try {
-		await writeState(statePath, { lastCheckedAt: now });
 		await appendUpdateLog(env, now, "started", { command: plan.command, args: plan.args });
 		if (env.LAZYCODEX_AUTO_UPDATE_WAIT === "1") {
-			const result = spawnSync(plan.command, plan.args, {
+			const invocation = resolveSpawnInvocation(plan.command, plan.args);
+			const result = spawnSync(invocation.command, invocation.args, {
 				env: plan.env,
 				stdio: "ignore",
 			});
-			await appendUpdateLog(env, now, "finished", { status: result.status ?? 0 });
-			return { started: true, status: result.status ?? 0 };
+			const status = result.status ?? (result.error === undefined ? 0 : 1);
+			await appendUpdateLog(env, now, "finished", { status });
+			await writeState(statePath, status === 0
+				? { lastCheckedAt: now, lastAttemptedAt: now, lastStatus: "success" }
+				: { lastAttemptedAt: now, lastStatus: "failed" });
+			return { started: true, status };
 		}
 
-		const child = spawn(plan.command, plan.args, {
+		const invocation = resolveSpawnInvocation(plan.command, plan.args);
+		const child = spawn(invocation.command, invocation.args, {
 			env: plan.env,
 			stdio: "ignore",
 			detached: true,
 		});
+		await writeState(statePath, { lastAttemptedAt: now, lastStatus: "started" });
 		child.unref();
 		return { started: true };
 	} finally {
@@ -79,7 +157,7 @@ async function runConfigMigration({ env }) {
 }
 
 function resolveCommand(env) {
-	return env.LAZYCODEX_AUTO_UPDATE_COMMAND?.trim() || "npx";
+	return env.LAZYCODEX_AUTO_UPDATE_COMMAND?.trim() || DEFAULT_UPDATE_COMMAND;
 }
 
 function resolveArgs(env) {
@@ -90,81 +168,93 @@ function resolveArgs(env) {
 		}
 		return parsed;
 	}
-	return ["--yes", "lazycodex-ai@latest", "install", "--no-tui", "--skip-auth"];
+	return DEFAULT_UPDATE_ARGS;
 }
 
-function resolveStatePath(env) {
-	if (env.LAZYCODEX_AUTO_UPDATE_STATE_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_STATE_PATH;
-	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
-	return join(dataRoot, "auto-update.json");
+function resolveCurrentVersion(env) {
+	if (env.LAZYCODEX_CURRENT_VERSION?.trim()) return env.LAZYCODEX_CURRENT_VERSION.trim();
+	const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+	return (
+		readVersionManifest(resolveInstalledVersionPath(env, pluginRoot)) ??
+		readVersionManifest(join(pluginRoot, "..", "..", "..", "package.json")) ??
+		readVersionManifest(join(pluginRoot, ".codex-plugin", "plugin.json"))
+	);
 }
 
-function resolveLogPath(env) {
-	if (env.LAZYCODEX_AUTO_UPDATE_LOG_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOG_PATH;
-	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
-	return join(dataRoot, "auto-update.log");
+function resolveLatestVersion(env) {
+	if (env.LAZYCODEX_LATEST_VERSION?.trim()) return env.LAZYCODEX_LATEST_VERSION.trim();
+	const invocation = resolveSpawnInvocation("npm", ["view", "lazycodex-ai", "version", "--silent"]);
+	const result = spawnSync(invocation.command, invocation.args, {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "ignore"],
+	});
+	if (result.status !== 0) return undefined;
+	const version = result.stdout.trim();
+	return version.length > 0 ? version : undefined;
 }
 
-function resolveLockPath(env, statePath) {
-	if (env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH?.trim()) return env.LAZYCODEX_AUTO_UPDATE_LOCK_PATH;
-	return `${statePath}.lock`;
+function defaultRunCommandForManualUpdate(command, args, options) {
+	return new Promise((resolve, reject) => {
+		const invocation = resolveSpawnInvocation(command, args);
+		const child = spawn(invocation.command, invocation.args, {
+			cwd: options.cwd,
+			env: options.env,
+			stdio: "inherit",
+		});
+		child.once("error", reject);
+		child.once("close", (code) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			reject(new Error(`${command} ${args.join(" ")} exited with ${code ?? "unknown status"}`));
+		});
+	});
 }
 
-async function acquireLock(lockPath, now, env) {
-	await mkdir(dirname(lockPath), { recursive: true });
-	const staleMs = parsePositiveInteger(env.LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS, DEFAULT_LOCK_STALE_MS);
-	try {
-		const handle = await open(lockPath, "wx");
-		await handle.writeFile(`${now}\n`);
-		await handle.close();
-		return {
-			release: () => rm(lockPath, { force: true }),
-		};
-	} catch (error) {
-		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
-		if (!(await removeStaleLock(lockPath, now, staleMs))) return null;
-		return acquireLock(lockPath, now, { ...env, LAZYCODEX_AUTO_UPDATE_LOCK_STALE_MS: "0" });
-	}
+function parseVersion(version) {
+	if (typeof version !== "string") return null;
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(version.trim());
+	if (match === null) return null;
+	const major = Number.parseInt(match[1], 10);
+	const minor = Number.parseInt(match[2], 10);
+	const patch = Number.parseInt(match[3], 10);
+	const prerelease = match[4];
+	return Number.isFinite(major) && Number.isFinite(minor) && Number.isFinite(patch)
+		? { major, minor, patch, prerelease }
+		: null;
 }
 
-async function removeStaleLock(lockPath, now, staleMs) {
-	if (staleMs <= 0) return false;
-	try {
-		const lockStat = await stat(lockPath);
-		if (now - lockStat.mtimeMs < staleMs) return false;
-		await rm(lockPath, { force: true });
-		return true;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return true;
-		throw error;
+function compareVersions(left, right) {
+	for (const key of ["major", "minor", "patch"]) {
+		const leftValue = left[key];
+		const rightValue = right[key];
+		if (leftValue > rightValue) return 1;
+		if (leftValue < rightValue) return -1;
 	}
-}
-
-async function readState(statePath) {
-	try {
-		const raw = await readFile(statePath, "utf8");
-		const parsed = JSON.parse(raw);
-		return typeof parsed === "object" && parsed !== null ? parsed : {};
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
-		return {};
+	if (left.prerelease === undefined && right.prerelease !== undefined) return 1;
+	if (left.prerelease !== undefined && right.prerelease === undefined) return -1;
+	if (left.prerelease !== undefined && right.prerelease !== undefined) {
+		return left.prerelease.localeCompare(right.prerelease);
 	}
+	return 0;
 }
 
-async function writeState(statePath, state) {
-	await mkdir(dirname(statePath), { recursive: true });
-	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+function resolveInstalledVersionPath(env, pluginRoot) {
+	if (env.LAZYCODEX_INSTALLED_VERSION_PATH?.trim()) return env.LAZYCODEX_INSTALLED_VERSION_PATH;
+	return join(pluginRoot, INSTALLED_VERSION_FILE);
 }
 
-async function appendUpdateLog(env, now, event, details = {}) {
-	const logPath = resolveLogPath(env);
-	await mkdir(dirname(logPath), { recursive: true });
-	const entry = {
-		timestamp: new Date(now).toISOString(),
-		event,
-		...details,
-	};
-	await appendFile(logPath, `${JSON.stringify(entry)}\n`);
+function readVersionManifest(path) {
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		if (typeof parsed.version !== "string") return undefined;
+		const version = parsed.version.trim();
+		return version.length > 0 ? version : undefined;
+	} catch (error) {
+		if (error instanceof Error) return undefined;
+		throw error;
+	}
 }
 
 function parsePositiveInteger(value, fallback) {

package/packages/omo-codex/plugin/scripts/migrate-codex-config/catalog.mjs

@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const FALLBACK_CATALOG = {
+	version: "fallback.gpt-5.5-400k-reviewer-high",
+	current: {
+		model: "gpt-5.5",
+		model_context_window: 400_000,
+		model_reasoning_effort: "high",
+		plan_mode_reasoning_effort: "xhigh",
+	},
+	roles: {
+		default: {
+			model: "gpt-5.5",
+			model_context_window: 400_000,
+			model_reasoning_effort: "high",
+			plan_mode_reasoning_effort: "xhigh",
+		},
+		verifier: { model: "gpt-5.5", model_reasoning_effort: "high" },
+		worker: { model: "gpt-5.5", model_reasoning_effort: "high" },
+	},
+	managedProfiles: [
+		{
+			version: "legacy.gpt-5.5-1m",
+			match: {
+				model: "gpt-5.5",
+				model_context_window: 1_000_000,
+				model_reasoning_effort: "high",
+				plan_mode_reasoning_effort: "xhigh",
+			},
+		},
+		{ version: "legacy.gpt-5.5-272k", match: { model: "gpt-5.5", model_context_window: 272_000 } },
+	],
+};
+
+export async function readModelCatalog(env = process.env) {
+	const catalogPath =
+		env.LAZYCODEX_MODEL_CATALOG_PATH?.trim() || join(dirname(fileURLToPath(import.meta.url)), "..", "model-catalog.json");
+	try {
+		return parseCatalog(JSON.parse(await readFile(catalogPath, "utf8"))) ?? FALLBACK_CATALOG;
+	} catch (error) {
+		if (error instanceof Error) return FALLBACK_CATALOG;
+		throw error;
+	}
+}
+
+function parseCatalog(value) {
+	if (!isRecord(value) || !isRecord(value.current) || !Array.isArray(value.managedProfiles)) return null;
+	if (typeof value.version !== "string" || !isReasoningProfile(value.current)) return null;
+	const managedProfiles = [];
+	for (const profile of value.managedProfiles) {
+		if (!isRecord(profile) || typeof profile.version !== "string" || !isRecord(profile.match)) return null;
+		managedProfiles.push({ version: profile.version, match: profile.match });
+	}
+	return { version: value.version, current: value.current, managedProfiles, roles: isRecord(value.roles) ? value.roles : {} };
+}
+
+function isReasoningProfile(value) {
+	return (
+		isRecord(value) &&
+		typeof value.model === "string" &&
+		typeof value.model_context_window === "number" &&
+		typeof value.model_reasoning_effort === "string" &&
+		typeof value.plan_mode_reasoning_effort === "string"
+	);
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/config-paths.mjs

@@ -0,0 +1,44 @@
+import { lstat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+export async function configPaths({ env, cwd }) {
+	const codexHome = resolve(env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
+	const paths = new Set([join(codexHome, "config.toml")]);
+	for (const projectConfig of projectConfigPaths({ cwd, stopAt: homedir() })) {
+		if (!(await isRegularFile(projectConfig))) continue;
+		if (!(await isRegularDirectory(dirname(projectConfig)))) continue;
+		paths.add(projectConfig);
+	}
+	return [...paths];
+}
+
+function projectConfigPaths({ cwd, stopAt }) {
+	const paths = [];
+	let current = resolve(cwd);
+	const stop = resolve(stopAt);
+	while (true) {
+		paths.push(join(current, ".codex", "config.toml"));
+		if (current === stop || current === dirname(current)) break;
+		current = dirname(current);
+	}
+	return paths;
+}
+
+async function isRegularFile(path) {
+	try {
+		return (await lstat(path)).isFile();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function isRegularDirectory(path) {
+	try {
+		return (await lstat(path)).isDirectory();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/root-settings.mjs

@@ -0,0 +1,74 @@
+export const MANAGED_KEYS = ["model", "model_context_window", "model_reasoning_effort", "plan_mode_reasoning_effort"];
+
+export function ensureCodexReasoningConfig(config, profile) {
+	let next = replaceOrInsertRootSetting(config, "model", JSON.stringify(profile.model));
+	next = replaceOrInsertRootSetting(next, "model_context_window", profile.model_context_window.toString());
+	next = replaceOrInsertRootSetting(next, "model_reasoning_effort", JSON.stringify(profile.model_reasoning_effort));
+	next = replaceOrInsertRootSetting(next, "plan_mode_reasoning_effort", JSON.stringify(profile.plan_mode_reasoning_effort));
+	return next;
+}
+
+export function readRootSettings(config) {
+	const settings = {};
+	for (const line of config.split(/\n/)) {
+		if (isSectionHeader(line)) break;
+		for (const key of MANAGED_KEYS) {
+			if (!isRootSetting(line, key)) continue;
+			const value = parseTomlScalar(line.slice(line.indexOf("=") + 1));
+			if (value !== undefined) settings[key] = value;
+		}
+	}
+	return settings;
+}
+
+function parseTomlScalar(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+		try {
+			return JSON.parse(trimmed);
+		} catch (error) {
+			if (error instanceof SyntaxError) return undefined;
+			throw error;
+		}
+	}
+	const numeric = Number(trimmed);
+	return Number.isFinite(numeric) ? numeric : undefined;
+}
+
+function replaceOrInsertRootSetting(config, key, value) {
+	const lines = config.split(/\n/);
+	const output = [];
+	let replaced = false;
+	let inserted = false;
+	let inRoot = true;
+	for (const line of lines) {
+		const sectionHeader = isSectionHeader(line);
+		if (inRoot && !inserted && sectionHeader) {
+			if (!replaced) output.push(`${key} = ${value}`);
+			inserted = true;
+		}
+		if (inRoot && isRootSetting(line, key)) {
+			if (!replaced) {
+				output.push(`${key} = ${value}`);
+				replaced = true;
+			}
+			continue;
+		}
+		output.push(line);
+		if (sectionHeader) inRoot = false;
+	}
+	if (!replaced && !inserted) output.push(`${key} = ${value}`);
+	return output.join("\n");
+}
+
+function isSectionHeader(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+
+function isRootSetting(line, key) {
+	const trimmed = line.trimStart();
+	if (trimmed.startsWith("#") || trimmed.startsWith("[")) return false;
+	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+	return match?.[1] === key;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/state.mjs

@@ -0,0 +1,29 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export function resolveStatePath(env) {
+	const explicitStatePath = env.LAZYCODEX_MODEL_CATALOG_STATE_PATH?.trim();
+	if (explicitStatePath) return explicitStatePath;
+	const dataRoot = env.PLUGIN_DATA?.trim() || join(homedir(), ".local", "share", "lazycodex");
+	return join(dataRoot, "model-catalog-state.json");
+}
+
+export async function readState(statePath) {
+	try {
+		const parsed = JSON.parse(await readFile(statePath, "utf8"));
+		return isRecord(parsed) ? parsed : {};
+	} catch (error) {
+		if (error instanceof Error) return {};
+		throw error;
+	}
+}
+
+export async function writeState(statePath, state) {
+	await mkdir(dirname(statePath), { recursive: true });
+	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}