@chikhamx/voidx 3.6.0 → 3.7.0

package/bin/postinstall.js

@@ -4,14 +4,19 @@
 // Post-install: download a standalone Python, create venv, pip install voidx.
 // Uses only the bundled Python — never falls back to the system Python.
 
-const { createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, rmSync } = require("fs");
+const { createWriteStream, existsSync, mkdirSync, readFileSync, unlinkSync, rmSync } = require("fs");
 const { spawnSync } = require("child_process");
-const { join, dirname } = require("path");
+const { join } = require("path");
 const os = require("os");
-const fs = require("fs");
 const path = require("path");
 
 const pkg = require("../package.json");
+const {
+  installVerifyAndRepair,
+  resolveBundledCliWheel,
+  verifyPair,
+  writeMarkerAtomic,
+} = require("./runtime-install");
 
 // ── Python build metadata ──────────────────────────────────────────────────
 // Pin to a specific python-build-standalone release tag and CPython version.
@@ -248,13 +253,8 @@ function readMarker(markerPath) {
   try { return readFileSync(markerPath, "utf8"); } catch { return ""; }
 }
 
-function writeMarker(markerPath, content) {
-  mkdirSync(dirname(markerPath), { recursive: true });
-  writeFileSync(markerPath, content);
-}
-
-// ── pip install ────────────────────────────────────────────────────────────
-function pipInstall(venvPython, packageSpec, env) {
+// ── pip setup ──────────────────────────────────────────────────────────────
+function upgradePip(venvPython, env) {
   // Upgrade pip first to avoid resolver bugs in old versions
   const pipUpgradeEnv = Object.assign({}, env, {
     PIP_NO_INPUT: "1",
@@ -269,39 +269,6 @@ function pipInstall(venvPython, packageSpec, env) {
   if (pipUpgradeResult.error || pipUpgradeResult.status !== 0) {
     console.error("  ⚠️  Failed to upgrade pip, continuing with current version…");
   }
-
-  const pipEnv = Object.assign({}, env, {
-    PIP_NO_INPUT: "1",
-    PIP_DISABLE_PIP_VERSION_CHECK: "1",
-    PYTHON_KEYRING_BACKEND: "keyring.backends.null.Keyring",
-  });
-
-  const pipArgs = ["-m", "pip", "install", "--upgrade", "--no-cache-dir", "--progress-bar", "on"];
-
-  // Support custom PyPI index for users behind firewalls or in regions with slow PyPI access
-  const pipIndex = env.VOIDX_NPM_PIP_INDEX;
-  if (pipIndex) {
-    pipArgs.push("-i", pipIndex);
-    // Extract host for --trusted-host when using a custom index
-    try {
-      const indexUrl = new URL(pipIndex);
-      pipArgs.push("--trusted-host", indexUrl.hostname);
-    } catch {}
-  }
-
-  pipArgs.push(packageSpec);
-
-  const result = spawnSync(
-    venvPython,
-    pipArgs,
-    { encoding: "utf8", stdio: "inherit", windowsHide: true, env: pipEnv }
-  );
-  if (result.error) {
-    throw new Error(`pip install failed: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new Error("pip install failed. See errors above.");
-  }
 }
 
 // ── Main ───────────────────────────────────────────────────────────────────
@@ -322,8 +289,17 @@ async function main() {
 
   // Already set up and up-to-date?
   if (existsSync(executable) && readMarker(markerPath) === marker) {
-    console.error(`\n✅ voidx ${pkg.version} ready (cached)\n`);
-    return;
+    const verification = verifyPair({
+      venvPython,
+      executable,
+      expectedVersion: pkg.version,
+      env,
+    });
+    if (verification.ok) {
+      console.error(`\n✅ voidx ${pkg.version} ready (cached)\n`);
+      return;
+    }
+    console.error(`  ⚠️  Cached environment is invalid: ${verification.message}`);
   }
 
   // Step 1: Download bundled Python (required — no system Python fallback)
@@ -359,7 +335,7 @@ async function main() {
       console.error("    Extraction complete.");
 
       // Clean up archive to save disk
-      try { fs.unlinkSync(archivePath); } catch {}
+      try { unlinkSync(archivePath); } catch {}
     } catch (err) {
       // Clean up partial archive on failure
       try { unlinkSync(archivePath); } catch {}
@@ -403,23 +379,22 @@ async function main() {
     }
   }
 
-  // Step 3: pip install voidx (core runtime)
-  console.error("  [3/4] Installing voidx core…");
-  pipInstall(venvPython, packageSpec, env);
-
-  // Step 4: pip install bundled voidx_cli wheel (terminal frontend)
-  console.error("  [4/4] Installing voidx_cli frontend…");
+  // Step 3: install and verify the exact core/CLI pair
+  console.error("  [3/3] Installing and verifying voidx…");
+  upgradePip(venvPython, env);
   const npmDir = path.resolve(__dirname, "..");
-  const wheelPattern = `voidx_cli-${pkg.version}-py3-none-any.whl`;
-  const wheelPath = path.join(npmDir, wheelPattern);
-  if (existsSync(wheelPath)) {
-    pipInstall(venvPython, wheelPath, env);
-  } else {
-    console.error(`  ⚠️  Bundled ${wheelPattern} not found — TUI frontend unavailable`);
-  }
+  const wheelPath = resolveBundledCliWheel(npmDir, pkg.version);
+  installVerifyAndRepair({
+    venvPython,
+    executable,
+    coreSpec: packageSpec,
+    cliSpec: wheelPath,
+    expectedVersion: pkg.version,
+    env,
+  });
 
   // Done
-  writeMarker(markerPath, marker);
+  writeMarkerAtomic(markerPath, marker);
   console.error(`\n✅ voidx ${pkg.version} installed! Run: voidx\n`);
 }
 

package/bin/runtime-install.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const VERIFY_PROBE = String.raw`
+import importlib
+import json
+import os
+import re
+import subprocess
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+current_directory = os.path.normcase(os.path.realpath(os.getcwd()))
+sys.path = [
+    entry
+    for entry in sys.path
+    if entry and os.path.normcase(os.path.realpath(entry)) != current_directory
+]
+
+def installed_version(name):
+    try:
+        return version(name)
+    except PackageNotFoundError:
+        return None
+    except Exception:
+        return None
+
+payload = {
+    "core_version": installed_version("voidx"),
+    "cli_version": installed_version("voidx-cli"),
+    "core_import": False,
+    "cli_import": False,
+    "entrypoint_ok": False,
+    "entrypoint_version": None,
+}
+
+try:
+    importlib.import_module("voidx")
+    payload["core_import"] = True
+except Exception as exc:
+    payload["core_error"] = str(exc)
+
+try:
+    importlib.import_module("voidx_cli")
+    payload["cli_import"] = True
+except Exception as exc:
+    payload["cli_error"] = str(exc)
+
+try:
+    completed = subprocess.run(
+        [sys.argv[1], "--version"],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    output = (completed.stdout or completed.stderr or "").strip()
+    payload["entrypoint_ok"] = completed.returncode == 0
+    match = re.search(r"\d+\.\d+\.\d+(?:[A-Za-z0-9.+-]*)?", output)
+    payload["entrypoint_version"] = match.group(0) if match else None
+except Exception as exc:
+    payload["entrypoint_error"] = str(exc)
+
+print(json.dumps(payload))
+`;
+
+function resolveBundledCliWheel(npmDir, version) {
+  const filename = `voidx_cli-${version}-py3-none-any.whl`;
+  const wheelPath = path.join(npmDir, filename);
+  if (!fs.existsSync(wheelPath)) {
+    throw new Error(`Bundled ${filename} not found.`);
+  }
+  return wheelPath;
+}
+
+function pipEnvironment(env) {
+  return {
+    ...env,
+    PIP_NO_INPUT: "1",
+    PIP_DISABLE_PIP_VERSION_CHECK: "1",
+    PYTHON_KEYRING_BACKEND: "keyring.backends.null.Keyring",
+  };
+}
+
+function buildPipArgs({ coreSpec, cliSpec, forceReinstall, env }) {
+  const args = [
+    "-m",
+    "pip",
+    "install",
+    "--upgrade",
+    "--no-cache-dir",
+    "--progress-bar",
+    "on",
+  ];
+  if (forceReinstall) {
+    args.push("--force-reinstall");
+  }
+  const pipIndex = env.VOIDX_NPM_PIP_INDEX;
+  if (pipIndex) {
+    args.push("-i", pipIndex);
+    try {
+      args.push("--trusted-host", new URL(pipIndex).hostname);
+    } catch {}
+  }
+  args.push(coreSpec, cliSpec);
+  return args;
+}
+
+function installPair({
+  venvPython,
+  coreSpec,
+  cliSpec,
+  env,
+  forceReinstall = false,
+  runner = spawnSync,
+}) {
+  const result = runner(
+    venvPython,
+    buildPipArgs({ coreSpec, cliSpec, forceReinstall, env }),
+    {
+      encoding: "utf8",
+      stdio: "inherit",
+      windowsHide: true,
+      env: pipEnvironment(env),
+    }
+  );
+  if (result.error) {
+    throw new Error(`pip install failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error("pip install failed. See errors above.");
+  }
+  return result;
+}
+
+function verifyPair({
+  venvPython,
+  executable,
+  expectedVersion,
+  env,
+  runner = spawnSync,
+}) {
+  const result = runner(
+    venvPython,
+    ["-c", VERIFY_PROBE, executable],
+    {
+      encoding: "utf8",
+      windowsHide: true,
+      env,
+    }
+  );
+  if (result.error || result.status !== 0) {
+    const detail = result.error
+      ? result.error.message
+      : (result.stderr || result.stdout || `verification exited ${result.status}`).trim();
+    return {
+      ok: false,
+      coreVersion: null,
+      cliVersion: null,
+      message: `Installation verification failed: ${detail}`,
+    };
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse((result.stdout || "").trim());
+  } catch (error) {
+    return {
+      ok: false,
+      coreVersion: null,
+      cliVersion: null,
+      message: `Installation verification returned invalid data: ${error.message}`,
+    };
+  }
+
+  const coreVersion = payload.core_version || null;
+  const cliVersion = payload.cli_version || null;
+  const failures = [];
+  if (!coreVersion) failures.push("voidx is not installed");
+  if (!cliVersion) failures.push("voidx-cli is not installed");
+  if (!payload.core_import) failures.push("voidx is not importable");
+  if (!payload.cli_import) failures.push("voidx-cli is not importable");
+  if (!payload.entrypoint_ok) failures.push("voidx entry point failed");
+  if (coreVersion && cliVersion && coreVersion !== cliVersion) {
+    failures.push(`package versions differ (${coreVersion} != ${cliVersion})`);
+  }
+  if (coreVersion && payload.entrypoint_version !== coreVersion) {
+    failures.push(
+      `entry point version differs (${payload.entrypoint_version || "missing"} != ${coreVersion})`
+    );
+  }
+  if (coreVersion !== expectedVersion) {
+    failures.push(`voidx version is ${coreVersion || "missing"}, expected ${expectedVersion}`);
+  }
+  if (cliVersion !== expectedVersion) {
+    failures.push(`voidx-cli version is ${cliVersion || "missing"}, expected ${expectedVersion}`);
+  }
+
+  return {
+    ok: failures.length === 0,
+    coreVersion,
+    cliVersion,
+    message: failures.length === 0
+      ? `Verified voidx and voidx-cli ${expectedVersion}`
+      : failures.join("; "),
+  };
+}
+
+function installVerifyAndRepair(options) {
+  const installFn = options.installFn || installPair;
+  const verifyFn = options.verifyFn || verifyPair;
+  let initialInstallError = null;
+  try {
+    installFn({ ...options, forceReinstall: false });
+  } catch (error) {
+    initialInstallError = error;
+  }
+  let verification = verifyFn(options);
+  if (verification.ok) {
+    return verification;
+  }
+  let repairInstallError = null;
+  try {
+    installFn({ ...options, forceReinstall: true });
+  } catch (error) {
+    repairInstallError = error;
+  }
+  verification = verifyFn(options);
+  if (!verification.ok) {
+    const installError = repairInstallError || initialInstallError;
+    const detail = installError
+      ? `${verification.message}; ${installError.message}`
+      : verification.message;
+    throw new Error(detail);
+  }
+  return verification;
+}
+
+function writeMarkerAtomic(markerPath, marker) {
+  fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+  const temporaryPath = `${markerPath}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(temporaryPath, marker);
+    fs.renameSync(temporaryPath, markerPath);
+  } finally {
+    try {
+      fs.unlinkSync(temporaryPath);
+    } catch {}
+  }
+}
+
+module.exports = {
+  installPair,
+  installVerifyAndRepair,
+  resolveBundledCliWheel,
+  verifyPair,
+  writeMarkerAtomic,
+};

package/bin/voidx.js

@@ -7,6 +7,12 @@ const os = require("os");
 const path = require("path");
 
 const pkg = require("../package.json");
+const {
+  installVerifyAndRepair,
+  resolveBundledCliWheel,
+  verifyPair,
+  writeMarkerAtomic,
+} = require("./runtime-install");
 
 // ── Configuration ──────────────────────────────────────────────────────────
 
@@ -190,6 +196,7 @@ function resolveVoidxExecutable(venvDir) {
 
 function ensureVenv(python, venvDir, env) {
   const executable = resolveVoidxExecutable(venvDir);
+  const venvPython = resolveVenvPython(venvDir);
   if (env.VOIDX_NPM_SKIP_BOOTSTRAP === "1") {
     if (!fs.existsSync(executable)) {
       throw new Error(`voidx executable not found in ${venvDir}.`);
@@ -199,16 +206,26 @@ function ensureVenv(python, venvDir, env) {
 
   const markerPath = path.join(venvDir, ".voidx-install-version");
   const marker = `${pkg.version}\n${PBS_TAG}\n${PBS_CPYTHON}\n`;
-  if (fs.existsSync(executable) && readFile(markerPath) === marker) {
-    debug(env, `Using cached environment at ${venvDir}`);
-    return;
+  let needsInstall = !fs.existsSync(executable) || readMarker(markerPath) !== marker;
+  if (fs.existsSync(executable) && readMarker(markerPath) === marker) {
+    const verification = verifyPair({
+      venvPython,
+      executable,
+      expectedVersion: pkg.version,
+      env,
+    });
+    if (verification.ok) {
+      debug(env, `Using cached environment at ${venvDir}`);
+      return;
+    }
+    console.error(`  Cached environment is invalid: ${verification.message}`);
+    needsInstall = true;
   }
 
   // v2 → v3 migration: clean up legacy data before first v3 run
   runV2CleanupIfNeeded(venvDir, env);
 
   fs.mkdirSync(path.dirname(venvDir), { recursive: true });
-  const venvPython = resolveVenvPython(venvDir);
 
   // If venv exists but is corrupted (python binary missing), nuke and rebuild
   if (fs.existsSync(venvDir) && !fs.existsSync(venvPython)) {
@@ -242,7 +259,7 @@ function ensureVenv(python, venvDir, env) {
     }
   }
 
-  if (!fs.existsSync(executable) || readFile(markerPath) !== marker) {
+  if (needsInstall) {
     const packageSpec = env.VOIDX_NPM_PACKAGE_SPEC || `voidx==${pkg.version}`;
     console.error(
       `\n📦 Downloading ${packageSpec} and dependencies… ` +
@@ -264,49 +281,26 @@ function ensureVenv(python, venvDir, env) {
       console.error("  ⚠️  Failed to upgrade pip, continuing with current version…");
     }
 
-    const pipEnv = Object.assign({}, env, {
-      PIP_NO_INPUT: "1",
-      PIP_DISABLE_PIP_VERSION_CHECK: "1",
-      PYTHON_KEYRING_BACKEND: "keyring.backends.null.Keyring",
-    });
-
-    const pipArgs = ["-m", "pip", "install", "--upgrade", "--no-cache-dir", "--progress-bar", "on"];
-
-    // Support custom PyPI index
-    const pipIndex = env.VOIDX_NPM_PIP_INDEX;
-    if (pipIndex) {
-      pipArgs.push("-i", pipIndex);
-      try {
-        const indexUrl = new URL(pipIndex);
-        pipArgs.push("--trusted-host", indexUrl.hostname);
-      } catch {}
-    }
-
-    pipArgs.push(packageSpec);
-
-    const result = spawnSync(
+    const npmDir = path.resolve(__dirname, "..");
+    const wheelPath = resolveBundledCliWheel(npmDir, pkg.version);
+    installVerifyAndRepair({
       venvPython,
-      pipArgs,
-      { encoding: "utf8", stdio: "inherit", windowsHide: true, env: pipEnv }
-    );
-    if (result.error) {
-      throw new Error(
-        `Failed to install ${packageSpec}: ${result.error.message}`
-      );
-    }
-    if (result.status !== 0) {
-      throw new Error(`Failed to install ${packageSpec}. See errors above.`);
-    }
+      executable,
+      coreSpec: packageSpec,
+      cliSpec: wheelPath,
+      expectedVersion: pkg.version,
+      env,
+    });
   }
 
-  fs.writeFileSync(markerPath, marker);
+  writeMarkerAtomic(markerPath, marker);
 }
 
 // ── v2 → v3 migration ─────────────────────────────────────────────────────
 
 function runV2CleanupIfNeeded(venvDir, env) {
   const markerPath = path.join(venvDir, ".voidx-install-version");
-  const oldMarker = readFile(markerPath).trim();
+  const oldMarker = readMarker(markerPath).trim();
   if (!oldMarker) return; // fresh install, nothing to migrate
 
   const oldVersion = parseVersion(oldMarker.split("\n")[0]);
@@ -360,7 +354,7 @@ function runV2CleanupIfNeeded(venvDir, env) {
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
-function readFile(filePath) {
+function readMarker(filePath) {
   try {
     return fs.readFileSync(filePath, "utf8");
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chikhamx/voidx",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "npm launcher for voidx, a terminal AI coding agent.",
   "license": "MIT",
   "bin": {
@@ -31,6 +31,6 @@
   ],
   "scripts": {
     "postinstall": "node bin/postinstall.js",
-    "check": "node --check bin/voidx.js && node --check bin/postinstall.js"
+    "check": "node --check bin/voidx.js && node --check bin/postinstall.js && node --check bin/runtime-install.js"
   }
 }