@lavilas/codex 1.3.55 → 1.3.60

package/bin/codex.js

@@ -6,65 +6,23 @@ import { chmodSync, existsSync, readdirSync, statSync } from "fs";
 import { createRequire } from "node:module";
 import path from "path";
 import { fileURLToPath } from "url";
+import {
+  PLATFORM_PACKAGE_BY_TARGET,
+  detectPackageManager,
+  getCodexBinaryName,
+  resolveTargetTriple,
+  selectVendorInstallation,
+  updateCommandForPackageManager,
+} from "./platform-resolver.js";
 
 // __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const packageDir = path.join(__dirname, "..");
 const require = createRequire(import.meta.url);
 
-const PLATFORM_PACKAGE_BY_TARGET = {
-  "x86_64-unknown-linux-musl": "@lavilas/codex-linux-x64",
-  "aarch64-unknown-linux-musl": "@lavilas/codex-linux-arm64",
-  "x86_64-apple-darwin": "@lavilas/codex-darwin-x64",
-  "aarch64-apple-darwin": "@lavilas/codex-darwin-arm64",
-  "x86_64-pc-windows-msvc": "@lavilas/codex-win32-x64",
-  "aarch64-pc-windows-msvc": "@lavilas/codex-win32-arm64",
-};
-
 const { platform, arch } = process;
