pinme 2.0.10-beta.1 → 2.0.10-beta.2

package/dist/index.js

@@ -5978,7 +5978,7 @@ var import_chalk26 = __toESM(require("chalk"));
 var import_figlet5 = __toESM(require("figlet"));
 
 // package.json
-var version = "2.0.10-beta.1";
+var version = "2.0.10-beta.2";
 
 // bin/upload.ts
 var import_path7 = __toESM(require("path"));
@@ -9090,10 +9090,24 @@ var import_chalk19 = __toESM(require("chalk"));
 var import_child_process3 = require("child_process");
 var INSTALL_TIMEOUT_MS = 10 * 60 * 1e3;
 var SLOW_INSTALL_NOTICE_MS = 60 * 1e3;
+var CAPTURED_OUTPUT_LIMIT = 12e3;
 var STALE_LOG_ONLY_MARKER_MS = 90 * 1e3;
+var STOP_BACKGROUND_GRACE_MS = 3e3;
+var STOP_BACKGROUND_KILL_GRACE_MS = 2e3;
+var STOP_BACKGROUND_POLL_MS = 200;
 var INSTALL_LOG_FILE = ".pinme-install.log";
 var INSTALL_EXITCODE_FILE = ".pinme-install.exitcode";
 var INSTALL_PID_FILE = ".pinme-install.pid";
+var DependencyInstallError = class extends Error {
+  command;
+  constructor(command, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(`${command} failed: ${reason}`);
+    this.name = "DependencyInstallError";
+    this.command = command;
+    this.cause = cause;
+  }
+};
 function makeTempCacheDir() {
   return import_fs_extra5.default.mkdtempSync(import_path11.default.join(import_os5.default.tmpdir(), "pinme-npm-cache-"));
 }
