@patchstack/connect 0.2.6 → 0.2.8

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/parsers/index.ts
 import { access } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 
 // src/types.ts
 var PatchstackError = class extends Error {
@@ -14,13 +14,52 @@ var PatchstackError = class extends Error {
   cause;
 };
 
-// src/parsers/npm.ts
+// src/parsers/consistency.ts
 import { readFile } from "fs/promises";
 import path from "path";
+async function readDeclaredDependencyNames(cwd) {
+  let raw;
+  try {
+    raw = await readFile(path.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
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
 async function parseNpmLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await readFile(lockfilePath, "utf8");
+    raw = await readFile2(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(`Could not read lockfile at ${lockfilePath}`, "LOCKFILE_NOT_FOUND", cause);
   }
@@ -78,7 +117,7 @@ function extractFromV1(deps, acc = [], depth = 0) {
   return acc;
 }
 function extractNameFromPath(pkgPath) {
-  const segments = pkgPath.split("node_modules" + path.sep === pkgPath ? path.sep : "/");
+  const segments = pkgPath.split("node_modules" + path2.sep === pkgPath ? path2.sep : "/");
   const parts = pkgPath.split("/");
   const nmIndex = parts.lastIndexOf("node_modules");
   if (nmIndex === -1 || nmIndex >= parts.length - 1) {
@@ -101,10 +140,10 @@ function isDirectV2(pkgPath) {
 }
 
 // src/parsers/node_modules.ts
-import { lstat, readFile as readFile2, readdir, stat } from "fs/promises";
-import path2 from "path";
+import { lstat, readFile as readFile3, readdir, stat } from "fs/promises";
+import path3 from "path";
 async function walkNodeModules(cwd) {
-  const root = path2.join(cwd, "node_modules");
+  const root = path3.join(cwd, "node_modules");
   try {
     const info = await stat(root);
     if (!info.isDirectory()) {
@@ -138,7 +177,7 @@ async function walk(dir, acc, depth) {
     if (name.startsWith(".")) {
       continue;
     }
-    const fullPath = path2.join(dir, name);
+    const fullPath = path3.join(dir, name);
     if (!await isPlainDirectory(fullPath)) {
       continue;
     }
@@ -153,7 +192,7 @@ async function walk(dir, acc, depth) {
         if (sub.startsWith(".")) {
           continue;
         }
-        const scopedDir = path2.join(fullPath, sub);
+        const scopedDir = path3.join(fullPath, sub);
         if (!await isPlainDirectory(scopedDir)) {
           continue;
         }
@@ -169,7 +208,7 @@ async function walk(dir, acc, depth) {
 async function readPackage(pkgDir, depth, acc) {
   let raw;
   try {
-    raw = await readFile2(path2.join(pkgDir, "package.json"), "utf8");
+    raw = await readFile3(path3.join(pkgDir, "package.json"), "utf8");
   } catch {
     return;
   }
@@ -192,7 +231,7 @@ async function readPackage(pkgDir, depth, acc) {
   });
 }
 async function walkNested(pkgDir, acc, depth) {
-  const nested = path2.join(pkgDir, "node_modules");
+  const nested = path3.join(pkgDir, "node_modules");
   if (!await isPlainDirectory(nested)) {
     return;
   }
@@ -208,11 +247,11 @@ async function isPlainDirectory(dir) {
 }
 
 // src/parsers/pnpm.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 async function parsePnpmLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await readFile3(lockfilePath, "utf8");
+    raw = await readFile4(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(
       `Could not read lockfile at ${lockfilePath}`,
@@ -460,12 +499,12 @@ function extractLeafName(trimmed) {
 }
 
 // src/parsers/yarn.ts
-import { readFile as readFile4 } from "fs/promises";
-import path3 from "path";
+import { readFile as readFile5 } from "fs/promises";
+import path4 from "path";
 async function parseYarnLockfile(lockfilePath) {
   let raw;
   try {
-    raw = await readFile4(lockfilePath, "utf8");
+    raw = await readFile5(lockfilePath, "utf8");
   } catch (cause) {
     throw new PatchstackError(
       `Could not read lockfile at ${lockfilePath}`,
@@ -480,7 +519,7 @@ async function parseYarnLockfile(lockfilePath) {
       "LOCKFILE_PARSE_ERROR"
     );
   }
-  const directNames = await readDirectDepNames(path3.dirname(lockfilePath));
+  const directNames = await readDirectDepNames(path4.dirname(lockfilePath));
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
   for (const block of blocks) {
@@ -624,7 +663,7 @@ async function readDirectDepNames(cwd) {
   const names = /* @__PURE__ */ new Set();
   let raw;
   try {
-    raw = await readFile4(path3.join(cwd, "package.json"), "utf8");
+    raw = await readFile5(path4.join(cwd, "package.json"), "utf8");
   } catch {
     return names;
   }
@@ -651,61 +690,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 = path4.join(cwd, "package-lock.json");
-  if (await exists(npmLock)) {
-    return {
-      ecosystem: "npm",
-      filePath: npmLock,
-      filename: "package-lock.json",
-      strategy: "npm-lockfile"
-    };
-  }
-  const bunLock = path4.join(cwd, "bun.lock");
-  if (await exists(bunLock)) {
-    return {
-      ecosystem: "npm",
-      filePath: bunLock,
-      filename: "bun.lock",
-      strategy: "node-modules-walk"
-    };
-  }
-  const bunLockB = path4.join(cwd, "bun.lockb");
-  if (await exists(bunLockB)) {
-    return {
-      ecosystem: "npm",
-      filePath: bunLockB,
-      filename: "bun.lockb",
-      strategy: "node-modules-walk"
-    };
-  }
-  const pnpmLock = path4.join(cwd, "pnpm-lock.yaml");
-  if (await exists(pnpmLock)) {
-    return {
-      ecosystem: "npm",
-      filePath: pnpmLock,
-      filename: "pnpm-lock.yaml",
-      strategy: "pnpm-lockfile"
-    };
-  }
-  const yarnLock = path4.join(cwd, "yarn.lock");
-  if (await exists(yarnLock)) {
+  const probed = await Promise.all(
+    LOCKFILE_CANDIDATES.map(async (candidate) => {
+      const filePath = path5.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 = path5.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) {
@@ -853,7 +930,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) {
@@ -908,15 +985,24 @@ function isTimeoutError(cause) {
 }
 
 // src/config.ts
-import { readFile as readFile5, writeFile } from "fs/promises";
-import path5 from "path";
+import { readFile as readFile6, writeFile } from "fs/promises";
+import path6 from "path";
 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.`,
@@ -932,11 +1018,12 @@ async function resolveConfig(options) {
   return {
     siteUuid: siteUuid === null || siteUuid.length === 0 ? null : siteUuid,
     endpoint,
-    timeoutMs
+    timeoutMs,
+    environment
   };
 }
 async function writeConfigFile(cwd, config) {
-  const target = path5.join(cwd, CONFIG_FILENAME);
+  const target = path6.join(cwd, CONFIG_FILENAME);
   const content = JSON.stringify(config, null, 2) + "\n";
   await writeFile(target, content, "utf8");
   return target;
@@ -946,10 +1033,10 @@ async function persistSiteUuid(cwd, siteUuid) {
   return writeConfigFile(cwd, { ...existing, siteUuid });
 }
 async function readConfigFile(cwd) {
-  const target = path5.join(cwd, CONFIG_FILENAME);
+  const target = path6.join(cwd, CONFIG_FILENAME);
   let raw;
   try {
-    raw = await readFile5(target, "utf8");
+    raw = await readFile6(target, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return {};
@@ -983,15 +1070,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 = {}) {