-
-let targetTriple = null;
-switch (platform) {
-  case "linux":
-  case "android":
-    switch (arch) {
-      case "x64":
-        targetTriple = "x86_64-unknown-linux-musl";
-        break;
-      case "arm64":
-        targetTriple = "aarch64-unknown-linux-musl";
-        break;
-      default:
-        break;
-    }
-    break;
-  case "darwin":
-    switch (arch) {
-      case "x64":
-        targetTriple = "x86_64-apple-darwin";
-        break;
-      case "arm64":
-        targetTriple = "aarch64-apple-darwin";
-        break;
-      default:
-        break;
-    }
-    break;
-  case "win32":
-    switch (arch) {
-      case "x64":
-        targetTriple = "x86_64-pc-windows-msvc";
-        break;
-      case "arm64":
-        targetTriple = "aarch64-pc-windows-msvc";
-        break;
-      default:
-        break;
-    }
-    break;
-  default:
-    break;
-}
+const targetTriple = resolveTargetTriple(platform, arch);
 
 if (!targetTriple) {
   throw new Error(`Unsupported platform: ${platform} (${arch})`);
@@ -75,8 +33,8 @@ if (!platformPackage) {
   throw new Error(`Unsupported target triple: ${targetTriple}`);
 }
 
-const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-const localVendorRoot = path.join(__dirname, "..", "vendor");
+const codexBinaryName = getCodexBinaryName(process.platform);
+const localVendorRoot = path.join(packageDir, "vendor");
 const localBinaryPath = path.join(
   localVendorRoot,
   targetTriple,
@@ -84,36 +42,24 @@ const localBinaryPath = path.join(
   codexBinaryName,
 );
 
-let vendorRoot;
-try {
-  const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
-  vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
-} catch {
-  if (existsSync(localBinaryPath)) {
-    vendorRoot = localVendorRoot;
-  } else {
-    const packageManager = detectPackageManager();
-    const updateCommand =
-      packageManager === "bun"
-        ? "bun install -g @lavilas/codex@latest"
-        : "npm install -g @lavilas/codex@latest";
-    throw new Error(
-      `Missing optional dependency ${platformPackage}. Reinstall Codex: ${updateCommand}`,
-    );
-  }
-}
+const selectedInstallation = selectVendorInstallation({
+  packageDir,
+  platformPackage,
+  targetTriple,
+  binaryName: codexBinaryName,
+  localVendorRoot,
+  requireResolve: (specifier) => require.resolve(specifier),
+});
 
-if (!vendorRoot) {
-  const packageManager = detectPackageManager();
-  const updateCommand =
-    packageManager === "bun"
-      ? "bun install -g @lavilas/codex@latest"
-      : "npm install -g @lavilas/codex@latest";
+if (!selectedInstallation) {
+  const packageManager = detectPackageManager({ installDir: __dirname });
+  const updateCommand = updateCommandForPackageManager(packageManager);
   throw new Error(
     `Missing optional dependency ${platformPackage}. Reinstall Codex: ${updateCommand}`,
   );
 }
 
+const vendorRoot = selectedInstallation.vendorRoot;
 const archRoot = path.join(vendorRoot, targetTriple);
 const binaryPath = path.join(archRoot, "codex", codexBinaryName);
 
@@ -133,31 +79,6 @@ function getUpdatedPath(newDirs) {
   return updatedPath;
 }
 
-/**
- * Use heuristics to detect the package manager that was used to install Codex
- * in order to give the user a hint about how to update it.
- */
-function detectPackageManager() {
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (/\bbun\//.test(userAgent)) {
-    return "bun";
-  }
-
-  const execPath = process.env.npm_execpath || "";
-  if (execPath.includes("bun")) {
-    return "bun";
-  }
-
-  if (
-    __dirname.includes(".bun/install/global") ||
-    __dirname.includes(".bun\\install\\global")
-  ) {
-    return "bun";
-  }
-
-  return userAgent ? "npm" : null;
-}
-
 const additionalDirs = [];
 const pathDir = path.join(archRoot, "path");
 if (existsSync(pathDir)) {
@@ -167,7 +88,7 @@ const updatedPath = getUpdatedPath(additionalDirs);
 
 const env = { ...process.env, PATH: updatedPath };
 const packageManagerEnvVar =
-  detectPackageManager() === "bun"
+  detectPackageManager({ installDir: __dirname }) === "bun"
     ? "CODEX_MANAGED_BY_BUN"
     : "CODEX_MANAGED_BY_NPM";
 env[packageManagerEnvVar] = "1";

package/bin/platform-resolver.js

@@ -0,0 +1,303 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+
+export const PLATFORM_PACKAGE_BY_TARGET = {
+  "x86_64-unknown-linux-musl": "@lavilas/codex-linux-x64",
+  "aarch64-unknown-linux-musl": "@lavilas/codex-linux-arm64",
+  "x86_64-apple-darwin": "@lavilas/codex-darwin-x64",
+  "aarch64-apple-darwin": "@lavilas/codex-darwin-arm64",
+  "x86_64-pc-windows-msvc": "@lavilas/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@lavilas/codex-win32-arm64",
+};
+
+export function resolveTargetTriple(
+  platformName = process.platform,
+  archName = process.arch,
+) {
+  switch (platformName) {
+    case "linux":
+    case "android":
+      switch (archName) {
+        case "x64":
+          return "x86_64-unknown-linux-musl";
+        case "arm64":
+          return "aarch64-unknown-linux-musl";
+        default:
+          return null;
+      }
+    case "darwin":
+      switch (archName) {
+        case "x64":
+          return "x86_64-apple-darwin";
+        case "arm64":
+          return "aarch64-apple-darwin";
+        default:
+          return null;
+      }
+    case "win32":
+      switch (archName) {
+        case "x64":
+          return "x86_64-pc-windows-msvc";
+        case "arm64":
+          return "aarch64-pc-windows-msvc";
+        default:
+          return null;
+      }
+    default:
+      return null;
+  }
+}
+
+export function getCodexBinaryName(platformName = process.platform) {
+  return platformName === "win32" ? "codex.exe" : "codex";
+}
+
+export function detectPackageManager(options = {}) {
+  const userAgent = options.userAgent ?? process.env.npm_config_user_agent ?? "";
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+
+  const execPath = options.execPath ?? process.env.npm_execpath ?? "";
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+
+  const installDir = options.installDir ?? "";
+  if (
+    installDir.includes(".bun/install/global") ||
+    installDir.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+
+  return userAgent ? "npm" : null;
+}
+
+export function updateCommandForPackageManager(packageManager) {
+  return packageManager === "bun"
+    ? "bun install -g @lavilas/codex@latest"
+    : "npm install -g @lavilas/codex@latest";
+}
+
+function packageNameSegments(packageName) {
+  return packageName.split("/");
+}
+
+function packageInstallDir(packageDir, platformPackage) {
+  return path.join(packageDir, "node_modules", ...packageNameSegments(platformPackage));
+}
+
+function readJsonFile(filePath) {
+  try {
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function vendorManifestFor(vendorRoot) {
+  return readJsonFile(path.join(vendorRoot, "manifest.json"));
+}
+
+function validateVendorRoot(candidate, targetTriple, binaryName) {
+  const binaryRelativePath = `${targetTriple}/codex/${binaryName}`;
+  const binaryPath = path.join(candidate.vendorRoot, binaryRelativePath);
+  if (!existsSync(binaryPath)) {
+    return { valid: false, reason: `missing ${binaryRelativePath}` };
+  }
+
+  let binaryStat;
+  try {
+    binaryStat = statSync(binaryPath);
+  } catch {
+    return { valid: false, reason: `unable to stat ${binaryRelativePath}` };
+  }
+  if (!binaryStat.isFile() || binaryStat.size <= 0) {
+    return { valid: false, reason: `invalid ${binaryRelativePath}` };
+  }
+
+  const manifest = vendorManifestFor(candidate.vendorRoot);
+  const expectedBinary = manifest?.files?.[binaryRelativePath];
+  if (
+    expectedBinary &&
+    typeof expectedBinary.size === "number" &&
+    expectedBinary.size !== binaryStat.size
+  ) {
+    return {
+      valid: false,
+      reason: `size mismatch for ${binaryRelativePath}`,
+    };
+  }
+
+  return {
+    valid: true,
+    binaryPath,
+    pathDir: path.join(candidate.vendorRoot, targetTriple, "path"),
+    vendorRoot: candidate.vendorRoot,
+    source: candidate.source,
+  };
+}
+
+function pushCandidate(candidates, seen, vendorRoot, source) {
+  if (!existsSync(vendorRoot)) {
+    return;
+  }
+  const resolvedRoot = path.resolve(vendorRoot);
+  if (seen.has(resolvedRoot)) {
+    return;
+  }
+  seen.add(resolvedRoot);
+  candidates.push({ vendorRoot: resolvedRoot, source });
+}
+
+export function collectVendorCandidates({
+  packageDir,
+  platformPackage,
+  localVendorRoot = path.join(packageDir, "vendor"),
+  requireResolve = null,
+}) {
+  const candidates = [];
+  const seen = new Set();
+
+  if (typeof requireResolve === "function") {
+    try {
+      const packageJsonPath = requireResolve(`${platformPackage}/package.json`);
+      pushCandidate(
+        candidates,
+        seen,
+        path.join(path.dirname(packageJsonPath), "vendor"),
+        "resolved-platform-package",
+      );
+    } catch {
+      // Ignore and continue with direct filesystem fallbacks.
+    }
+  }
+
+  pushCandidate(
+    candidates,
+    seen,
+    path.join(packageInstallDir(packageDir, platformPackage), "vendor"),
+    "nested-platform-package",
+  );
+
+  const scopeDir = path.resolve(packageDir, "..");
+  if (existsSync(scopeDir)) {
+    for (const entry of readdirSync(scopeDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !entry.name.startsWith(".codex-")) {
+        continue;
+      }
+      pushCandidate(
+        candidates,
+        seen,
+        path.join(scopeDir, entry.name, "node_modules", ...packageNameSegments(platformPackage), "vendor"),
+        `staged-platform-package:${entry.name}`,
+      );
+    }
+  }
+
+  pushCandidate(candidates, seen, localVendorRoot, "local-vendor-root");
+
+  return candidates;
+}
+
+export function selectVendorInstallation({
+  packageDir,
+  platformPackage,
+  targetTriple,
+  binaryName,
+  localVendorRoot = path.join(packageDir, "vendor"),
+  requireResolve = null,
+}) {
+  const candidates = collectVendorCandidates({
+    packageDir,
+    platformPackage,
+    localVendorRoot,
+    requireResolve,
+  });
+  for (const candidate of candidates) {
+    const result = validateVendorRoot(candidate, targetTriple, binaryName);
+    if (result.valid) {
+      return result;
+    }
+  }
+  return null;
+}
+
+export function buildPlatformPackageMetadata({
+  platformPackage,
+  version,
+  license = "Apache-2.0",
+  repository = null,
+  packageManager = null,
+}) {
+  const metadata = {
+    name: platformPackage,
+    version,
+    license,
+    files: ["vendor"],
+  };
+  if (repository) {
+    metadata.repository = repository;
+  }
+  if (packageManager) {
+    metadata.packageManager = packageManager;
+  }
+
+  if (platformPackage.includes("linux")) {
+    metadata.os = ["linux"];
+  } else if (platformPackage.includes("darwin")) {
+    metadata.os = ["darwin"];
+  } else if (platformPackage.includes("win32")) {
+    metadata.os = ["win32"];
+  }
+
+  if (platformPackage.endsWith("x64")) {
+    metadata.cpu = ["x64"];
+  } else if (platformPackage.endsWith("arm64")) {
+    metadata.cpu = ["arm64"];
+  }
+
+  metadata.engines = { node: ">=16" };
+  return metadata;
+}
+
+export function ensurePlatformPackageMetadata({
+  packageDir,
+  platformPackage,
+  version,
+  license = "Apache-2.0",
+  repository = null,
+  packageManager = null,
+}) {
+  const vendorRoot = path.join(packageDir, "vendor");
+  if (!existsSync(vendorRoot)) {
+    return null;
+  }
+
+  const packageJsonPath = path.join(packageDir, "package.json");
+  if (existsSync(packageJsonPath)) {
+    return packageJsonPath;
+  }
+
+  mkdirSync(packageDir, { recursive: true });
+  const metadata = buildPlatformPackageMetadata({
+    platformPackage,
+    version,
+    license,
+    repository,
+    packageManager,
+  });
+  writeFileSync(packageJsonPath, `${JSON.stringify(metadata, null, 2)}\n`);
+  return packageJsonPath;
+}

package/bin/postinstall.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  PLATFORM_PACKAGE_BY_TARGET,
+  detectPackageManager,
+  ensurePlatformPackageMetadata,
+  getCodexBinaryName,
+  resolveTargetTriple,
+  selectVendorInstallation,
+  updateCommandForPackageManager,
+} from "./platform-resolver.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageDir = path.join(__dirname, "..");
+const require = createRequire(import.meta.url);
+
+if (!packageDir.includes(`${path.sep}node_modules${path.sep}`)) {
+  process.exit(0);
+}
+
+const targetTriple = resolveTargetTriple();
+if (!targetTriple) {
+  process.exit(0);
+}
+
+const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+if (!platformPackage) {
+  process.exit(0);
+}
+
+const rootPackageJson = JSON.parse(
+  readFileSync(path.join(packageDir, "package.json"), "utf8"),
+);
+ensurePlatformPackageMetadata({
+  packageDir: path.join(packageDir, "node_modules", ...platformPackage.split("/")),
+  platformPackage,
+  version: rootPackageJson.optionalDependencies?.[platformPackage] ?? rootPackageJson.version,
+  license: rootPackageJson.license ?? "Apache-2.0",
+  repository: rootPackageJson.repository ?? null,
+  packageManager: rootPackageJson.packageManager ?? null,
+});
+
+const selectedInstallation = selectVendorInstallation({
+  packageDir,
+  platformPackage,
+  targetTriple,
+  binaryName: getCodexBinaryName(),
+  requireResolve: (specifier) => require.resolve(specifier),
+});
+
+if (!selectedInstallation) {
+  const packageManager = detectPackageManager({ installDir: __dirname });
+  const updateCommand = updateCommandForPackageManager(packageManager);
+  console.error(
+    `[lavilas/codex] Failed to validate ${platformPackage}. Reinstall Codex: ${updateCommand}`,
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(selectedInstallation.binaryPath, ["--version"], {
+  stdio: "pipe",
+  encoding: "utf8",
+  timeout: 15000,
+});
+
+if (result.error) {
+  console.error(
+    `[lavilas/codex] Native binary validation failed: ${result.error.message}`,
+  );
+  process.exit(1);
+}
+
+if (result.signal) {
+  console.error(
+    `[lavilas/codex] Native binary exited with signal ${result.signal} during install validation.`,
+  );
+  process.exit(1);
+}
+
+if (result.status !== 0) {
+  const details = (result.stderr || result.stdout || "").trim();
+  if (details) {
+    console.error(details);
+  }
+  process.exit(result.status ?? 1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lavilas/codex",
-  "version": "1.3.55",
+  "version": "1.3.60",
   "license": "Apache-2.0",
   "bin": {
     "codex": "bin/codex.js",
@@ -12,6 +12,10 @@
   "engines": {
     "node": ">=16"
   },
+  "scripts": {
+    "postinstall": "node bin/postinstall.js",
+    "test:bin": "node --test bin/platform-resolver.test.js"
+  },
   "files": [
     "bin"
   ],
@@ -22,11 +26,11 @@
   },
   "packageManager": "pnpm@10.29.3+sha512.498e1fb4cca5aa06c1dcf2611e6fafc50972ffe7189998c409e90de74566444298ffe43e6cd2acdc775ba1aa7cc5e092a8b7054c811ba8c5770f84693d33d2dc",
   "optionalDependencies": {
-    "@lavilas/codex-linux-x64": "1.3.55",
-    "@lavilas/codex-linux-arm64": "1.3.55",
-    "@lavilas/codex-darwin-x64": "1.3.55",
-    "@lavilas/codex-darwin-arm64": "1.3.55",
-    "@lavilas/codex-win32-x64": "1.3.55",
-    "@lavilas/codex-win32-arm64": "1.3.55"
+    "@lavilas/codex-linux-x64": "1.3.60",
+    "@lavilas/codex-linux-arm64": "1.3.60",
+    "@lavilas/codex-darwin-x64": "1.3.60",
+    "@lavilas/codex-darwin-arm64": "1.3.60",
+    "@lavilas/codex-win32-x64": "1.3.60",
+    "@lavilas/codex-win32-arm64": "1.3.60"
   }
 }