iterate-harness 1.8.0 → 1.9.1

package/bin/ih.js

@@ -3,12 +3,15 @@
 
 "use strict";
 
-const { BootstrapError, runHarness } = require("../lib/bootstrap");
+const { reportBootstrapFailure, runHarness } = require("../lib/bootstrap");
+
+const fail = (error) => {
+  reportBootstrapFailure(error);
+  process.exit(1);
+};
 
 try {
-  runHarness(process.argv.slice(2));
+  Promise.resolve(runHarness(process.argv.slice(2))).catch(fail);
 } catch (error) {
-  const message = error instanceof BootstrapError ? error.message : (error && error.stack) || error;
-  process.stderr.write(`[iterate-harness] ${message}\n`);
-  process.exit(1);
+  fail(error);
 }

package/bin/iterate-harness.js

@@ -3,12 +3,15 @@
 
 "use strict";
 
-const { BootstrapError, runHarness } = require("../lib/bootstrap");
+const { reportBootstrapFailure, runHarness } = require("../lib/bootstrap");
+
+const fail = (error) => {
+  reportBootstrapFailure(error);
+  process.exit(1);
+};
 
 try {
-  runHarness(process.argv.slice(2));
+  Promise.resolve(runHarness(process.argv.slice(2))).catch(fail);
 } catch (error) {
-  const message = error instanceof BootstrapError ? error.message : (error && error.stack) || error;
-  process.stderr.write(`[iterate-harness] ${message}\n`);
-  process.exit(1);
+  fail(error);
 }

package/lib/bootstrap.js

@@ -8,7 +8,11 @@
  * 1. Resolve a Python interpreter >= 3.10 (env override first).
  * 2. Create/reuse the venv at ~/.iterate-harness-npm/venv.
  * 3. pip-install the harness release tarball pinned to THIS npm package's
- *    version (lockstep: npm 1.6.0 installs harness v1.6.0).
+ *    version (lockstep: npm 1.6.0 installs harness v1.6.0). When pip cannot
+ *    fetch the tarball (typically a broken Python TLS trust store on macOS
+ *    python.org builds), the wrapper retries by downloading the tarball with
+ *    Node's own https stack — and, failing that, with curl (system trust
+ *    store) — then pip-installs the local file.
  * 4. Stamp the installed version; a mismatch (npm upgrade) triggers a
  *    re-install on the next run.
  * 5. Spawn the venv's `ih` with argv/stdio/signals forwarded and the exit
@@ -21,6 +25,8 @@
 
 const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
+const http = require("http");
+const https = require("https");
 const os = require("os");
 const path = require("path");
 
@@ -31,6 +37,11 @@ const path = require("path");
 const RUNTIME_DIR_NAME = ".iterate-harness-npm";
 const VENV_DIR_NAME = "venv";
 const STAMP_FILE_NAME = "version.stamp";
+const TARBALL_CACHE_DIR_NAME = "cache";
+
+const MAX_DOWNLOAD_REDIRECTS = 5;
+const DOWNLOAD_TIMEOUT_MS = 120000;
+const CURL_MAX_TIME_SECONDS = 240;
 
 const PYTHON_ENV_VAR = "ITERATE_HARNESS_PYTHON";
 const HOME_ENV_VAR = "ITERATE_HARNESS_NPM_HOME";
@@ -110,6 +121,18 @@ function needsBootstrap(stampContent, expectedVersion) {
   return String(stampContent || "").trim() !== String(expectedVersion || "").trim();
 }
 
+function isRemoteHttpUrl(target) {
+  return /^https?:\/\//i.test(String(target || ""));
+}
+
+function downloadCachePath(homeDir, version) {
+  return path.join(homeDir, TARBALL_CACHE_DIR_NAME, `iterate-harness-${version}.tar.gz`);
+}
+
+function pipInstallArgs(target) {
+  return ["-m", "pip", "install", "--upgrade", "--force-reinstall", target];
+}
+
 // ---------------------------------------------------------------------------
 // Runtime resolution
 // ---------------------------------------------------------------------------