@@ -9113,10 +9127,8 @@ function getInstallScript(cwd, mode) {
   return hasPackageLock(cwd) ? "ci" : "install";
 }
 function getInstallArgs(script, cacheDir) {
-  return [
+  const args = [
     script,
-    "--cache",
-    cacheDir,
     "--no-audit",
     "--no-fund",
     "--fetch-retries=3",
@@ -9125,6 +9137,100 @@ function getInstallArgs(script, cacheDir) {
     "--fetch-retry-maxtimeout=60000",
     "--fetch-timeout=60000"
   ];
+  if (cacheDir) {
+    args.splice(1, 0, "--cache", cacheDir);
+  }
+  return args;
+}
+function formatInstallCommand(script, cacheMode = "default") {
+  const parts = [
+    `npm ${script}`,
+    "--no-audit",
+    "--no-fund",
+    "--fetch-retries=3",
+    "--fetch-timeout=60000"
+  ];
+  if (cacheMode === "isolated") {
+    parts.splice(1, 0, "--cache <isolated npm cache>");
+  }
+  return parts.join(" ");
+}
+function appendCapturedOutput(output, chunk) {
+  const next = output + chunk.toString();
+  if (next.length <= CAPTURED_OUTPUT_LIMIT) {
+    return next;
+  }
+  return next.slice(next.length - CAPTURED_OUTPUT_LIMIT);
+}
+function runInstall(cwd, script, cacheDir) {
+  const npm = getNpmCommand();
+  const args = getInstallArgs(script, cacheDir);
+  const env = {
+    ...process.env,
+    npm_config_audit: "false",
+    npm_config_fund: "false",
+    npm_config_fetch_retries: "3",
+    npm_config_fetch_retry_factor: "2",
+    npm_config_fetch_retry_mintimeout: "10000",
+    npm_config_fetch_retry_maxtimeout: "60000",
+    npm_config_fetch_timeout: "60000"
+  };
+  if (cacheDir) {
+    env.npm_config_cache = cacheDir;
+  }
+  return new Promise((resolve, reject) => {
+    var _a2, _b;
+    let capturedOutput = "";
+    let settled = false;
+    let timedOut = false;
+    const child = (0, import_child_process3.spawn)(npm, args, {
+      cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: process.platform === "win32",
+      env
+    });
+    const slowNoticeTimer = setTimeout(() => {
+      console.log(import_chalk19.default.yellow("   Still installing dependencies. Slow npm registry or network can make this take a few minutes..."));
+    }, SLOW_INSTALL_NOTICE_MS);
+    const timeoutTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, INSTALL_TIMEOUT_MS);
+    const cleanup = () => {
+      clearTimeout(slowNoticeTimer);
+      clearTimeout(timeoutTimer);
+    };
+    (_a2 = child.stdout) == null ? void 0 : _a2.on("data", (chunk) => {
+      process.stdout.write(chunk);
+      capturedOutput = appendCapturedOutput(capturedOutput, chunk);
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+      process.stderr.write(chunk);
+      capturedOutput = appendCapturedOutput(capturedOutput, chunk);
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (timedOut) {
+        reject(new Error(`npm ${script} timed out after 10 minutes.
+${capturedOutput}`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`npm ${script} failed with exit code ${code}${signal ? ` and signal ${signal}` : ""}.
+${capturedOutput}`));
+        return;
+      }
+      resolve();
+    });
+  });
 }
 function quoteForShell(value) {
   if (process.platform === "win32") {
@@ -9134,8 +9240,7 @@ function quoteForShell(value) {
 }
 function startBackgroundInstall(cwd) {
   const script = getInstallScript(cwd, "auto");
-  const cacheDir = makeTempCacheDir();
-  const args = getInstallArgs(script, cacheDir);
+  const args = getInstallArgs(script);
   const logPath = import_path11.default.join(cwd, INSTALL_LOG_FILE);
   const exitCodePath = import_path11.default.join(cwd, INSTALL_EXITCODE_FILE);
   const pidPath = import_path11.default.join(cwd, INSTALL_PID_FILE);
@@ -9164,7 +9269,6 @@ function startBackgroundInstall(cwd) {
     stdio: "ignore",
     env: {
       ...process.env,
-      npm_config_cache: cacheDir,
       npm_config_audit: "false",
       npm_config_fund: "false",
       npm_config_fetch_retries: "3",
@@ -9199,6 +9303,56 @@ function readPidFile(pidPath) {
   }
   return pid;
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function signalInstallProcess(pid, signal) {
+  try {
+    if (process.platform === "win32") {
+      process.kill(pid, signal);
+    } else {
+      process.kill(-pid, signal);
+    }
+    return true;
+  } catch {
+    try {
+      process.kill(pid, signal);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await sleep(STOP_BACKGROUND_POLL_MS);
+  }
+  return !isProcessAlive(pid);
+}
+async function stopBackgroundInstall(cwd) {
+  const pidPath = import_path11.default.join(cwd, INSTALL_PID_FILE);
+  const pid = readPidFile(pidPath);
+  let stopped = false;
+  if (pid !== null && isProcessAlive(pid)) {
+    if (signalInstallProcess(pid, "SIGTERM")) {
+      stopped = true;
+      const stoppedGracefully = await waitForProcessExit(
+        pid,
+        STOP_BACKGROUND_GRACE_MS
+      );
+      if (!stoppedGracefully) {
+        signalInstallProcess(pid, "SIGKILL");
+        await waitForProcessExit(pid, STOP_BACKGROUND_KILL_GRACE_MS);
+      }
+    }
+  }
+  import_fs_extra5.default.removeSync(pidPath);
+  return stopped;
+}
 function isStaleLogOnlyMarker(logPath) {
   try {
     const ageMs = Date.now() - import_fs_extra5.default.statSync(logPath).mtimeMs;
@@ -9243,6 +9397,44 @@ function readBackgroundInstallLogTail(cwd, maxChars = 1500) {
   const content = import_fs_extra5.default.readFileSync(logPath, "utf-8");
   return content.length > maxChars ? content.slice(content.length - maxChars) : content;
 }
+async function installProjectDependencies(cwd, options = {}) {
+  const mode = options.mode || "auto";
+  const script = getInstallScript(cwd, mode);
+  const command = formatInstallCommand(script);
+  let lastError;
+  if (script === "ci" && !hasPackageLock(cwd)) {
+    throw new DependencyInstallError(
+      command,
+      new Error("package-lock.json is required for npm ci but was not found.")
+    );
+  }
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const useIsolatedCache = attempt > 1;
+    const cacheDir = useIsolatedCache ? makeTempCacheDir() : void 0;
+    try {
+      if (attempt > 1) {
+        console.log(import_chalk19.default.yellow("   Retrying dependency install with a fresh npm cache..."));
+      }
+      if (attempt === 1 && script === "ci" && mode === "auto") {
+        console.log(import_chalk19.default.gray("   package-lock.json found; using npm ci for a reproducible install."));
+      } else if (attempt === 1 && script === "ci") {
+        console.log(import_chalk19.default.gray("   Using npm ci for a clean, reproducible install."));
+      }
+      await runInstall(cwd, script, cacheDir);
+      return;
+    } catch (error) {
+      lastError = error;
+    } finally {
+      if (cacheDir) {
+        import_fs_extra5.default.removeSync(cacheDir);
+      }
+    }
+  }
+  throw new DependencyInstallError(
+    formatInstallCommand(script, "isolated"),
+    lastError
+  );
+}
 
 // bin/create.ts
 init_cliError();
@@ -9922,10 +10114,10 @@ function isMissingDependencyError(error) {
 function dependenciesPresent() {
   return hasLocalBinary("wrangler") && hasLocalBinary("vite");
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var WAIT_FOR_INSTALL_TIMEOUT_MS = 2 * 60 * 1e3;
+var WAIT_FOR_INSTALL_TIMEOUT_MS = 15 * 1e3;
 var WAIT_POLL_INTERVAL_MS = 2e3;
 async function ensureDependenciesReady() {
   if (dependenciesPresent()) {
@@ -9934,26 +10126,25 @@ async function ensureDependenciesReady() {
   }
   const initial = readBackgroundInstallStatus(PROJECT_DIR2);
   if (initial.status === "idle") {
-    throw dependenciesMissingError(
-      "Project dependencies are not installed and no install is running."
-    );
+    await installDependenciesInForeground();
+    return;
   }
   if (initial.status === "failed") {
-    throw dependenciesMissingError(
-      `The background dependency install (started by \`pinme create\`) failed with exit code ${initial.exitCode}.`,
-      readBackgroundInstallLogTail(PROJECT_DIR2)
-    );
+    console.log(import_chalk21.default.yellow(
+      `Background dependency install failed with exit code ${initial.exitCode}. Retrying in this terminal...`
+    ));
+    await installDependenciesInForeground();
+    return;
   }
   if (initial.status === "interrupted") {
-    throw dependenciesMissingError(
-      "The background dependency install appears to have been interrupted.",
-      readBackgroundInstallLogTail(PROJECT_DIR2)
-    );
+    console.log(import_chalk21.default.yellow("Background dependency install was interrupted. Continuing in this terminal..."));
+    await installDependenciesInForeground();
+    return;
   }
-  const spinner = (0, import_ora3.default)("Waiting for background dependency install to finish...").start();
+  const spinner = (0, import_ora3.default)("Waiting briefly for background dependency install...").start();
   const startedAt = Date.now();
   while (true) {
-    await sleep(WAIT_POLL_INTERVAL_MS);
+    await sleep2(WAIT_POLL_INTERVAL_MS);
     if (dependenciesPresent()) {
       spinner.succeed("Dependencies installed.");
       return;
@@ -9961,17 +10152,16 @@ async function ensureDependenciesReady() {
     const state = readBackgroundInstallStatus(PROJECT_DIR2);
     if (state.status === "failed") {
       spinner.fail("Background dependency install failed.");
-      throw dependenciesMissingError(
-        `The background dependency install (started by \`pinme create\`) failed with exit code ${state.exitCode}.`,
-        readBackgroundInstallLogTail(PROJECT_DIR2)
-      );
+      console.log(import_chalk21.default.yellow(
+        `Retrying dependency install in this terminal after exit code ${state.exitCode}...`
+      ));
+      await installDependenciesInForeground();
+      return;
     }
     if (state.status === "interrupted") {
       spinner.fail("Background dependency install was interrupted.");
-      throw dependenciesMissingError(
-        "The background dependency install appears to have been interrupted.",
-        readBackgroundInstallLogTail(PROJECT_DIR2)
-      );
+      await installDependenciesInForeground();
+      return;
     }
     if (state.status === "success") {
       spinner.succeed("Dependencies installed.");
@@ -9979,14 +10169,32 @@ async function ensureDependenciesReady() {
     }
     const elapsedMs = Date.now() - startedAt;
     if (elapsedMs > WAIT_FOR_INSTALL_TIMEOUT_MS) {
-      spinner.fail("Timed out waiting for the dependency install.");
-      throw dependenciesMissingError(
-        "Timed out waiting for the background dependency install to finish. It may still be running slowly.",
-        readBackgroundInstallLogTail(PROJECT_DIR2)
-      );
+      spinner.warn("Background dependency install is not ready yet; continuing in this terminal.");
+      await stopBackgroundInstall(PROJECT_DIR2);
+      await installDependenciesInForeground();
+      return;
     }
-    spinner.text = `Waiting for background dependency install to finish... (${Math.round(elapsedMs / 1e3)}s)`;
+    spinner.text = `Waiting briefly for background dependency install... (${Math.round(elapsedMs / 1e3)}s)`;
+  }
+}
+async function installDependenciesInForeground() {
+  console.log(import_chalk21.default.blue("Installing project dependencies..."));
+  try {
+    await stopBackgroundInstall(PROJECT_DIR2);
+    await installProjectDependencies(PROJECT_DIR2);
+  } catch (error) {
+    throw dependenciesMissingError(
+      "Project dependency install failed.",
+      readBackgroundInstallLogTail(PROJECT_DIR2) || (error == null ? void 0 : error.message)
+    );
+  }
+  if (!dependenciesPresent()) {
+    throw dependenciesMissingError(
+      "Project dependencies were installed, but required build CLIs are still missing.",
+      readBackgroundInstallLogTail(PROJECT_DIR2)
+    );
   }
+  console.log(import_chalk21.default.green("Project dependencies installed."));
 }
 function cleanupInstallMarkers() {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinme",
-  "version": "2.0.10-beta.1",
+  "version": "2.0.10-beta.2",
   "publishConfig": {
     "access": "public"
   },