@patchstack/connect 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -47,8 +47,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/parsers/index.ts
-var import_promises5 = require("fs/promises");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises6 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/types.ts
 var PatchstackError = class extends Error {
@@ -62,13 +62,52 @@ var PatchstackError = class extends Error {
   cause;
 };
 
-// src/parsers/npm.ts
+// src/parsers/consistency.ts
 var import_promises = require("fs/promises");
 var import_node_path = __toESM(require("path"), 1);
+async function readDeclaredDependencyNames(cwd) {
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(import_node_path.default.join(cwd, "package.json"), "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const group of ["dependencies", "devDependencies"]) {
+    const deps = parsed[group];
+    if (typeof deps !== "object" || deps === null) {
+      continue;
+    }
+    for (const [name, spec] of Object.entries(deps)) {
+      if (typeof spec === "string" && /^(file|link|workspace|portal):/.test(spec)) {
+        continue;
+      }
+      names.add(name);
+    }
+  }
+  return [...names];
+}
+function missingDependencies(declared, packages) {
+  const present = new Set(packages.map((entry) => entry.name));
+  return declared.filter((name) => !present.has(name));
+}
+
+// src/parsers/npm.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
 async function parseNpmLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await (0, import_promises.readFile)(lockfilePath, "utf8");
+    raw = await (0, import_promises2.readFile)(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(`Could not read lockfile at ${lockfilePath}`, "LOCKFILE_NOT_FOUND", cause);
   }
@@ -126,7 +165,7 @@ function extractFromV1(deps, acc = [], depth = 0) {
   return acc;
 }
 function extractNameFromPath(pkgPath) {
-  const segments = pkgPath.split("node_modules" + import_node_path.default.sep === pkgPath ? import_node_path.default.sep : "/");
+  const segments = pkgPath.split("node_modules" + import_node_path2.default.sep === pkgPath ? import_node_path2.default.sep : "/");
   const parts = pkgPath.split("/");
   const nmIndex = parts.lastIndexOf("node_modules");
   if (nmIndex === -1 || nmIndex >= parts.length - 1) {
@@ -149,12 +188,12 @@ function isDirectV2(pkgPath) {
 }
 
 // src/parsers/node_modules.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 async function walkNodeModules(cwd) {
-  const root = import_node_path2.default.join(cwd, "node_modules");
+  const root = import_node_path3.default.join(cwd, "node_modules");
   try {
-    const info = await (0, import_promises2.stat)(root);
+    const info = await (0, import_promises3.stat)(root);
     if (!info.isDirectory()) {
       throw new PatchstackError(
         `${root} exists but is not a directory.`,
@@ -178,7 +217,7 @@ async function walkNodeModules(cwd) {
 async function walk(dir, acc, depth) {
   let names;
   try {
-    names = await (0, import_promises2.readdir)(dir);
+    names = await (0, import_promises3.readdir)(dir);
   } catch {
     return;
   }
@@ -186,14 +225,14 @@ async function walk(dir, acc, depth) {
     if (name.startsWith(".")) {
       continue;
     }
-    const fullPath = import_node_path2.default.join(dir, name);
+    const fullPath = import_node_path3.default.join(dir, name);
     if (!await isPlainDirectory(fullPath)) {
       continue;
     }
     if (name.startsWith("@")) {
       let subNames;
       try {
-        subNames = await (0, import_promises2.readdir)(fullPath);
+        subNames = await (0, import_promises3.readdir)(fullPath);
       } catch {
         continue;
       }
@@ -201,7 +240,7 @@ async function walk(dir, acc, depth) {
         if (sub.startsWith(".")) {
           continue;
         }
-        const scopedDir = import_node_path2.default.join(fullPath, sub);
+        const scopedDir = import_node_path3.default.join(fullPath, sub);
         if (!await isPlainDirectory(scopedDir)) {
           continue;
         }
@@ -217,7 +256,7 @@ async function walk(dir, acc, depth) {
 async function readPackage(pkgDir, depth, acc) {
   let raw;
   try {
-    raw = await (0, import_promises2.readFile)(import_node_path2.default.join(pkgDir, "package.json"), "utf8");
+    raw = await (0, import_promises3.readFile)(import_node_path3.default.join(pkgDir, "package.json"), "utf8");
   } catch {
     return;
   }
@@ -240,7 +279,7 @@ async function readPackage(pkgDir, depth, acc) {
   });
 }
 async function walkNested(pkgDir, acc, depth) {
-  const nested = import_node_path2.default.join(pkgDir, "node_modules");
+  const nested = import_node_path3.default.join(pkgDir, "node_modules");
   if (!await isPlainDirectory(nested)) {
     return;
   }
@@ -248,7 +287,7 @@ async function walkNested(pkgDir, acc, depth) {
 }
 async function isPlainDirectory(dir) {
   try {
-    const info = await (0, import_promises2.lstat)(dir);
+    const info = await (0, import_promises3.lstat)(dir);
     return info.isDirectory() && !info.isSymbolicLink();
   } catch {
     return false;
@@ -256,11 +295,11 @@ async function isPlainDirectory(dir) {
 }
 
 // src/parsers/pnpm.ts
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 async function parsePnpmLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await (0, import_promises3.readFile)(lockfilePath, "utf8");
+    raw = await (0, import_promises4.readFile)(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(
       `Could not read lockfile at ${lockfilePath}`,
@@ -508,12 +547,12 @@ function extractLeafName(trimmed) {
 }
 
 // src/parsers/yarn.ts
-var import_promises4 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises5 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
 async function parseYarnLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await (0, import_promises4.readFile)(lockfilePath, "utf8");
+    raw = await (0, import_promises5.readFile)(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(
       `Could not read lockfile at ${lockfilePath}`,
@@ -528,7 +567,7 @@ async function parseYarnLockfile(lockfilePath) {
       "LOCKFILE_PARSE_ERROR"
     );
   }
-  const directNames = await readDirectDepNames(import_node_path3.default.dirname(lockfilePath));
+  const directNames = await readDirectDepNames(import_node_path4.default.dirname(lockfilePath));
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
   for (const block of blocks) {
@@ -672,7 +711,7 @@ async function readDirectDepNames(cwd) {
   const names = /* @__PURE__ */ new Set();
   let raw;
   try {
-    raw = await (0, import_promises4.readFile)(import_node_path3.default.join(cwd, "package.json"), "utf8");
+    raw = await (0, import_promises5.readFile)(import_node_path4.default.join(cwd, "package.json"), "utf8");
   } catch {
     return names;
   }
@@ -699,61 +738,99 @@ async function readDirectDepNames(cwd) {
 }
 
 // src/parsers/index.ts
+var LOCKFILE_CANDIDATES = [
+  { filename: "package-lock.json", strategy: "npm-lockfile" },
+  { filename: "bun.lock", strategy: "node-modules-walk" },
+  { filename: "bun.lockb", strategy: "node-modules-walk" },
+  { filename: "pnpm-lock.yaml", strategy: "pnpm-lockfile" },
+  { filename: "yarn.lock", strategy: "yarn-lockfile" }
+];
 async function detectLockfile(cwd) {
-  const npmLock = import_node_path4.default.join(cwd, "package-lock.json");
-  if (await exists(npmLock)) {
-    return {
-      ecosystem: "npm",
-      filePath: npmLock,
-      filename: "package-lock.json",
-      strategy: "npm-lockfile"
-    };
-  }
-  const bunLock = import_node_path4.default.join(cwd, "bun.lock");
-  if (await exists(bunLock)) {
-    return {
-      ecosystem: "npm",
-      filePath: bunLock,
-      filename: "bun.lock",
-      strategy: "node-modules-walk"
-    };
-  }
-  const bunLockB = import_node_path4.default.join(cwd, "bun.lockb");
-  if (await exists(bunLockB)) {
-    return {
-      ecosystem: "npm",
-      filePath: bunLockB,
-      filename: "bun.lockb",
-      strategy: "node-modules-walk"
-    };
-  }
-  const pnpmLock = import_node_path4.default.join(cwd, "pnpm-lock.yaml");
-  if (await exists(pnpmLock)) {
-    return {
-      ecosystem: "npm",
-      filePath: pnpmLock,
-      filename: "pnpm-lock.yaml",
-      strategy: "pnpm-lockfile"
-    };
-  }
-  const yarnLock = import_node_path4.default.join(cwd, "yarn.lock");
-  if (await exists(yarnLock)) {
+  const probed = await Promise.all(
+    LOCKFILE_CANDIDATES.map(async (candidate) => {
+      const filePath = import_node_path5.default.join(cwd, candidate.filename);
+      return { ...candidate, filePath, present: await exists(filePath) };
+    })
+  );
+  const match = probed.find((candidate) => candidate.present);
+  if (match) {
     return {
       ecosystem: "npm",
-      filePath: yarnLock,
-      filename: "yarn.lock",
-      strategy: "yarn-lockfile"
+      filePath: match.filePath,
+      filename: match.filename,
+      strategy: match.strategy
     };
   }
+  const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
   throw new PatchstackError(
-    `No lockfile found in ${cwd}. Expected one of: package-lock.json, bun.lock, bun.lockb, yarn.lock, pnpm-lock.yaml.`,
+    `No lockfile found in ${cwd}. Expected one of: ${expected}.`,
     "LOCKFILE_NOT_FOUND"
   );
 }
 async function scanLockfile(cwd) {
-  const detected = await detectLockfile(cwd);
-  const packages = await runStrategy(detected, cwd);
-  return { ecosystem: detected.ecosystem, packages };
+  const candidates = await presentLockfiles(cwd);
+  if (candidates.length === 0) {
+    await detectLockfile(cwd);
+  }
+  const declared = await readDeclaredDependencyNames(cwd);
+  const warnings = [];
+  let firstParsed = null;
+  let walkTried = false;
+  for (const candidate of candidates) {
+    let packages;
+    try {
+      packages = await runStrategy(candidate, cwd);
+    } catch {
+      continue;
+    }
+    walkTried ||= candidate.strategy === "node-modules-walk";
+    firstParsed ??= { packages, filename: candidate.filename };
+    const missing = missingDependencies(declared, packages);
+    if (missing.length === 0) {
+      return manifestWith(packages, warnings);
+    }
+    warnings.push(staleWarning(candidate.filename, missing));
+  }
+  if (!walkTried) {
+    try {
+      const packages = await walkNodeModules(cwd);
+      const missing = missingDependencies(declared, packages);
+      if (missing.length > 0) {
+        warnings.push(staleWarning("node_modules/", missing));
+      }
+      warnings.push("Scanned node_modules/ instead. Delete the stale lockfile to silence this warning.");
+      return manifestWith(packages, warnings);
+    } catch {
+    }
+  }
+  if (firstParsed === null) {
+    const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
+    throw new PatchstackError(
+      `No readable lockfile found in ${cwd}. Expected one of: ${expected}.`,
+      "LOCKFILE_NOT_FOUND"
+    );
+  }
+  warnings.push(
+    `No fully-consistent source found; reporting ${firstParsed.filename}. The manifest may understate the real dependency set.`
+  );
+  return manifestWith(firstParsed.packages, warnings);
+}
+function manifestWith(packages, warnings) {
+  return warnings.length > 0 ? { ecosystem: "npm", packages, warnings } : { ecosystem: "npm", packages };
+}
+function staleWarning(source, missing) {
+  const sample = missing.slice(0, 3).join(", ");
+  const suffix = missing.length > 3 ? `, +${missing.length - 3} more` : "";
+  return `${source} looks stale: package.json declares ${missing.length} dependenc${missing.length === 1 ? "y" : "ies"} it does not contain (${sample}${suffix}).`;
+}
+async function presentLockfiles(cwd) {
+  const probed = await Promise.all(
+    LOCKFILE_CANDIDATES.map(async (candidate) => {
+      const filePath = import_node_path5.default.join(cwd, candidate.filename);
+      return { ...candidate, filePath, present: await exists(filePath) };
+    })
+  );
+  return probed.filter((candidate) => candidate.present).map(({ filename, strategy, filePath }) => ({ ecosystem: "npm", filename, strategy, filePath }));
 }
 async function runStrategy(detected, cwd) {
   switch (detected.strategy) {
@@ -769,7 +846,7 @@ async function runStrategy(detected, cwd) {
 }
 async function exists(filePath) {
   try {
-    await (0, import_promises5.access)(filePath);
+    await (0, import_promises6.access)(filePath);
     return true;
   } catch {
     return false;
@@ -901,7 +978,7 @@ async function postManifest(config, payload) {
         Accept: "application/json",
         "User-Agent": "@patchstack/connect"
       },
-      body: JSON.stringify(payload),
+      body: JSON.stringify({ ...payload, environment: config.environment }),
       signal: AbortSignal.timeout(timeoutMs)
     });
   } catch (cause) {
@@ -956,15 +1033,24 @@ function isTimeoutError(cause) {
 }
 
 // src/config.ts
-var import_promises6 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises7 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
 var CONFIG_FILENAME = ".patchstackrc.json";
+var DEFAULT_ENVIRONMENT = "production";
 async function resolveConfig(options) {
   const fromFile = await readConfigFile(options.cwd);
   const fromEnv = readEnv();
   const siteUuid = options.cliSiteUuid ?? fromEnv.siteUuid ?? fromFile.siteUuid ?? null;
   const endpoint = options.cliEndpoint ?? fromEnv.endpoint ?? fromFile.endpoint ?? DEFAULT_ENDPOINT;
   const timeoutMs = fromEnv.timeoutMs ?? fromFile.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const environmentRaw = fromEnv.environment ?? fromFile.environment;
+  if (environmentRaw !== void 0 && !isEnvironment(environmentRaw)) {
+    throw new PatchstackError(
+      `Environment must be "production" or "sandbox"; got "${environmentRaw}".`,
+      "CONFIG_INVALID"
+    );
+  }
+  const environment = environmentRaw ?? DEFAULT_ENVIRONMENT;
   if (siteUuid !== null && siteUuid.length > 0 && !isUuid(siteUuid)) {
     throw new PatchstackError(
       `Site UUID "${siteUuid}" does not look like a valid UUID.`,
@@ -980,13 +1066,14 @@ async function resolveConfig(options) {
   return {
     siteUuid: siteUuid === null || siteUuid.length === 0 ? null : siteUuid,
     endpoint,
-    timeoutMs
+    timeoutMs,
+    environment
   };
 }
 async function writeConfigFile(cwd, config) {
-  const target = import_node_path5.default.join(cwd, CONFIG_FILENAME);
+  const target = import_node_path6.default.join(cwd, CONFIG_FILENAME);
   const content = JSON.stringify(config, null, 2) + "\n";
-  await (0, import_promises6.writeFile)(target, content, "utf8");
+  await (0, import_promises7.writeFile)(target, content, "utf8");
   return target;
 }
 async function persistSiteUuid(cwd, siteUuid) {
@@ -994,10 +1081,10 @@ async function persistSiteUuid(cwd, siteUuid) {
   return writeConfigFile(cwd, { ...existing, siteUuid });
 }
 async function readConfigFile(cwd) {
-  const target = import_node_path5.default.join(cwd, CONFIG_FILENAME);
+  const target = import_node_path6.default.join(cwd, CONFIG_FILENAME);
   let raw;
   try {
-    raw = await (0, import_promises6.readFile)(target, "utf8");
+    raw = await (0, import_promises7.readFile)(target, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return {};
@@ -1031,15 +1118,20 @@ function readEnv() {
     }
     timeoutMs = parsed;
   }
+  const environmentRaw = process.env.PATCHSTACK_ENVIRONMENT;
   return {
     siteUuid: process.env.PATCHSTACK_SITE_UUID ?? void 0,
     endpoint: process.env.PATCHSTACK_ENDPOINT ?? void 0,
-    timeoutMs
+    timeoutMs,
+    environment: environmentRaw !== void 0 && environmentRaw.length > 0 ? environmentRaw : void 0
   };
 }
 function isUuid(value) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
+function isEnvironment(value) {
+  return value === "production" || value === "sandbox";
+}
 
 // src/index.ts
 async function scanAndReport(options = {}) {