@patchstack/connect 0.5.6 → 0.5.8

package/dist/index.js

@@ -1195,8 +1195,8 @@ function compareSegments(a, b) {
 var RULES = [
   { platform: "netlify", any: ["NETLIFY", "NETLIFY_BUILD_BASE", "DEPLOY_PRIME_URL"] },
   { platform: "vercel", any: ["VERCEL", "VERCEL_ENV", "VERCEL_URL"] },
-  { platform: "cloudflare", any: ["CF_PAGES", "CF_PAGES_URL", "CLOUDFLARE_ACCOUNT_ID"] },
-  { platform: "aws", any: ["AWS_APP_ID", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV"] },
+  { platform: "cloudflare", any: ["CF_PAGES", "CF_PAGES_URL", "WORKERS_CI", "WORKERS_CI_BRANCH", "CLOUDFLARE_ACCOUNT_ID"] },
+  { platform: "aws", any: ["AWS_APP_ID", "AWS_BRANCH", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV"] },
   { platform: "render", any: ["RENDER", "RENDER_SERVICE_ID", "RENDER_EXTERNAL_URL"] },
   { platform: "railway", any: ["RAILWAY_ENVIRONMENT", "RAILWAY_ENVIRONMENT_NAME", "RAILWAY_PROJECT_ID"] },
   { platform: "fly", any: ["FLY_APP_NAME", "FLY_REGION", "FLY_ALLOC_ID"] },
@@ -1219,6 +1219,128 @@ function detectHostingPlatform(env = process.env) {
   return { platform: null, evidence: [] };
 }
 
+// src/protect/safe-origin.js
+function isSafeOrigin(value) {
+  try {
+    const u = new URL(value);
+    if (u.protocol === "https:") return true;
+    return u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]" || u.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
+
+// src/endpoint-policy.ts
+function assertConnectableEndpoint(config, target = config.endpoint) {
+  if (config.endpointTrusted === false) {
+    throw new PatchstackError(
+      "The custom endpoint in .patchstackrc.json must be confirmed with --endpoint or PATCHSTACK_ENDPOINT before it can be used.",
+      "CONFIG_INVALID"
+    );
+  }
+  if (safeRemoteUrl(config.endpoint) === null) {
+    throw new PatchstackError(
+      "Patchstack endpoints must use HTTPS, except for localhost development endpoints.",
+      "CONFIG_INVALID"
+    );
+  }
+  let endpointOrigin;
+  let targetOrigin;
+  try {
+    endpointOrigin = new URL(config.endpoint).origin;
+    targetOrigin = new URL(target).origin;
+  } catch (cause) {
+    throw new PatchstackError("The configured Patchstack endpoint is not a valid URL.", "CONFIG_INVALID", cause);
+  }
+  if (safeRemoteUrl(target) === null || targetOrigin !== endpointOrigin) {
+    throw new PatchstackError(
+      "A Patchstack request resolved outside the configured endpoint origin.",
+      "CONFIG_INVALID"
+    );
+  }
+}
+function safeRemoteUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 2048) return null;
+  try {
+    const parsed = new URL(value);
+    if (!isSafeOrigin(parsed.toString()) || parsed.username !== "" || parsed.password !== "") return null;
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+function safeDisplayString(value, maxLength = 512) {
+  if (typeof value !== "string") return null;
+  const clean = value.replace(/\u001b(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001b\\))/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+  if (clean.length === 0) return null;
+  return clean.slice(0, maxLength);
+}
+function isCanonicalUuid(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function isCredential(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 33 || code > 126) return false;
+  }
+  const separator = value.lastIndexOf("-");
+  return separator > 0 && separator < value.length - 1 && /^\d+$/.test(value.slice(separator + 1));
+}
+function isHeaderValue(value, maxLength = 8192) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 33 || code > 126) return false;
+  }
+  return true;
+}
+
+// src/bounded-response.ts
+var MAX_CONTROL_RESPONSE_BYTES = 256 * 1024;
+async function readBoundedText(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const stated2 = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(stated2) && stated2 > maxBytes) {
+    void response.body?.cancel().catch(() => {
+    });
+    throw new Error(`response exceeds ${maxBytes} bytes`);
+  }
+  const stream = response.body;
+  if (stream === null || typeof stream.getReader !== "function") {
+    if (stated2 === 0) return "";
+    throw new Error("response body cannot be read with a size bound");
+  }
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        void reader.cancel().catch(() => {
+        });
+        throw new Error(`response exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function readBoundedJson(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const text = await readBoundedText(response, maxBytes);
+  return JSON.parse(text);
+}
+
 // src/pulse-token.ts
 var TOKEN_SKEW_MS = 6e4;
 function buildTokenUrl(manifestEndpoint) {
@@ -1236,22 +1358,48 @@ function parsePulseAuth(credential) {
   if (!/^\d+$/.test(clientId)) return null;
   return { clientId, clientSecret: credential.slice(0, index) };
 }
-var cached = null;
-var inflight = null;
-function clearPulseToken() {
-  cached = null;
+var cached = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+function cacheKey(tokenUrl, credential) {
+  return `${tokenUrl}
+${credential}`;
+}
+function clearPulseToken(config) {
+  if (!config || typeof config.pulseAuth !== "string") {
+    cached.clear();
+    inflight.clear();
+    return;
+  }
+  try {
+    const key = cacheKey(buildTokenUrl(config.endpoint), config.pulseAuth);
+    cached.delete(key);
+    inflight.delete(key);
+  } catch {
+  }
 }
 async function getPulseToken(config, fetchImpl = fetch) {
   if (typeof config.pulseAuth !== "string" || config.pulseAuth.length === 0) return null;
-  if (cached !== null && Date.now() < cached.expiresAt - TOKEN_SKEW_MS) {
-    return cached.token;
+  if (config.endpointTrusted === false) return null;
+  let tokenUrl;
+  try {
+    tokenUrl = buildTokenUrl(config.endpoint);
+  } catch {
+    return null;
+  }
+  if (!isSafeOrigin(tokenUrl)) return null;
+  const key = cacheKey(tokenUrl, config.pulseAuth);
+  const existing = cached.get(key);
+  if (existing !== void 0 && Date.now() < existing.expiresAt - TOKEN_SKEW_MS) {
+    return existing.token;
   }
-  if (inflight !== null) return inflight;
+  const pending = inflight.get(key);
+  if (pending !== void 0) return pending;
   const credentials = parsePulseAuth(config.pulseAuth);
   if (credentials === null) return null;
-  inflight = (async () => {
+  let exchange;
+  exchange = (async () => {
     try {
-      const response = await fetchImpl(buildTokenUrl(config.endpoint), {
+      const response = await fetchImpl(tokenUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -1266,25 +1414,27 @@ async function getPulseToken(config, fetchImpl = fetch) {
         signal: AbortSignal.timeout(config.timeoutMs)
       });
       if (!response.ok) return null;
-      const body = await response.json();
-      if (typeof body.access_token !== "string" || body.access_token.length === 0) return null;
+      const body = await readBoundedJson(response);
+      if (!isHeaderValue(body.access_token)) return null;
       const expiresIn = Number(body.expires_in);
       const ttlMs = Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1e3 : 36e5;
-      cached = { token: body.access_token, expiresAt: Date.now() + ttlMs };
+      cached.set(key, { token: body.access_token, expiresAt: Date.now() + ttlMs });
       return body.access_token;
     } catch {
       return null;
     } finally {
-      inflight = null;
+      if (inflight.get(key) === exchange) inflight.delete(key);
     }
   })();
-  return inflight;
+  inflight.set(key, exchange);
+  return exchange;
 }
 async function pulseAuthHeader(config, fetchImpl = fetch) {
   const token = await getPulseToken(config, fetchImpl);
   return token === null ? {} : { Authorization: `Bearer ${token}` };
 }
 async function pulseFetch(config, url, init, fetchImpl = fetch) {
+  assertConnectableEndpoint(config, url);
   const send = async () => {
     const auth = await pulseAuthHeader(config, fetchImpl);
     const response = await fetchImpl(url, {
@@ -1295,7 +1445,7 @@ async function pulseFetch(config, url, init, fetchImpl = fetch) {
   };
   const first = await send();
   if (first.response.status === 401 && first.authenticated) {
-    clearPulseToken();
+    clearPulseToken(config);
     return (await send()).response;
   }
   return first.response;
@@ -1306,7 +1456,7 @@ var DEFAULT_ENDPOINT = "https://api.patchstack.com/monitor/pulse/manifest";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var CLAIM_TOKEN_HEADER = "X-Patchstack-Claim-Token";
 function claimTokenHeader(config) {
-  return typeof config.claimToken === "string" && config.claimToken !== "" ? { [CLAIM_TOKEN_HEADER]: config.claimToken } : {};
+  return config.endpointTrusted !== false && isHeaderValue(config.claimToken) ? { [CLAIM_TOKEN_HEADER]: config.claimToken } : {};
 }
 function buildEndpointUrl(base, siteUuid) {
   const trimmed = base.replace(/\/$/, "");
@@ -1345,9 +1495,46 @@ function validationFields(body) {
   if (typeof errors !== "object" || errors === null || Array.isArray(errors)) return [];
   return Object.keys(errors);
 }
+function manifestResponse(body, provisioning) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+  const value = body;
+  if (typeof value.stored !== "boolean") return null;
+  const uuid = value.uuid === void 0 ? void 0 : isCanonicalUuid(value.uuid) ? value.uuid : null;
+  if (uuid === null || provisioning && uuid === void 0) return null;
+  if (value.api_key !== void 0 && !isCredential(value.api_key)) return null;
+  if (value.manifest_id !== void 0 && (!Number.isInteger(value.manifest_id) || Number(value.manifest_id) <= 0)) return null;
+  const claimValue = value.claim;
+  let claim2;
+  if (claimValue !== void 0) {
+    if (typeof claimValue !== "object" || claimValue === null || Array.isArray(claimValue)) return null;
+    const raw = claimValue;
+    if (!["claimed", "owned-by-you", "owned-by-other", "rejected"].includes(String(raw.state))) return null;
+    const dashboardUrl = raw.dashboard_url === void 0 || raw.dashboard_url === null ? null : safeRemoteUrl(raw.dashboard_url);
+    if (raw.dashboard_url !== void 0 && raw.dashboard_url !== null && dashboardUrl === null) return null;
+    claim2 = {
+      state: raw.state,
+      ...Number.isInteger(raw.site_id) ? { site_id: Number(raw.site_id) } : {},
+      ...dashboardUrl !== null ? { dashboard_url: dashboardUrl } : {},
+      ...raw.reason === "expired" || raw.reason === "invalid" ? { reason: raw.reason } : {}
+    };
+  }
+  const result = {
+    stored: value.stored,
+    ...uuid !== void 0 ? { uuid } : {},
+    ...typeof value.api_key === "string" ? { api_key: value.api_key } : {},
+    ...Number.isInteger(value.manifest_id) ? { manifest_id: Number(value.manifest_id) } : {},
+    ...safeDisplayString(value.checksum, 256) !== null ? { checksum: safeDisplayString(value.checksum, 256) } : {},
+    ...safeDisplayString(value.reason) !== null ? { reason: safeDisplayString(value.reason) } : {},
+    ...safeDisplayString(value.message) !== null ? { message: safeDisplayString(value.message) } : {},
+    ...safeDisplayString(value.error) !== null ? { error: safeDisplayString(value.error) } : {},
+    ...claim2 !== void 0 ? { claim: claim2 } : {}
+  };
+  return result;
+}
 async function postManifest(config, payload) {
   const url = buildEndpointUrl(config.endpoint, config.siteUuid);
   const timeoutMs = config.timeoutMs;
+  assertConnectableEndpoint(config, url);
   let response;
   try {
     response = await pulseFetch(config, url, {
@@ -1375,25 +1562,27 @@ async function postManifest(config, payload) {
       cause
     );
   }
-  const text = await response.text();
-  let body = null;
+  let text = "";
+  let parsed = null;
   try {
-    body = text.length > 0 ? JSON.parse(text) : null;
+    text = await readBoundedText(response);
+    parsed = text.length > 0 ? JSON.parse(text) : null;
   } catch {
-    body = null;
+    parsed = null;
   }
+  const body = manifestResponse(parsed, config.siteUuid === null);
   if (response.status === 404) {
     throw new PatchstackError(
-      body?.error ?? "Site not found. Check that your site UUID is correct and that the app is registered as a Pulse app in your Patchstack dashboard.",
+      safeDisplayString(parsed?.error) ?? "Site not found. Check that your site UUID is correct and that the app is registered as a Pulse app in your Patchstack dashboard.",
       "SITE_NOT_FOUND"
     );
   }
   if (response.status === 422) {
     const refused2 = new PatchstackError(
-      body?.message ?? "Patchstack rejected the manifest payload (validation failed).",
+      safeDisplayString(parsed?.message) ?? "Patchstack rejected the manifest payload (validation failed).",
       "VALIDATION_ERROR"
     );
-    refused2.fields = validationFields(body);
+    refused2.fields = validationFields(parsed);
     throw refused2;
   }
   const refused = authFailureMessage(response.status, config);
@@ -1402,12 +1591,12 @@ async function postManifest(config, payload) {
   }
   if (response.status < 200 || response.status >= 300) {
     throw new PatchstackError(
-      `Patchstack returned ${response.status}: ${text.slice(0, 200)}`,
+      `Patchstack returned ${response.status}: ${safeDisplayString(text, 200) ?? "no response details"}`,
       "SERVER_ERROR"
     );
   }
   if (body === null) {
-    throw new PatchstackError("Patchstack returned an empty response.", "SERVER_ERROR");
+    throw new PatchstackError("Patchstack returned an unexpected response.", "SERVER_ERROR");
   }
   return body;
 }
@@ -1419,13 +1608,25 @@ function isTimeoutError(cause) {
 }
 
 // src/config.ts
-import { readFile as readFile8, writeFile, chmod } from "fs/promises";
+import { readFile as readFile8, chmod, lstat as lstat2, open, rename, unlink } from "fs/promises";
 import path8 from "path";
+import { randomUUID } from "crypto";
 
 // src/environment.ts
 import { readFileSync } from "fs";
 import path6 from "path";
 var set = (value) => value !== void 0 && value !== "";
+var PRODUCTION_BRANCHES = /* @__PURE__ */ new Set([
+  "main",
+  "master",
+  "production",
+  "prod",
+  "release",
+  "live"
+]);
+function environmentFromBranch(variable, branch) {
+  return PRODUCTION_BRANCHES.has(branch.toLowerCase()) ? { environment: "production", evidence: `${variable}=${branch} (a production branch by name)` } : { environment: "sandbox", evidence: `${variable}=${branch} (not a production branch by name)` };
+}
 var DISCRIMINATORS = [
   {
     platform: "vercel",
@@ -1454,6 +1655,79 @@ var DISCRIMINATORS = [
       if (!set(env.RAILWAY_ENVIRONMENT_NAME)) return null;
       return env.RAILWAY_ENVIRONMENT_NAME === "production" ? { environment: "production", evidence: "RAILWAY_ENVIRONMENT_NAME=production" } : { environment: "sandbox", evidence: `RAILWAY_ENVIRONMENT_NAME=${env.RAILWAY_ENVIRONMENT_NAME}` };
     }
+  },
+  {
+    // Pages and Workers Builds both name the branch and neither names the tier.
+    platform: "cloudflare",
+    read: (env) => {
+      if (set(env.CF_PAGES) && set(env.CF_PAGES_BRANCH)) {
+        return environmentFromBranch("CF_PAGES_BRANCH", env.CF_PAGES_BRANCH);
+      }
+      if (set(env.WORKERS_CI) && set(env.WORKERS_CI_BRANCH)) {
+        return environmentFromBranch("WORKERS_CI_BRANCH", env.WORKERS_CI_BRANCH);
+      }
+      return null;
+    }
+  },
+  {
+    // Amplify names the branch, and separately whether the build is a pull-request preview.
+    platform: "aws",
+    read: (env) => {
+      if (!set(env.AWS_APP_ID) || !set(env.AWS_BRANCH)) return null;
+      return set(env.AWS_PULL_REQUEST_ID) ? { environment: "sandbox", evidence: "AWS_PULL_REQUEST_ID set (a pull-request preview)" } : environmentFromBranch("AWS_BRANCH", env.AWS_BRANCH);
+    }
+  },
+  {
+    // A Deployment build carries `REPLIT_DEPLOYMENT`; the workspace carries `REPL_ID` alone. Read here,
+    // before the hosted-builder rule, so a workspace build in a Replit project is not its publish step.
+    platform: "replit",
+    read: (env) => {
+      if (set(env.REPLIT_DEPLOYMENT)) {
+        return { environment: "production", evidence: "REPLIT_DEPLOYMENT set (a Replit Deployment build)" };
+      }
+      if (set(env.REPL_ID)) {
+        return { environment: "sandbox", evidence: "REPL_ID set without REPLIT_DEPLOYMENT (the workspace)" };
+      }
+      return null;
+    }
+  },
+  {
+    // GitHub Pages deploys build here. A pull request checks out a merge ref whose name says nothing, so
+    // the event is read first; a tag is a release; otherwise the branch name decides.
+    platform: "github-actions",
+    read: (env) => {
+      if (env.GITHUB_ACTIONS !== "true") return null;
+      if (set(env.GITHUB_EVENT_NAME) && env.GITHUB_EVENT_NAME.startsWith("pull_request")) {
+        return { environment: "sandbox", evidence: `GITHUB_EVENT_NAME=${env.GITHUB_EVENT_NAME} (a pull-request build)` };
+      }
+      if (env.GITHUB_REF_TYPE === "tag") {
+        return { environment: "production", evidence: "GITHUB_REF_TYPE=tag (a tag build)" };
+      }
+      if (!set(env.GITHUB_REF_NAME)) return null;
+      return environmentFromBranch("GITHUB_REF_NAME", env.GITHUB_REF_NAME);
+    }
+  },
+  {
+    // The tier, when a job declares one, is GitLab's own word for it. Without one: a merge request is a
+    // check, a tag is a release, the default branch goes live, and any other branch name decides.
+    platform: "gitlab-ci",
+    read: (env) => {
+      if (env.GITLAB_CI !== "true") return null;
+      if (set(env.CI_ENVIRONMENT_TIER)) {
+        return env.CI_ENVIRONMENT_TIER === "production" ? { environment: "production", evidence: "CI_ENVIRONMENT_TIER=production" } : { environment: "sandbox", evidence: `CI_ENVIRONMENT_TIER=${env.CI_ENVIRONMENT_TIER}` };
+      }
+      if (set(env.CI_MERGE_REQUEST_IID)) {
+        return { environment: "sandbox", evidence: "CI_MERGE_REQUEST_IID set (a merge-request build)" };
+      }
+      if (set(env.CI_COMMIT_TAG)) {
+        return { environment: "production", evidence: "CI_COMMIT_TAG set (a tag build)" };
+      }
+      if (!set(env.CI_COMMIT_BRANCH)) return null;
+      if (set(env.CI_DEFAULT_BRANCH) && env.CI_COMMIT_BRANCH === env.CI_DEFAULT_BRANCH) {
+        return { environment: "production", evidence: `CI_COMMIT_BRANCH=${env.CI_COMMIT_BRANCH} (the default branch)` };
+      }
+      return environmentFromBranch("CI_COMMIT_BRANCH", env.CI_COMMIT_BRANCH);
+    }
   }
 ];
 var HOSTED_BUILDER_PACKAGES = [
@@ -1691,7 +1965,15 @@ async function resolveConfig(options) {
   const fromSecretFile = await readSecretFile(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 endpointRaw = options.cliEndpoint ?? fromEnv.endpoint ?? fromFile.endpoint ?? DEFAULT_ENDPOINT;
+  const endpointTrusted = endpointRaw === DEFAULT_ENDPOINT || options.cliEndpoint !== void 0 || fromEnv.endpoint !== void 0 || fromFile.endpoint === void 0;
+  const endpoint = safeRemoteUrl(endpointRaw);
+  if (endpoint === null) {
+    throw new PatchstackError(
+      "Patchstack endpoints must be valid HTTPS URLs, except for localhost development endpoints.",
+      "CONFIG_INVALID"
+    );
+  }
   const timeoutMs = fromEnv.timeoutMs ?? fromFile.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const environmentRaw = fromEnv.environment ?? fromFile.environment;
   if (environmentRaw !== void 0 && !isEnvironment(environmentRaw)) {
@@ -1703,7 +1985,7 @@ async function resolveConfig(options) {
   const inferred = environmentRaw === void 0 ? inferEnvironment(process.env, detectHostedBuilder(options.cwd)) : null;
   const environment = environmentRaw ?? inferred.environment;
   const environmentEvidence = inferred?.evidence ?? [];
-  if (siteUuid !== null && siteUuid.length > 0 && !isUuid(siteUuid)) {
+  if (siteUuid !== null && siteUuid.length > 0 && !isCanonicalUuid(siteUuid)) {
     throw new PatchstackError(
       `Site UUID "${siteUuid}" does not look like a valid UUID.`,
       "CONFIG_INVALID"
@@ -1726,6 +2008,7 @@ async function resolveConfig(options) {
     siteUrl: identity.url,
     siteName: identity.name,
     endpoint,
+    endpointTrusted,
     timeoutMs,
     environment,
     environmentEvidence,
@@ -1736,12 +2019,12 @@ async function resolveConfig(options) {
 async function writeConfigFile(cwd, config) {
   const target = path8.join(cwd, CONFIG_FILENAME);
   const content = JSON.stringify(config, null, 2) + "\n";
-  await writeFile(target, content, "utf8");
+  await writeAtomicFile(target, content, 420);
   return target;
 }
 async function writeSecretFile(cwd, secrets) {
   const target = path8.join(cwd, SECRET_FILENAME);
-  await writeFile(target, JSON.stringify(secrets, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  await writeAtomicFile(target, JSON.stringify(secrets, null, 2) + "\n", 384);
   try {
     await chmod(target, 384);
   } catch {
@@ -1749,6 +2032,39 @@ async function writeSecretFile(cwd, secrets) {
   const ignore = await ensureIgnored(cwd, SECRET_FILENAME);
   return { path: target, ...ignore };
 }
+async function writeAtomicFile(target, content, mode) {
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    handle = await open(temporary, "wx", mode);
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    try {
+      await rename(temporary, target);
+    } catch (error) {
+      const code = error.code;
+      if (process.platform !== "win32" || code !== "EEXIST" && code !== "EPERM") throw error;
+      try {
+        await unlink(target);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      await rename(temporary, target);
+    }
+  } catch (error) {
+    try {
+      await handle?.close();
+    } catch {
+    }
+    try {
+      await unlink(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
 async function ensureIgnored(cwd, entry) {
   const target = path8.join(cwd, ".gitignore");
   let existing = "";
@@ -1767,7 +2083,7 @@ async function ensureIgnored(cwd, entry) {
 ${entry}
 `;
   try {
-    await writeFile(target, existing + block, "utf8");
+    await writeAtomicFile(target, existing + block, 420);
   } catch (err) {
     const code = err.code;
     return { ignored: false, reason: `.gitignore could not be written (${code ?? "unknown error"})` };
@@ -1820,8 +2136,15 @@ async function readJsonFile(cwd, filename) {
   const target = path8.join(cwd, filename);
   let raw;
   try {
+    if ((await lstat2(target)).isSymbolicLink()) {
+      throw new PatchstackError(
+        `Could not read ${target}: configuration files must not be symbolic links.`,
+        "CONFIG_INVALID"
+      );
+    }
     raw = await readFile8(target, "utf8");
   } catch (err) {
+    if (err instanceof PatchstackError) throw err;
     if (err.code === "ENOENT") {
       return {};
     }
@@ -1866,9 +2189,6 @@ function readEnv() {
     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" || value === "local";
 }
@@ -1963,8 +2283,110 @@ function isEmptyStack(stack) {
 }
 
 // src/widget.ts
-import { existsSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync3 } from "fs";
 import path9 from "path";
+
+// src/safe-file.ts
+import {
+  chmodSync,
+  closeSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function pathError(message) {
+  return Object.assign(new Error(message), { code: "EINVAL" });
+}
+function existingEntry(path10) {
+  try {
+    return lstatSync(path10);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function assertWritableTarget(target) {
+  const entry = existingEntry(target);
+  if (entry?.isSymbolicLink()) throw pathError(`refusing to replace symbolic link: ${target}`);
+  if (entry && !entry.isFile()) throw pathError(`refusing to replace non-file path: ${target}`);
+  return entry;
+}
+function atomicWriteFileSync(target, content, options = {}) {
+  const current = assertWritableTarget(target);
+  const preserveMode = options.preserveMode !== false;
+  const exactMode = options.mode ?? (preserveMode && current ? current.mode & 4095 : options.createMode);
+  const temporary = join(dirname(target), `.${randomUUID2()}.patchstack-tmp`);
+  let descriptor = null;
+  try {
+    descriptor = openSync(temporary, "wx", exactMode ?? 438);
+    writeFileSync(descriptor, content, options.encoding);
+    fsyncSync(descriptor);
+    closeSync(descriptor);
+    descriptor = null;
+    if (exactMode !== void 0) chmodSync(temporary, exactMode);
+    try {
+      renameSync(temporary, target);
+    } catch (error) {
+      const code = error.code;
+      if (process.platform !== "win32" || code !== "EEXIST" && code !== "EPERM") throw error;
+      try {
+        unlinkSync(target);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      renameSync(temporary, target);
+    }
+  } catch (error) {
+    if (descriptor !== null) {
+      try {
+        closeSync(descriptor);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+function projectTarget(cwd, target, allowRoot = false) {
+  const logicalRoot = resolve(cwd);
+  const logicalTarget = isAbsolute(target) ? resolve(target) : resolve(logicalRoot, target);
+  const rel = relative(logicalRoot, logicalTarget);
+  if (!allowRoot && rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    throw pathError(`path is outside the project: ${target}`);
+  }
+  const root = realpathSync(logicalRoot);
+  return { root, path: rel === "" ? root : join(root, rel), parts: rel === "" ? [] : rel.split(sep) };
+}
+function assertProjectParents(root, parts) {
+  let current = root;
+  for (const part of parts.slice(0, -1)) {
+    current = join(current, part);
+    const entry = existingEntry(current);
+    if (entry === null) throw Object.assign(new Error(`project directory does not exist: ${current}`), { code: "ENOENT" });
+    if (entry.isSymbolicLink() || !entry.isDirectory()) {
+      throw pathError(`project path contains a non-directory or symbolic link: ${current}`);
+    }
+  }
+}
+function writeProjectFileSync(cwd, target, content, options = {}) {
+  const resolved = projectTarget(cwd, target);
+  assertProjectParents(resolved.root, resolved.parts);
+  atomicWriteFileSync(resolved.path, content, options);
+}
+
+// src/widget.ts
 var WIDGET_SCRIPT_URL = "https://cdn.patchstack.com/patchstack-widget.js";
 var WIDGET_MARKER_ATTR = "data-patchstack-connect-widget";
 var WIDGET_NEEDLE = "patchstack-widget";
@@ -2017,10 +2439,10 @@ function ensureSourceWidget(cwd, siteUuid, jsxShell = null) {
   if (!existsSync(file)) {
     return { shell: null, action: "no-shell" };
   }
-  const before = readFileSync2(file, "utf8");
+  const before = readFileSync3(file, "utf8");
   const { html, action } = ensureWidgetInHtml(before, siteUuid);
   if (html !== before) {
-    writeFileSync(file, html);
+    writeProjectFileSync(cwd, file, html, { encoding: "utf8" });
   }
   return { shell, action };
 }