pinme 2.0.8 → 2.0.9-beta.1

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.1";
 
 // bin/upload.ts
 var import_path7 = __toESM(require("path"));
@@ -9067,16 +9067,8 @@ 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;
 function makeTempCacheDir() {
   return import_fs_extra5.default.mkdtempSync(import_path11.default.join(import_os5.default.tmpdir(), "pinme-npm-cache-"));
 }
@@ -9089,54 +9081,57 @@ 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) {
+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 startBackgroundInstall(cwd) {
   const npm = getNpmCommand();
-  const result = (0, import_child_process3.spawnSync)(npm, [script, "--cache", cacheDir, "--no-audit", "--no-fund"], {
+  const script = getInstallScript(cwd, "auto");
+  const cacheDir = makeTempCacheDir();
+  const args = getInstallArgs(script, cacheDir);
+  const logPath = import_path11.default.join(cwd, ".pinme-install.log");
+  const header = `
+[pinme] ${(/* @__PURE__ */ new Date()).toISOString()} starting "npm ${script}"
+`;
+  import_fs_extra5.default.writeFileSync(logPath, header);
+  const logFd = import_fs_extra5.default.openSync(logPath, "a");
+  const child = (0, import_child_process3.spawn)(npm, args, {
     cwd,
-    stdio: "inherit",
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
     shell: true,
     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;
-  }
-  if (result.status !== 0) {
-    throw new Error(`npm ${script} failed with exit code ${result.status}`);
-  }
-}
-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);
-    }
-  }
-  throw new DependencyInstallError(command, lastError);
+  import_fs_extra5.default.closeSync(logFd);
+  child.unref();
+  return { logPath };
 }
 
 // bin/create.ts
@@ -9312,23 +9307,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 +9392,22 @@ 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..."));
-    try {
-      installProjectDependencies(targetDir);
-      console.log(import_chalk20.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 " + 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..."));
+    console.log(import_chalk20.default.blue("\n4. Installing dependencies in the background..."));
     try {
-      (0, import_child_process4.execSync)("npm run build:worker", {
-        cwd: targetDir,
-        stdio: "inherit"
-      });
-      console.log(import_chalk20.default.green("   Worker built"));
+      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}`));
     } 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 +9482,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"]
@@ -9651,36 +9602,25 @@ function buildWorker() {
     ]);
   }
 }
-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."
-      ]);
-    }
-    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.",
-      "If `package-lock.json` is stale, update it intentionally with `npm install` before retrying."
-    ]);
+function ensureDependenciesInstalled() {
+  const nodeModulesPath = import_path13.default.join(PROJECT_DIR2, "node_modules");
+  const installLogPath = import_path13.default.join(PROJECT_DIR2, ".pinme-install.log");
+  if (import_fs_extra7.default.existsSync(nodeModulesPath)) {
+    console.log(import_chalk21.default.gray("Dependencies already installed; skipping install."));
+    return;
+  }
+  const suggestions = [
+    "Dependencies are not installed. 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(
+      `A background install may still be running (started by \`pinme create\`). Check progress in \`${installLogPath}\` before retrying.`
+    );
   }
+  throw createConfigError(
+    "Project dependencies are not installed: `node_modules` is missing.",
+    suggestions
+  );
 }
 function getBuiltWorker() {
   const distWorkerDir = import_path13.default.join(PROJECT_DIR2, "dist-worker");
@@ -9886,7 +9826,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();
+    ensureDependenciesInstalled();
     buildWorker();
     const metadata = getMetadata();
     const { workerJsPath, modulePaths } = getBuiltWorker();

package/package.json

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