run402 1.35.1 → 1.35.2

package/lib/blob.mjs

@@ -34,7 +34,7 @@ import { basename, dirname, join, resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
 import { pipeline } from "node:stream/promises";
 
-import { findProject, API } from "./config.mjs";
+import { resolveProject, API } from "./config.mjs";
 
 const HELP = `run402 blob — Direct-to-S3 blob storage
 
@@ -97,13 +97,6 @@ function parseArgs(args) {
   return out;
 }
 
-function resolveProject(projectId) {
-  if (!projectId) die("--project is required (or run 'run402 projects use <id>' to set default)");
-  const p = findProject(projectId);
-  if (!p) die(`Project not found: ${projectId}`);
-  return p;
-}
-
 async function sha256File(filePath) {
   const h = createHash("sha256");
   const stream = createReadStream(filePath);

package/lib/deploy.mjs

@@ -1,7 +1,7 @@
 import { readFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { Agent, fetch as undiciFetch } from "undici";
-import { API, allowanceAuthHeaders, findProject } from "./config.mjs";
+import { API, allowanceAuthHeaders, resolveProjectId } from "./config.mjs";
 import { resolveFilePathsInManifest, resolveMigrationsFile } from "./manifest.mjs";
 
 // Custom undici dispatcher with longer timeouts for large-batch deploys.
@@ -158,6 +158,91 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf-8");
 }
 
+/**
+ * Load + parse the manifest from --manifest file or stdin, and resolve any
+ * referenced files[].path / migrations_file against the manifest's directory.
+ *
+ * Returns { manifest } on success, or { error } with a structured error object
+ * on any fs / parse failure. Never throws.
+ *
+ * The returned error shape (GH-44):
+ *   { status: "error", message, field, path?, hint? }
+ * where `field` is one of: "manifest", "stdin", "migrations_file", "files[<i>].path".
+ */
+async function loadManifest(opts) {
+  let raw;
+  let baseDir = null;
+
+  // Step 1: read the manifest source.
+  if (opts.manifest) {
+    const manifestAbs = resolve(opts.manifest);
+    baseDir = dirname(manifestAbs);
+    try {
+      raw = readFileSync(opts.manifest, "utf-8");
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        return { error: {
+          status: "error",
+          message: `File not found: ${manifestAbs}`,
+          field: "manifest",
+          path: manifestAbs,
+          hint: "Check that --manifest points to an existing JSON file.",
+        } };
+      }
+      return { error: {
+        status: "error",
+        message: err && err.message ? err.message : String(err),
+        field: "manifest",
+        path: manifestAbs,
+        ...(err && err.code ? { code: err.code } : {}),
+      } };
+    }
+  } else {
+    raw = await readStdin();
+  }
+
+  // Step 2: parse JSON.
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch (err) {
+    return { error: {
+      status: "error",
+      message: `Manifest is not valid JSON: ${err.message}`,
+      field: opts.manifest ? "manifest" : "stdin",
+      ...(opts.manifest ? { path: resolve(opts.manifest) } : {}),
+    } };
+  }
+
+  // Step 3: resolve file paths (only when reading from a manifest file — we
+  // can't resolve relative paths without a baseDir).
+  if (opts.manifest) {
+    try {
+      resolveMigrationsFile(manifest, baseDir);
+      resolveFilePathsInManifest(manifest, baseDir);
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        return { error: {
+          status: "error",
+          message: `File not found: ${err.absPath || err.path || "<unknown>"}`,
+          field: err.field || "manifest",
+          ...(err.absPath || err.path ? { path: err.absPath || err.path } : {}),
+          hint: `Paths in manifest.${err.field || "files[].path"} are resolved relative to the manifest file's directory (${baseDir}).`,
+        } };
+      }
+      return { error: {
+        status: "error",
+        message: err && err.message ? err.message : String(err),
+        ...(err && err.field ? { field: err.field } : {}),
+        ...(err && (err.absPath || err.path) ? { path: err.absPath || err.path } : {}),
+        ...(err && err.code ? { code: err.code } : {}),
+      } };
+    }
+  }
+
+  return { manifest };
+}
+
 export async function run(args) {
   const opts = { manifest: null, project: null };
   for (let i = 0; i < args.length; i++) {
@@ -166,21 +251,42 @@ export async function run(args) {
     if (args[i] === "--project" && args[i + 1]) opts.project = args[++i];
   }
 
-  const raw = opts.manifest ? readFileSync(opts.manifest, "utf-8") : await readStdin();
-  const manifest = JSON.parse(raw);
-  if (opts.manifest) {
-    const baseDir = dirname(resolve(opts.manifest));
-    resolveMigrationsFile(manifest, baseDir);
-    resolveFilePathsInManifest(manifest, baseDir);
+  // Load + parse the manifest. Errors here (missing --manifest path, malformed
+  // JSON, or any referenced files[].path / migrations_file that doesn't exist)
+  // must be surfaced as structured JSON on stderr — never as a raw Node stack
+  // trace (GH-44). The CLI is agent-first; stack traces break JSON consumers.
+  const manifestResult = await loadManifest(opts);
+  if (manifestResult.error) {
+    console.error(JSON.stringify(manifestResult.error));
+    process.exit(1);
+  }
+  const manifest = manifestResult.manifest;
+
+  // If both sources set project_id and they disagree, refuse to deploy rather
+  // than silently shipping to the wrong target. Agents and humans should be
+  // forced to be explicit when the two sources conflict (GH-42).
+  if (opts.project && manifest.project_id && opts.project !== manifest.project_id) {
+    const err = {
+      status: "error",
+      message: `project_id conflict: manifest.project_id=${manifest.project_id} but --project=${opts.project}`,
+      manifest_project_id: manifest.project_id,
+      flag_project_id: opts.project,
+      hint: "Remove one of them or make them match. The --project flag and manifest.project_id must agree (or only one of them must be set).",
+    };
+    console.error(JSON.stringify(err));
+    process.exit(1);
   }
 
-  // --project flag overrides manifest's project_id
+  // --project flag fills in manifest's project_id when the manifest doesn't
+  // specify one. (When both are set they must already agree — enforced above.)
   if (opts.project) manifest.project_id = opts.project;
 
-  // If no project_id in manifest, use active project
+  // If no project_id in manifest, fall back to the active project.
+  // resolveProjectId() returns the active project id when its argument is
+  // falsy, and emits a clear error + exits non-zero when no active project
+  // is set either.
   if (!manifest.project_id) {
-    const { id } = findProject(null);
-    manifest.project_id = id;
+    manifest.project_id = resolveProjectId(null);
   }
 
   // Remove legacy 'name' field if present

package/lib/manifest.mjs

@@ -11,6 +11,12 @@ const TEXT_EXTS = new Set([
  * read the SQL from that file path and set `migrations` to its contents.
  * `migrations_file` is resolved relative to `baseDir`.
  *
+ * On read failure, re-throws the underlying fs error with additional context
+ * attached:
+ *   err.field = "migrations_file"
+ *   err.absPath = <absolute path that was attempted>
+ * (the original Error.code / Error.message / Error.path are preserved).
+ *
  * @param {object} manifest  Parsed manifest JSON (mutated in place)
  * @param {string} baseDir   Directory to resolve relative paths from
  * @returns {object}         The same manifest object
@@ -18,7 +24,13 @@ const TEXT_EXTS = new Set([
 export function resolveMigrationsFile(manifest, baseDir) {
   if (!manifest.migrations_file) return manifest;
   const abs = resolve(baseDir, manifest.migrations_file);
-  manifest.migrations = readFileSync(abs, "utf-8");
+  try {
+    manifest.migrations = readFileSync(abs, "utf-8");
+  } catch (err) {
+    err.field = "migrations_file";
+    err.absPath = abs;
+    throw err;
+  }
   delete manifest.migrations_file;
   return manifest;
 }
@@ -31,6 +43,12 @@ export function resolveMigrationsFile(manifest, baseDir) {
  *
  * Entries with `data` already set are left untouched.
  *
+ * On read failure, re-throws the underlying fs error with additional context
+ * attached:
+ *   err.field = `files[<i>].path`
+ *   err.absPath = <absolute path that was attempted>
+ * (the original Error.code / Error.message / Error.path are preserved).
+ *
  * @param {object} manifest  Parsed manifest JSON (mutated in place)
  * @param {string} baseDir   Directory to resolve relative paths from
  * @returns {object}         The same manifest object
@@ -38,18 +56,25 @@ export function resolveMigrationsFile(manifest, baseDir) {
 export function resolveFilePathsInManifest(manifest, baseDir) {
   if (!Array.isArray(manifest.files)) return manifest;
 
-  for (const entry of manifest.files) {
+  for (let i = 0; i < manifest.files.length; i++) {
+    const entry = manifest.files[i];
     if (!entry.path || entry.data !== undefined) continue;
 
     const abs = resolve(baseDir, entry.path);
     const ext = extname(abs).toLowerCase();
     const isText = TEXT_EXTS.has(ext);
 
-    if (isText) {
-      entry.data = readFileSync(abs, "utf-8");
-    } else {
-      entry.data = readFileSync(abs).toString("base64");
-      entry.encoding = "base64";
+    try {
+      if (isText) {
+        entry.data = readFileSync(abs, "utf-8");
+      } else {
+        entry.data = readFileSync(abs).toString("base64");
+        entry.encoding = "base64";
+      }
+    } catch (err) {
+      err.field = `files[${i}].path`;
+      err.absPath = abs;
+      throw err;
     }
 
     // If no explicit file (deploy target name), use the path value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "run402",
-  "version": "1.35.1",
+  "version": "1.35.2",
   "description": "CLI for Run402 — provision Postgres databases, deploy static sites, generate images, and manage wallets via x402 and MPP micropayments.",
   "type": "module",
   "bin": {