pinme 2.0.8 → 2.0.9-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.8";
+var version = "2.0.9-beta.2";
 
 // bin/upload.ts
 var import_path7 = __toESM(require("path"));
@@ -9067,16 +9067,10 @@ var import_os5 = __toESM(require("os"));
 var import_path11 = __toESM(require("path"));
 var import_chalk19 = __toESM(require("chalk"));
 var import_child_process3 = require("child_process");
-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;
-  }
-};
+var INSTALL_TIMEOUT_MS = 10 * 60 * 1e3;
+var SLOW_INSTALL_NOTICE_MS = 60 * 1e3;
+var INSTALL_LOG_FILE = ".pinme-install.log";
+var INSTALL_EXITCODE_FILE = ".pinme-install.exitcode";
 function makeTempCacheDir() {
   return import_fs_extra5.default.mkdtempSync(import_path11.default.join(import_os5.default.tmpdir(), "pinme-npm-cache-"));
 }
@@ -9089,54 +9083,98 @@ function getNpmCommand() {
 function hasPackageLock(cwd) {
   return import_fs_extra5.default.existsSync(import_path11.default.join(cwd, "package-lock.json"));
 }
-function getInstallScript(cwd) {
+function getInstallScript(cwd, mode) {
+  if (mode !== "auto") {
+    return mode;
+  }
   return hasPackageLock(cwd) ? "ci" : "install";
 }
-function formatInstallCommand(script) {
-  return `npm ${script} --cache <isolated npm cache> --no-audit --no-fund`;
-}
-function runInstall(cwd, cacheDir, script) {
-  const npm = getNpmCommand();
-  const result = (0, import_child_process3.spawnSync)(npm, [script, "--cache", cacheDir, "--no-audit", "--no-fund"], {
+function getInstallArgs(script, cacheDir) {
+  return [
+    script,
+    "--cache",
+    cacheDir,
+    "--no-audit",
+    "--no-fund",
+    "--fetch-retries=3",
+    "--fetch-retry-factor=2",
+    "--fetch-retry-mintimeout=10000",
+    "--fetch-retry-maxtimeout=60000",
+    "--fetch-timeout=60000"
+  ];
+}
+function quoteForShell(value) {
+  if (process.platform === "win32") {
+    return `"${value}"`;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function startBackgroundInstall(cwd) {
+  const script = getInstallScript(cwd, "auto");
+  const cacheDir = makeTempCacheDir();
+  const args = getInstallArgs(script, cacheDir);
+  const logPath = import_path11.default.join(cwd, INSTALL_LOG_FILE);
+  const exitCodePath = import_path11.default.join(cwd, INSTALL_EXITCODE_FILE);
+  import_fs_extra5.default.removeSync(exitCodePath);
+  import_fs_extra5.default.writeFileSync(logPath, `[pinme] ${(/* @__PURE__ */ new Date()).toISOString()} starting "npm ${script}"
+`);
+  const npmCmd = process.platform === "win32" ? "npm" : getNpmCommand();
+  const installCmd = `${npmCmd} ${args.map(quoteForShell).join(" ")}`;
+  const qLog = quoteForShell(logPath);
+  const qExit = quoteForShell(exitCodePath);
+  let shellBin;
+  let shellArgs;
+  if (process.platform === "win32") {
+    const command = `${installCmd} >> ${qLog} 2>&1 & echo %errorlevel% > ${qExit}`;
+    shellBin = process.env.ComSpec || "cmd.exe";
+    shellArgs = ["/d", "/s", "/c", command];
+  } else {
+    const command = `${installCmd} >> ${qLog} 2>&1; printf '%s' "$?" > ${qExit}`;
+    shellBin = "/bin/sh";
+    shellArgs = ["-c", command];
+  }
+  const child = (0, import_child_process3.spawn)(shellBin, shellArgs, {
     cwd,
-    stdio: "inherit",
-    shell: true,
+    detached: true,
+    stdio: "ignore",
     env: {
       ...process.env,
       npm_config_cache: cacheDir,
       npm_config_audit: "false",
-      npm_config_fund: "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 (result.error) {
-    throw result.error;
+  child.unref();
+  return { logPath };
+}
+function readBackgroundInstallStatus(cwd) {
+  const logPath = import_path11.default.join(cwd, INSTALL_LOG_FILE);
+  const exitCodePath = import_path11.default.join(cwd, INSTALL_EXITCODE_FILE);
+  if (import_fs_extra5.default.existsSync(exitCodePath)) {
+    const raw = import_fs_extra5.default.readFileSync(exitCodePath, "utf-8").trim();
+    const code = Number.parseInt(raw, 10);
+    if (Number.isNaN(code)) {
+      return { status: "running", exitCode: null, logPath };
+    }
+    return { status: code === 0 ? "success" : "failed", exitCode: code, logPath };
   }
-  if (result.status !== 0) {
-    throw new Error(`npm ${script} failed with exit code ${result.status}`);
+  if (import_fs_extra5.default.existsSync(logPath)) {
+    return { status: "running", exitCode: null, logPath };
   }
+  return { status: "idle", exitCode: null, logPath };
 }
-function installProjectDependencies(cwd) {
-  const script = getInstallScript(cwd);
-  const command = formatInstallCommand(script);
-  let lastError;
-  for (let attempt = 1; attempt <= 2; attempt += 1) {
-    const cacheDir = makeTempCacheDir();
-    try {
-      if (attempt > 1) {
-        console.log(import_chalk19.default.yellow("   Retrying dependency install with a fresh npm cache..."));
-      }
-      if (attempt === 1 && script === "ci") {
-        console.log(import_chalk19.default.gray("   package-lock.json found; using npm ci for a reproducible install."));
-      }
-      runInstall(cwd, cacheDir, script);
-      return;
-    } catch (error) {
-      lastError = error;
-    } finally {
-      import_fs_extra5.default.removeSync(cacheDir);
-    }
+function readBackgroundInstallLogTail(cwd, maxChars = 1500) {
+  const logPath = import_path11.default.join(cwd, INSTALL_LOG_FILE);
+  if (!import_fs_extra5.default.existsSync(logPath)) {
+    return "";
   }
-  throw new DependencyInstallError(command, lastError);
+  const content = import_fs_extra5.default.readFileSync(logPath, "utf-8");
+  return content.length > maxChars ? content.slice(content.length - maxChars) : content;
 }
 
 // bin/create.ts
@@ -9312,23 +9350,14 @@ Directory "${projectName}" already exists.`));
       import_fs_extra6.default.removeSync(zipPath);
       import_fs_extra6.default.removeSync(extractDir);
       const nodeModulesPath = import_path12.default.join(targetDir, "node_modules");
-      const packageLockPath = import_path12.default.join(targetDir, "package-lock.json");
       if (import_fs_extra6.default.existsSync(nodeModulesPath)) {
         console.log(import_chalk20.default.gray("   Removing existing node_modules..."));
         import_fs_extra6.default.removeSync(nodeModulesPath);
       }
-      if (import_fs_extra6.default.existsSync(packageLockPath)) {
-        console.log(import_chalk20.default.gray("   Removing existing package-lock.json..."));
-        import_fs_extra6.default.removeSync(packageLockPath);
-      }
       const frontendNodeModules = import_path12.default.join(targetDir, "frontend", "node_modules");
       const backendNodeModules = import_path12.default.join(targetDir, "backend", "node_modules");
-      const frontendPackageLock = import_path12.default.join(targetDir, "frontend", "package-lock.json");
-      const backendPackageLock = import_path12.default.join(targetDir, "backend", "package-lock.json");
       if (import_fs_extra6.default.existsSync(frontendNodeModules)) import_fs_extra6.default.removeSync(frontendNodeModules);
       if (import_fs_extra6.default.existsSync(backendNodeModules)) import_fs_extra6.default.removeSync(backendNodeModules);
-      if (import_fs_extra6.default.existsSync(frontendPackageLock)) import_fs_extra6.default.removeSync(frontendPackageLock);
-      if (import_fs_extra6.default.existsSync(backendPackageLock)) import_fs_extra6.default.removeSync(backendPackageLock);
       console.log(import_chalk20.default.green(`   Template downloaded to: ${targetDir}`));
     } catch (error) {
       throw createCommandError("template extraction", `extract "${zipPath}" to "${extractDir}"`, error, [
@@ -9406,53 +9435,23 @@ Directory "${projectName}" already exists.`));
     }
     import_fs_extra6.default.writeFileSync(configPath, pinmeConfig);
     console.log(import_chalk20.default.green(`   Updated pinme.toml with api_url`));
-    console.log(import_chalk20.default.blue("\n4. Installing dependencies..."));
+    console.log(import_chalk20.default.blue("\n4. Installing dependencies in the background..."));
     try {
-      installProjectDependencies(targetDir);
-      console.log(import_chalk20.default.green("   Project dependencies installed"));
+      const { logPath } = startBackgroundInstall(targetDir);
+      console.log(import_chalk20.default.gray("   Dependencies are installing in the background; create will continue."));
+      console.log(import_chalk20.default.gray(`   Install progress is logged to: ${logPath}`));
+      console.log(import_chalk20.default.gray("   `pinme save` will automatically wait for this install to finish."));
     } catch (error) {
-      const errorMsg = error.message || "";
-      const installCommand = error instanceof DependencyInstallError ? error.command : "npm ci/npm install --cache <isolated npm cache> --no-audit --no-fund";
-      if (errorMsg.includes("EACCES") || errorMsg.includes("EPERM") || errorMsg.includes("permission denied")) {
-        throw createCommandError("project dependency install", installCommand, error, [
-          "Permission error detected. Pinme already retries with an isolated npm cache.",
-          "Check whether the project directory is writable:",
-          "  ls -la " + targetDir,
-          "If npm still reports a root-owned cache, set `npm_config_cache` to a user-writable directory and retry."
-        ]);
-      }
-      if (errorMsg.includes("ENOTFOUND") || errorMsg.includes("ETIMEDOUT") || errorMsg.includes("network")) {
-        throw createCommandError("project dependency install", installCommand, error, [
-          "Network error detected. Please check:",
-          "  1. Internet connection is available",
-          "  2. npm registry is accessible (https://registry.npmjs.org)",
-          "  3. Try using a mirror: npm config set registry https://registry.npmmirror.com"
-        ]);
-      }
-      throw createCommandError("project dependency install", installCommand, error, [
-        "Dependency installation failed.",
-        "Check network connectivity and npm registry availability.",
-        "Inspect the generated workspace `package.json` files for dependency conflicts.",
-        "If `package-lock.json` is stale, update it intentionally with `npm install` before retrying."
-      ]);
-    }
-    console.log(import_chalk20.default.blue("\n5. Building backend worker..."));
-    try {
-      (0, import_child_process4.execSync)("npm run build:worker", {
-        cwd: targetDir,
-        stdio: "inherit"
-      });
-      console.log(import_chalk20.default.green("   Worker built"));
-    } catch (error) {
-      throw createCommandError("worker build", "npm run build:worker", error, [
-        "Fix the build error shown above, then rerun `pinme create`."
-      ]);
+      console.log(import_chalk20.default.yellow("   Warning: could not start background dependency install."));
+      console.log(import_chalk20.default.yellow("   Run `npm install` inside the project before `pinme save`."));
     }
+    console.log(import_chalk20.default.blue("\n5. Preparing backend worker..."));
     const distWorkerDir = import_path12.default.join(targetDir, "dist-worker");
     const workerJsPath = import_path12.default.join(distWorkerDir, "worker.js");
     if (!import_fs_extra6.default.existsSync(distWorkerDir) || !import_fs_extra6.default.existsSync(workerJsPath)) {
-      throw createConfigError("Built worker output not found: `dist-worker/worker.js`.", [
-        "Make sure `npm run build:worker` completed successfully."
+      throw createConfigError("Prebuilt worker output not found: `dist-worker/worker.js`.", [
+        "The template should ship a prebuilt `dist-worker/`.",
+        "Once dependencies finish installing, run `npm run build:worker` in the project, then `pinme save`."
       ]);
     }
     const modulePaths = [];
@@ -9527,23 +9526,19 @@ Directory "${projectName}" already exists.`));
         "Check whether backend metadata, SQL files, or worker bundle contains invalid content."
       ]);
     }
-    console.log(import_chalk20.default.blue("\n7. Building frontend..."));
+    console.log(import_chalk20.default.blue("\n7. Preparing frontend..."));
     const frontendDir = import_path12.default.join(targetDir, "frontend");
+    const frontendDistDir = import_path12.default.join(frontendDir, "dist");
     if (import_fs_extra6.default.existsSync(frontendDir)) {
-      try {
-        (0, import_child_process4.execSync)("npm run build:frontend", {
-          cwd: targetDir,
-          stdio: "inherit"
-        });
-        console.log(import_chalk20.default.green("   Frontend built"));
-      } catch (error) {
-        throw createCommandError("frontend build", "npm run build:frontend", error, [
-          "Fix the frontend build error shown above, then rerun `pinme create`."
+      if (!import_fs_extra6.default.existsSync(frontendDistDir)) {
+        throw createConfigError("Prebuilt frontend output not found: `frontend/dist/`.", [
+          "The template should ship a prebuilt `frontend/dist/`.",
+          "Once dependencies finish installing, run `npm run build:frontend` in the project, then `pinme save`."
         ]);
       }
       console.log(import_chalk20.default.blue("   Uploading to IPFS..."));
       try {
-        const uploadResult = await uploadPath(import_path12.default.join(frontendDir, "dist"), {
+        const uploadResult = await uploadPath(frontendDistDir, {
           action: "project_create",
           projectName: workerData.project_name,
           uid: headers["token-address"]
@@ -9602,6 +9597,7 @@ Next steps:`));
 
 // bin/save.ts
 var import_chalk21 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
 var import_fs_extra7 = __toESM(require("fs-extra"));
 var import_path13 = __toESM(require("path"));
 init_axios2();
@@ -9646,42 +9642,117 @@ function buildWorker() {
     });
     console.log(import_chalk21.default.green("Worker built"));
   } catch (error) {
+    if (isMissingDependencyError(error)) {
+      throw dependenciesMissingError(
+        "Worker build failed because a required CLI (e.g. `wrangler`) was not found. Project dependencies are missing or incomplete."
+      );
+    }
     throw createCommandError("worker build", "npm run build:worker", error, [
       "Fix the build error shown above, then rerun `pinme save`."
     ]);
   }
 }
-function installDependencies() {
-  console.log(import_chalk21.default.blue("Installing dependencies..."));
-  try {
-    installProjectDependencies(PROJECT_DIR2);
-    console.log(import_chalk21.default.green("Project dependencies installed"));
-  } catch (error) {
-    const errorMsg = error.message || "";
-    const installCommand = error instanceof DependencyInstallError ? error.command : "npm ci/npm install --cache <isolated npm cache> --no-audit --no-fund";
-    if (errorMsg.includes("EACCES") || errorMsg.includes("EPERM") || errorMsg.includes("permission denied")) {
-      throw createCommandError("project dependency install", installCommand, error, [
-        "Permission error detected. Pinme already retries with an isolated npm cache.",
-        "Check whether the project directory is writable:",
-        "  ls -la " + PROJECT_DIR2,
-        "If npm still reports a root-owned cache, set `npm_config_cache` to a user-writable directory and retry."
-      ]);
+function dependenciesMissingError(summary, logTail) {
+  const installLogPath = import_path13.default.join(PROJECT_DIR2, ".pinme-install.log");
+  const suggestions = [
+    "Run `npm install` in the project root, wait for it to finish, then rerun `pinme save`."
+  ];
+  if (import_fs_extra7.default.existsSync(installLogPath)) {
+    suggestions.push(
+      `Background install log: ${installLogPath}`
+    );
+  }
+  const error = createConfigError(summary, suggestions);
+  const trimmedTail = logTail == null ? void 0 : logTail.trim();
+  if (trimmedTail) {
+    error.details = [
+      ...error.details,
+      "Install log (tail):",
+      ...trimmedTail.split("\n").slice(-20)
+    ];
+  }
+  return error;
+}
+function isMissingDependencyError(error) {
+  const exitCode = (error == null ? void 0 : error.status) ?? (error == null ? void 0 : error.code);
+  if (exitCode === 127) {
+    return true;
+  }
+  const haystack = [error == null ? void 0 : error.message, error == null ? void 0 : error.stderr, error == null ? void 0 : error.stdout].map((value) => String(value || "")).join(" ").toLowerCase();
+  return /command not found|not found|is not recognized|cannot find module|cannot find package/.test(haystack);
+}
+function dependenciesPresent() {
+  return hasLocalBinary("wrangler") && hasLocalBinary("vite");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var WAIT_FOR_INSTALL_TIMEOUT_MS = 12 * 60 * 1e3;
+var WAIT_POLL_INTERVAL_MS = 2e3;
+async function ensureDependenciesReady() {
+  if (dependenciesPresent()) {
+    console.log(import_chalk21.default.gray("Dependencies are installed."));
+    return;
+  }
+  const initial = readBackgroundInstallStatus(PROJECT_DIR2);
+  if (initial.status === "idle") {
+    throw dependenciesMissingError(
+      "Project dependencies are not installed and no install is running."
+    );
+  }
+  if (initial.status === "failed") {
+    throw dependenciesMissingError(
+      `The background dependency install (started by \`pinme create\`) failed with exit code ${initial.exitCode}.`,
+      readBackgroundInstallLogTail(PROJECT_DIR2)
+    );
+  }
+  const spinner = (0, import_ora3.default)("Waiting for background dependency install to finish...").start();
+  const startedAt = Date.now();
+  while (true) {
+    await sleep(WAIT_POLL_INTERVAL_MS);
+    if (dependenciesPresent()) {
+      spinner.succeed("Dependencies installed.");
+      return;
     }
-    if (errorMsg.includes("ENOTFOUND") || errorMsg.includes("ETIMEDOUT") || errorMsg.includes("network")) {
-      throw createCommandError("project dependency install", installCommand, error, [
-        "Network error detected. Please check:",
-        "  1. Internet connection is available",
-        "  2. npm registry is accessible (https://registry.npmjs.org)",
-        "  3. Try using a mirror: npm config set registry https://registry.npmmirror.com"
-      ]);
+    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)
+      );
     }
-    throw createCommandError("project dependency install", installCommand, error, [
-      "Dependency installation failed.",
-      "Check network connectivity and npm registry availability.",
-      "If `package-lock.json` is stale, update it intentionally with `npm install` before retrying."
-    ]);
+    if (state.status === "success") {
+      spinner.succeed("Dependencies installed.");
+      return;
+    }
+    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.",
+        readBackgroundInstallLogTail(PROJECT_DIR2)
+      );
+    }
+    spinner.text = `Waiting for background dependency install to finish... (${Math.round(elapsedMs / 1e3)}s)`;
+  }
+}
+function cleanupInstallMarkers() {
+  try {
+    import_fs_extra7.default.removeSync(import_path13.default.join(PROJECT_DIR2, INSTALL_LOG_FILE));
+    import_fs_extra7.default.removeSync(import_path13.default.join(PROJECT_DIR2, INSTALL_EXITCODE_FILE));
+  } catch {
   }
 }
+function hasLocalBinary(name) {
+  const binDirs = [
+    import_path13.default.join(PROJECT_DIR2, "node_modules", ".bin"),
+    import_path13.default.join(PROJECT_DIR2, "backend", "node_modules", ".bin"),
+    import_path13.default.join(PROJECT_DIR2, "frontend", "node_modules", ".bin")
+  ];
+  const candidates = process.platform === "win32" ? [name, `${name}.cmd`, `${name}.exe`, `${name}.ps1`] : [name];
+  return binDirs.some((dir) => candidates.some((candidate) => import_fs_extra7.default.existsSync(import_path13.default.join(dir, candidate))));
+}
 function getBuiltWorker() {
   const distWorkerDir = import_path13.default.join(PROJECT_DIR2, "dist-worker");
   if (!import_fs_extra7.default.existsSync(distWorkerDir)) {
@@ -9787,6 +9858,11 @@ function buildFrontend() {
     });
     console.log(import_chalk21.default.green("Frontend built"));
   } catch (error) {
+    if (isMissingDependencyError(error)) {
+      throw dependenciesMissingError(
+        "Frontend build failed because a required CLI (e.g. `vite`) was not found. Project dependencies are missing or incomplete."
+      );
+    }
     throw createCommandError("frontend build", "npm run build:frontend", error, [
       "Fix the frontend build error shown above, then rerun `pinme save`."
     ]);
@@ -9886,7 +9962,7 @@ async function saveCmd(options) {
     const apiUrl = `${getPinmeApiUrl("/save_worker")}?project_name=${encodeURIComponent(projectName)}`;
     console.log(import_chalk21.default.gray(`API URL: ${apiUrl}`));
     console.log(import_chalk21.default.blue("\n--- Backend ---"));
-    installDependencies();
+    await ensureDependenciesReady();
     buildWorker();
     const metadata = getMetadata();
     const { workerJsPath, modulePaths } = getBuiltWorker();
@@ -9915,6 +9991,7 @@ async function saveCmd(options) {
       "management"
     );
     console.log(import_chalk21.default.green("\nDeployment complete."));
+    cleanupInstallMarkers();
     void tracker_default.trackEvent(TRACK_EVENTS.projectSaveSuccess, TRACK_PAGES.deploy, {
       a: resolveTrackAction2(TRACK_EVENTS.projectSaveSuccess),
       project_name: projectName,

package/package.json

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