@@ -210,7 +233,158 @@ function installUrl(version, env) {
   return releaseTarballUrl(version);
 }
 
-function bootstrap(homeDir, version, env) {
+// ---------------------------------------------------------------------------
+// Tarball download fallback (Node-side TLS — survives broken pip trust stores)
+// ---------------------------------------------------------------------------
+
+function downloadFile(url, dest, redirectBudget) {
+  const budget = redirectBudget === undefined ? MAX_DOWNLOAD_REDIRECTS : redirectBudget;
+  return new Promise((resolve, reject) => {
+    if (budget < 0) {
+      reject(new BootstrapError(`too many redirects while downloading ${url}`));
+      return;
+    }
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch (error) {
+      reject(new BootstrapError(`invalid download URL ${url}: ${error.message}`));
+      return;
+    }
+    const client = parsed.protocol === "http:" ? http : https;
+    const request = client.get(url, { timeout: DOWNLOAD_TIMEOUT_MS }, (response) => {
+      const status = response.statusCode || 0;
+      if (status >= 300 && status < 400 && response.headers.location) {
+        response.resume();
+        const nextUrl = new URL(response.headers.location, url).toString();
+        resolve(downloadFile(nextUrl, dest, budget - 1));
+        return;
+      }
+      if (status < 200 || status >= 300) {
+        response.resume();
+        reject(new BootstrapError(`downloading ${url} failed with HTTP ${status}`));
+        return;
+      }
+      const file = fs.createWriteStream(dest);
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close((closeError) => {
+          if (closeError) {
+            reject(closeError);
+            return;
+          }
+          resolve(dest);
+        });
+      });
+      file.on("error", (fileError) => {
+        file.destroy();
+        reject(fileError);
+      });
+    });
+    request.on("timeout", () => {
+      request.destroy(new BootstrapError(`downloading ${url} timed out`));
+    });
+    request.on("error", (requestError) => reject(requestError));
+  });
+}
+
+function curlDownload(url, dest, spawnFn) {
+  const runner = spawnFn || spawnSync;
+  const result = runner("curl", [
+    "-fsSL",
+    "--max-time",
+    String(CURL_MAX_TIME_SECONDS),
+    "-o",
+    dest,
+    url,
+  ], {
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+  });
+  if (result.error) {
+    return {
+      ok: false,
+      error: new BootstrapError(`curl download of ${url} failed: ${result.error.message}`),
+    };
+  }
+  if (result.status !== 0) {
+    const detail = `${result.stderr || result.stdout || ""}`.trim() || `exit code ${result.status}`;
+    return { ok: false, error: new BootstrapError(`curl download of ${url} failed: ${detail}`) };
+  }
+  return { ok: true, error: undefined };
+}
+
+async function downloadTarballTo(url, dest, deps) {
+  const nodeDownload = (deps && deps.nodeDownload) || downloadFile;
+  const curlDownloadFn = (deps && deps.curlDownload) || curlDownload;
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+  const attempts = [
+    {
+      name: "node-https",
+      run: () => nodeDownload(url, dest),
+    },
+    {
+      name: "curl",
+      run: async () => {
+        const outcome = curlDownloadFn(url, dest);
+        if (!outcome.ok) {
+          throw outcome.error;
+        }
+        return dest;
+      },
+    },
+  ];
+
+  const failures = [];
+  for (const attempt of attempts) {
+    try {
+      await attempt.run();
+      return dest;
+    } catch (error) {
+      failures.push(`${attempt.name}: ${error.message}`);
+      process.stderr.write(
+        `[iterate-harness] ${attempt.name} download failed (${error.message}); trying next strategy ...\n`
+      );
+      fs.rmSync(dest, { force: true });
+    }
+  }
+  throw new BootstrapError(`direct download of ${url} failed (${failures.join("; ")})`);
+}
+
+// ---------------------------------------------------------------------------
+// Install chain: pip from URL first, Node-download + local pip as fallback
+// ---------------------------------------------------------------------------
+
+async function installHarness(options) {
+  const python = options.python;
+  const url = options.url;
+  const runStepFn = options.runStepFn || runStep;
+  const downloader = options.downloader || downloadTarballTo;
+
+  try {
+    runStepFn(python, pipInstallArgs(url));
+    return;
+  } catch (primaryError) {
+    if (!isRemoteHttpUrl(url)) {
+      throw primaryError;
+    }
+    process.stderr.write(
+      `[iterate-harness] pip install from ${url} failed; retrying via direct download ...\n`
+    );
+    const cachePath = downloadCachePath(options.homeDir, options.version);
+    try {
+      await downloader(url, cachePath);
+    } catch (downloadError) {
+      throw new BootstrapError(
+        `${primaryError.message}\n\n(direct-download fallback also failed: ${downloadError.message})`
+      );
+    }
+    runStepFn(python, pipInstallArgs(cachePath));
+  }
+}
+
+async function bootstrap(homeDir, version, env) {
   fs.mkdirSync(homeDir, { recursive: true });
 
   const venvDir = path.join(homeDir, VENV_DIR_NAME);
@@ -231,20 +405,13 @@ function bootstrap(homeDir, version, env) {
 
   const url = installUrl(version, env);
   process.stderr.write(`[iterate-harness] pip installing iterate-harness ${version} ...\n`);
-  runStep(executable.python, [
-    "-m",
-    "pip",
-    "install",
-    "--upgrade",
-    "--force-reinstall",
-    url,
-  ]);
+  await installHarness({ python: executable.python, url, homeDir, version });
 
   const stampPath = path.join(homeDir, STAMP_FILE_NAME);
   fs.writeFileSync(stampPath, `${version}\n`, "utf8");
 }
 
-function ensureRuntime(env) {
+async function ensureRuntime(env) {
   const environment = env || process.env;
   const version = packageVersion();
   const homeDir = runtimeHomeDir(environment);
@@ -258,7 +425,7 @@ function ensureRuntime(env) {
     : "";
 
   if (!skipInstall && needsBootstrap(stampContent, version)) {
-    bootstrap(homeDir, version, environment);
+    await bootstrap(homeDir, version, environment);
   }
 
   if (!fs.existsSync(executable.ih)) {
@@ -279,8 +446,20 @@ function ensureRuntime(env) {
 // Delegation to the real ih executable
 // ---------------------------------------------------------------------------
 
-function runHarness(args, env) {
-  const target = ensureRuntime(env);
+function reportBootstrapFailure(error) {
+  const message = error instanceof BootstrapError ? error.message : (error && error.stack) || error;
+  process.stderr.write(`[iterate-harness] ${message}\n`);
+}
+
+async function runHarness(args, env) {
+  let target;
+  try {
+    target = await ensureRuntime(env);
+  } catch (error) {
+    reportBootstrapFailure(error);
+    process.exit(1);
+    return;
+  }
   const child = spawn(target, args, {
     stdio: "inherit",
     windowsHide: false,
@@ -310,6 +489,7 @@ function runHarness(args, env) {
 
 module.exports = {
   BootstrapError,
+  MAX_DOWNLOAD_REDIRECTS,
   MIN_PYTHON_MAJOR,
   MIN_PYTHON_MINOR,
   PYTHON_ENV_VAR,
@@ -317,14 +497,22 @@ module.exports = {
   INSTALL_URL_ENV_VAR,
   SKIP_INSTALL_ENV_VAR,
   detectPython,
+  curlDownload,
+  downloadCachePath,
+  downloadFile,
+  downloadTarballTo,
   ensureRuntime,
+  installHarness,
   installUrl,
+  isRemoteHttpUrl,
   isSupportedPython,
   needsBootstrap,
   packageVersion,
   parsePythonVersion,
+  pipInstallArgs,
   pythonCandidates,
   releaseTarballUrl,
+  reportBootstrapFailure,
   runHarness,
   venvExecutablePaths,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterate-harness",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "npm distribution wrapper for iterate-harness — installs the Python harness (ih CLI) into a managed venv on first run and exposes it as a global command",
   "license": "MIT",
   "type": "commonjs",