@lavilas/codex 1.3.60 → 1.3.61

package/bin/codex.js

@@ -2,7 +2,7 @@
 // Unified entry point for the Codex CLI.
 
 import { spawn } from "node:child_process";
-import { chmodSync, existsSync, readdirSync, statSync } from "fs";
+import { chmodSync, existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { createRequire } from "node:module";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -11,6 +11,7 @@ import {
   detectPackageManager,
   getCodexBinaryName,
   resolveTargetTriple,
+  resolveRuntimeCacheRoot,
   selectVendorInstallation,
   updateCommandForPackageManager,
 } from "./platform-resolver.js";
@@ -20,6 +21,9 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageDir = path.join(__dirname, "..");
 const require = createRequire(import.meta.url);
+const rootPackageJson = JSON.parse(
+  readFileSync(path.join(packageDir, "package.json"), "utf8"),
+);
 
 const { platform, arch } = process;
 const targetTriple = resolveTargetTriple(platform, arch);
@@ -35,18 +39,14 @@ if (!platformPackage) {
 
 const codexBinaryName = getCodexBinaryName(process.platform);
 const localVendorRoot = path.join(packageDir, "vendor");
-const localBinaryPath = path.join(
-  localVendorRoot,
-  targetTriple,
-  "codex",
-  codexBinaryName,
-);
 
 const selectedInstallation = selectVendorInstallation({
   packageDir,
   platformPackage,
   targetTriple,
   binaryName: codexBinaryName,
+  packageVersion: rootPackageJson.version ?? null,
+  runtimeCacheRoot: resolveRuntimeCacheRoot(),
   localVendorRoot,
   requireResolve: (specifier) => require.resolve(specifier),
 });
@@ -59,9 +59,7 @@ if (!selectedInstallation) {
   );
 }
 
-const vendorRoot = selectedInstallation.vendorRoot;
-const archRoot = path.join(vendorRoot, targetTriple);
-const binaryPath = path.join(archRoot, "codex", codexBinaryName);
+const binaryPath = selectedInstallation.binaryPath;
 
 // Use an asynchronous spawn instead of spawnSync so that Node is able to
 // respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
@@ -80,7 +78,7 @@ function getUpdatedPath(newDirs) {
 }
 
 const additionalDirs = [];
-const pathDir = path.join(archRoot, "path");
+const pathDir = selectedInstallation.pathDir;
 if (existsSync(pathDir)) {
   additionalDirs.push(pathDir);
 }

package/bin/platform-resolver.js

@@ -1,11 +1,19 @@
 import {
+  chmodSync,
+  copyFileSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readFileSync,
   readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
+import { createHash } from "node:crypto";
+import os from "node:os";
 import path from "node:path";
 
 export const PLATFORM_PACKAGE_BY_TARGET = {
@@ -95,6 +103,73 @@ function packageInstallDir(packageDir, platformPackage) {
   return path.join(packageDir, "node_modules", ...packageNameSegments(platformPackage));
 }
 
+function packageCacheBaseDir(runtimeCacheRoot, platformPackage) {
+  if (!runtimeCacheRoot) {
+    return null;
+  }
+  return path.join(runtimeCacheRoot, ...packageNameSegments(platformPackage));
+}
+
+function packageCacheDir(
+  runtimeCacheRoot,
+  platformPackage,
+  packageVersion,
+  manifestDigest = null,
+) {
+  if (!runtimeCacheRoot || !packageVersion) {
+    return null;
+  }
+  const cacheBaseDir = packageCacheBaseDir(runtimeCacheRoot, platformPackage);
+  if (!cacheBaseDir) {
+    return null;
+  }
+  const cacheKey = manifestDigest
+    ? `${packageVersion}-${manifestDigest.slice(0, 12)}`
+    : packageVersion;
+  return path.join(cacheBaseDir, cacheKey);
+}
+
+export function resolveRuntimeCacheRoot({
+  env = process.env,
+  homeDir = (() => {
+    try {
+      return os.homedir();
+    } catch {
+      return null;
+    }
+  })(),
+  platformName = process.platform,
+} = {}) {
+  const explicitCacheDir =
+    env.LAVILAS_CODEX_VENDOR_CACHE_DIR ?? env.CODEX_VENDOR_CACHE_DIR ?? null;
+  if (explicitCacheDir) {
+    return path.resolve(explicitCacheDir);
+  }
+
+  const codexHome =
+    env.CODEX_HOME ?? (homeDir ? path.join(homeDir, ".codex") : null);
+  if (codexHome) {
+    return path.join(codexHome, "runtime", "npm");
+  }
+
+  if (!homeDir) {
+    return null;
+  }
+
+  switch (platformName) {
+    case "win32": {
+      const localAppData = env.LOCALAPPDATA || path.join(homeDir, "AppData", "Local");
+      return path.join(localAppData, "Lavilas", "Codex", "runtime", "npm");
+    }
+    case "darwin":
+      return path.join(homeDir, "Library", "Caches", "Lavilas", "Codex", "runtime", "npm");
+    default: {
+      const xdgCacheHome = env.XDG_CACHE_HOME || path.join(homeDir, ".cache");
+      return path.join(xdgCacheHome, "lavilas-codex", "runtime", "npm");
+    }
+  }
+}
+
 function readJsonFile(filePath) {
   try {
     if (!existsSync(filePath)) {
@@ -110,7 +185,89 @@ function vendorManifestFor(vendorRoot) {
   return readJsonFile(path.join(vendorRoot, "manifest.json"));
 }
 
-function validateVendorRoot(candidate, targetTriple, binaryName) {
+function vendorManifestDigest(vendorRoot) {
+  try {
+    const manifestContents = readFileSync(path.join(vendorRoot, "manifest.json"));
+    return createHash("sha256").update(manifestContents).digest("hex");
+  } catch {
+    return null;
+  }
+}
+
+function readyMarkerPathFor(vendorRoot) {
+  return path.join(path.dirname(vendorRoot), ".ready.json");
+}
+
+function readyMarkerFor(vendorRoot) {
+  return readJsonFile(readyMarkerPathFor(vendorRoot));
+}
+
+function validateVendorManifest(manifest, vendorRoot) {
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, reason: "missing manifest.json" };
+  }
+
+  const files = manifest.files;
+  if (!files || typeof files !== "object") {
+    return { valid: false, reason: "invalid manifest.json files map" };
+  }
+
+  for (const [relativePath, metadata] of Object.entries(files)) {
+    const candidatePath = path.join(vendorRoot, relativePath);
+    if (!existsSync(candidatePath)) {
+      return { valid: false, reason: `missing ${relativePath}` };
+    }
+
+    let candidateStat;
+    try {
+      candidateStat = statSync(candidatePath);
+    } catch {
+      return { valid: false, reason: `unable to stat ${relativePath}` };
+    }
+
+    if (!candidateStat.isFile() || candidateStat.size <= 0) {
+      return { valid: false, reason: `invalid ${relativePath}` };
+    }
+
+    if (
+      metadata &&
+      typeof metadata === "object" &&
+      typeof metadata.size === "number" &&
+      metadata.size !== candidateStat.size
+    ) {
+      return { valid: false, reason: `size mismatch for ${relativePath}` };
+    }
+  }
+
+  return { valid: true };
+}
+
+function validateVendorRoot(
+  candidate,
+  targetTriple,
+  binaryName,
+  { requireReadyMarker = false } = {},
+) {
+  const manifest = vendorManifestFor(candidate.vendorRoot);
+  const manifestValidation = validateVendorManifest(manifest, candidate.vendorRoot);
+  if (!manifestValidation.valid) {
+    return manifestValidation;
+  }
+
+  if (requireReadyMarker) {
+    const readyMarker = readyMarkerFor(candidate.vendorRoot);
+    if (!readyMarker || typeof readyMarker !== "object") {
+      return { valid: false, reason: "missing .ready.json" };
+    }
+    if (
+      candidate.cacheKey &&
+      typeof readyMarker.cacheKey === "string" &&
+      readyMarker.cacheKey !== candidate.cacheKey
+    ) {
+      return { valid: false, reason: "runtime cache marker mismatch" };
+    }
+  }
+
   const binaryRelativePath = `${targetTriple}/codex/${binaryName}`;
   const binaryPath = path.join(candidate.vendorRoot, binaryRelativePath);
   if (!existsSync(binaryPath)) {
@@ -127,7 +284,6 @@ function validateVendorRoot(candidate, targetTriple, binaryName) {
     return { valid: false, reason: `invalid ${binaryRelativePath}` };
   }
 
-  const manifest = vendorManifestFor(candidate.vendorRoot);
   const expectedBinary = manifest?.files?.[binaryRelativePath];
   if (
     expectedBinary &&
@@ -161,6 +317,199 @@ function pushCandidate(candidates, seen, vendorRoot, source) {
   candidates.push({ vendorRoot: resolvedRoot, source });
 }
 
+function copyDirectoryRecursive(sourceDir, destinationDir) {
+  mkdirSync(destinationDir, { recursive: true });
+
+  for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const destinationPath = path.join(destinationDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectoryRecursive(sourcePath, destinationPath);
+      continue;
+    }
+
+    if (entry.isSymbolicLink()) {
+      const resolvedPath = realpathSync(sourcePath);
+      const resolvedStat = statSync(resolvedPath);
+      if (resolvedStat.isDirectory()) {
+        copyDirectoryRecursive(resolvedPath, destinationPath);
+      } else {
+        copyFileSync(resolvedPath, destinationPath);
+        chmodSync(destinationPath, resolvedStat.mode);
+      }
+      continue;
+    }
+
+    const sourceStat = lstatSync(sourcePath);
+    if (sourceStat.isDirectory()) {
+      copyDirectoryRecursive(sourcePath, destinationPath);
+      continue;
+    }
+
+    copyFileSync(sourcePath, destinationPath);
+    chmodSync(destinationPath, sourceStat.mode);
+  }
+}
+
+function runtimeCacheCandidate({
+  runtimeCacheRoot,
+  platformPackage,
+  packageVersion,
+  manifestDigest = null,
+  source = "runtime-cache",
+}) {
+  const cacheDir = packageCacheDir(
+    runtimeCacheRoot,
+    platformPackage,
+    packageVersion,
+    manifestDigest,
+  );
+  if (!cacheDir) {
+    return null;
+  }
+  return {
+    vendorRoot: path.join(cacheDir, "vendor"),
+    cacheKey: path.basename(cacheDir),
+    source,
+  };
+}
+
+function collectRuntimeCacheCandidates({
+  runtimeCacheRoot,
+  platformPackage,
+  packageVersion,
+}) {
+  const cacheBaseDir = packageCacheBaseDir(runtimeCacheRoot, platformPackage);
+  if (!cacheBaseDir || !packageVersion || !existsSync(cacheBaseDir)) {
+    return [];
+  }
+
+  const versionPrefix = `${packageVersion}-`;
+  return readdirSync(cacheBaseDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith(versionPrefix))
+    .map((entry) => ({
+      vendorRoot: path.join(cacheBaseDir, entry.name, "vendor"),
+      cacheKey: entry.name,
+      source: "runtime-cache",
+    }));
+}
+
+function materializeRuntimeCache({
+  runtimeCacheRoot,
+  platformPackage,
+  packageVersion,
+  targetTriple,
+  binaryName,
+  sourceInstallation,
+}) {
+  const manifestDigest = vendorManifestDigest(sourceInstallation.vendorRoot);
+  const cacheDir = packageCacheDir(
+    runtimeCacheRoot,
+    platformPackage,
+    packageVersion,
+    manifestDigest,
+  );
+  if (!cacheDir || !manifestDigest) {
+    return null;
+  }
+
+  const cachedCandidate = runtimeCacheCandidate({
+    runtimeCacheRoot,
+    platformPackage,
+    packageVersion,
+    manifestDigest,
+    source: `runtime-cache:${sourceInstallation.source}`,
+  });
+  if (!cachedCandidate) {
+    return null;
+  }
+
+  const cachedInstallation = validateVendorRoot(
+    cachedCandidate,
+    targetTriple,
+    binaryName,
+    { requireReadyMarker: true },
+  );
+  if (cachedInstallation.valid) {
+    return cachedInstallation;
+  }
+
+  const cacheParentDir = path.dirname(cacheDir);
+  mkdirSync(cacheParentDir, { recursive: true });
+
+  const tempCacheDir = path.join(
+    cacheParentDir,
+    `.tmp-${packageVersion}-${process.pid}-${Date.now()}-${Math.random()
+      .toString(16)
+      .slice(2)}`,
+  );
+
+  try {
+    copyDirectoryRecursive(sourceInstallation.vendorRoot, path.join(tempCacheDir, "vendor"));
+
+    const stagedInstallation = validateVendorRoot(
+      {
+        vendorRoot: path.join(tempCacheDir, "vendor"),
+        cacheKey: path.basename(cacheDir),
+        source: `runtime-cache-staging:${sourceInstallation.source}`,
+      },
+      targetTriple,
+      binaryName,
+    );
+    if (!stagedInstallation.valid) {
+      return null;
+    }
+
+    const readyMarker = {
+      cacheKey: path.basename(cacheDir),
+      platformPackage,
+      packageVersion,
+      targetTriple,
+      manifestSha256: manifestDigest,
+      createdAt: new Date().toISOString(),
+    };
+    writeFileSync(
+      readyMarkerPathFor(path.join(tempCacheDir, "vendor")),
+      `${JSON.stringify(readyMarker, null, 2)}\n`,
+    );
+
+    try {
+      renameSync(tempCacheDir, cacheDir);
+    } catch {
+      const currentInstallation = validateVendorRoot(
+        cachedCandidate,
+        targetTriple,
+        binaryName,
+        { requireReadyMarker: true },
+      );
+      if (currentInstallation.valid) {
+        return currentInstallation;
+      }
+
+      const currentReadyMarker = readyMarkerFor(cachedCandidate.vendorRoot);
+      if (!currentReadyMarker && existsSync(cacheDir)) {
+        rmSync(cacheDir, { recursive: true, force: true });
+        renameSync(tempCacheDir, cacheDir);
+      } else {
+        return null;
+      }
+    }
+
+    const finalInstallation = validateVendorRoot(
+      cachedCandidate,
+      targetTriple,
+      binaryName,
+      { requireReadyMarker: true },
+    );
+    return finalInstallation.valid ? finalInstallation : null;
+  } catch {
+    return null;
+  } finally {
+    rmSync(tempCacheDir, { recursive: true, force: true });
+  }
+}
+
 export function collectVendorCandidates({
   packageDir,
   platformPackage,
@@ -216,6 +565,8 @@ export function selectVendorInstallation({
   platformPackage,
   targetTriple,
   binaryName,
+  packageVersion = null,
+  runtimeCacheRoot = null,
   localVendorRoot = path.join(packageDir, "vendor"),
   requireResolve = null,
 }) {
@@ -228,9 +579,35 @@ export function selectVendorInstallation({
   for (const candidate of candidates) {
     const result = validateVendorRoot(candidate, targetTriple, binaryName);
     if (result.valid) {
-      return result;
+      return (
+        materializeRuntimeCache({
+          runtimeCacheRoot,
+          platformPackage,
+          packageVersion,
+          targetTriple,
+          binaryName,
+          sourceInstallation: result,
+        }) ?? result
+      );
+    }
+  }
+
+  for (const cachedCandidate of collectRuntimeCacheCandidates({
+    runtimeCacheRoot,
+    platformPackage,
+    packageVersion,
+  })) {
+    const cachedInstallation = validateVendorRoot(
+      cachedCandidate,
+      targetTriple,
+      binaryName,
+      { requireReadyMarker: true },
+    );
+    if (cachedInstallation.valid) {
+      return cachedInstallation;
     }
   }
+
   return null;
 }
 

package/bin/postinstall.js

@@ -11,6 +11,7 @@ import {
   ensurePlatformPackageMetadata,
   getCodexBinaryName,
   resolveTargetTriple,
+  resolveRuntimeCacheRoot,
   selectVendorInstallation,
   updateCommandForPackageManager,
 } from "./platform-resolver.js";
@@ -51,6 +52,8 @@ const selectedInstallation = selectVendorInstallation({
   platformPackage,
   targetTriple,
   binaryName: getCodexBinaryName(),
+  packageVersion: rootPackageJson.version ?? null,
+  runtimeCacheRoot: resolveRuntimeCacheRoot(),
   requireResolve: (specifier) => require.resolve(specifier),
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lavilas/codex",
-  "version": "1.3.60",
+  "version": "1.3.61",
   "license": "Apache-2.0",
   "bin": {
     "codex": "bin/codex.js",
@@ -26,11 +26,11 @@
   },
   "packageManager": "pnpm@10.29.3+sha512.498e1fb4cca5aa06c1dcf2611e6fafc50972ffe7189998c409e90de74566444298ffe43e6cd2acdc775ba1aa7cc5e092a8b7054c811ba8c5770f84693d33d2dc",
   "optionalDependencies": {
-    "@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"
+    "@lavilas/codex-linux-x64": "1.3.61",
+    "@lavilas/codex-linux-arm64": "1.3.61",
+    "@lavilas/codex-darwin-x64": "1.3.61",
+    "@lavilas/codex-darwin-arm64": "1.3.61",
+    "@lavilas/codex-win32-x64": "1.3.61",
+    "@lavilas/codex-win32-arm64": "1.3.61"
   }
 }