import fs from "node:fs";

import path from "node:path";

import {

assertPathInside,

configPath,

findPackageJson,

managedNpmRoot,

npmProjectRootForInstalledPackage,

readInstallRecords,

readJson,

realPathMaybe,

stateDir,

} from "../codex-install-utils.mjs";

const command = process.argv[2];

const readJson = (file) => JSON.parse(fs.readFileSync(file, "utf8"));

const allowBetaCompatDiagnostics =

process.env.OPENCLAW_CODEX_NPM_PLUGIN_ALLOW_BETA_COMPAT_DIAGNOSTICS === "1";

function stateDir() {

return process.env.OPENCLAW_STATE_DIR || path.join(process.env.HOME, ".openclaw");

}

function configPath() {

return process.env.OPENCLAW_CONFIG_PATH || path.join(stateDir(), "openclaw.json");

}

function realPathMaybe(filePath) {

try {

return fs.realpathSync(filePath);

} catch {

return path.resolve(filePath);

}

}

function assertPathInside(parentPath, childPath, label) {

const parent = realPathMaybe(parentPath);

const child = realPathMaybe(childPath);

const relative = path.relative(parent, child);

if (relative.startsWith("..") || path.isAbsolute(relative)) {

throw new Error(`${label} resolved outside ${parentPath}: ${child}`);

}

}

function configure() {

const modelRef = process.argv[3] || "codex/gpt-5.4";

const state = stateDir();

}

function readInstallRecord() {

const indexPath = path.join(stateDir(), "plugins", "installs.json");

const index = readJson(indexPath);

const record = (index.installRecords || index.records || {}).codex;

const record = readInstallRecords().codex;

if (!record) {

throw new Error("missing codex install record");

}

return record;

}

function readInstallRecords() {

const indexPath = path.join(stateDir(), "plugins", "installs.json");

if (!fs.existsSync(indexPath)) {

return {};

}

const index = readJson(indexPath);

return index.installRecords || index.records || {};

}

function normalizePluginSpec(spec) {

if (spec.startsWith("npm:")) {

return {

}

}

function managedNpmRoot() {

return path.join(stateDir(), "npm");

}

function codexInstallPath() {

const record = readInstallRecord();

if (typeof record.installPath !== "string" || record.installPath.length === 0) {

}

function codexNpmProjectRoot() {

const installPath = codexInstallPath();

const packageRoot = "@openclaw/codex"

.split("/")

.reduce((current) => path.dirname(current), installPath);

return path.basename(packageRoot) === "node_modules"

? path.dirname(packageRoot)

: managedNpmRoot();

return npmProjectRootForInstalledPackage(codexInstallPath(), "@openclaw/codex");

}

function findPackageJson(packageName) {

const parts = packageName.split("/");

function findCodexPackageJson(packageName) {

const projectRoot = codexNpmProjectRoot();

const candidates =

packageName.startsWith("@") && parts.length === 2

? [

path.join(projectRoot, "node_modules", parts[0], parts[1], "package.json"),

path.join(codexInstallPath(), "node_modules", parts[0], parts[1], "package.json"),

path.join(managedNpmRoot(), "node_modules", parts[0], parts[1], "package.json"),

]

: [

path.join(projectRoot, "node_modules", packageName, "package.json"),

path.join(codexInstallPath(), "node_modules", packageName, "package.json"),

path.join(managedNpmRoot(), "node_modules", packageName, "package.json"),

];

return candidates.find((candidate) => fs.existsSync(candidate));

return findPackageJson(packageName, [projectRoot, codexInstallPath(), managedNpmRoot()]);

}

function assertNpmDeps() {

throw new Error(`unexpected codex package name: ${pluginPackage.name}`);

}

const openAiCodexPackageJson = findPackageJson("@openai/codex");

const openAiCodexPackageJson = findCodexPackageJson("@openai/codex");

if (!openAiCodexPackageJson) {

throw new Error("missing @openai/codex dependency under .openclaw/npm");

}

if (candidate) {

return candidate;

}

const packageJson = findPackageJson("@openai/codex");

const packageJson = findCodexPackageJson("@openai/codex");

if (!packageJson) {

throw new Error("cannot resolve Codex binary without @openai/codex package");

}