shop-cli 0.1.0 → 0.1.2

package/dist/cli/verbs/selling-plan-groups.js

@@ -181,22 +181,44 @@ const runSellingPlanGroups = async ({
     });
     const id = (0, import_shared.requireId)(args.id, "SellingPlanGroup");
     const variantIds = (0, import_shared.parseIds)(args["variant-ids"], "ProductVariant");
-    const mutationField = verb === "add-variants" ? "sellingPlanGroupAddProductVariants" : "sellingPlanGroupRemoveProductVariants";
-    const selection = verb === "add-variants" ? { sellingPlanGroup: sellingPlanGroupSummarySelection, userErrors: { field: true, message: true } } : { removedProductVariantIds: true, userErrors: { field: true, message: true } };
+    if (verb === "add-variants") {
+      const result2 = await (0, import_router.runMutation)(ctx, {
+        sellingPlanGroupAddProductVariants: {
+          __args: { id, productVariantIds: variantIds },
+          sellingPlanGroup: sellingPlanGroupSummarySelection,
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result2 === void 0) return;
+      const payload2 = result2.sellingPlanGroupAddProductVariants;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: payload2, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return console.log(payload2?.sellingPlanGroup?.id ?? "");
+      (0, import_output.printJson)(payload2, ctx.format !== "raw");
+      return;
+    }
     const result = await (0, import_router.runMutation)(ctx, {
-      [mutationField]: {
+      sellingPlanGroupRemoveProductVariants: {
         __args: { id, productVariantIds: variantIds },
-        ...selection
+        removedProductVariantIds: true,
+        userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
-    const payload = result[mutationField];
+    const payload = result.sellingPlanGroupRemoveProductVariants;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) {
-      if (verb === "add-variants") return console.log(payload?.sellingPlanGroup?.id ?? "");
-      return;
-    }
-    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    if (ctx.quiet) return console.log(id ?? "");
+    const groupResult = await (0, import_router.runQuery)(ctx, {
+      sellingPlanGroup: { __args: { id }, ...sellingPlanGroupSummarySelection }
+    });
+    if (groupResult === void 0) return;
+    (0, import_output.printJson)(
+      {
+        sellingPlanGroup: groupResult.sellingPlanGroup ?? null,
+        removedProductVariantIds: payload?.removedProductVariantIds ?? [],
+        userErrors: payload?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
     return;
   }
   throw new import_errors.CliError(`Unknown verb for selling-plan-groups: ${verb}`, 2);

package/dist/cli/verbs/subscription-contracts.js

@@ -121,6 +121,7 @@ const subscriptionContractFullSelection = {
 };
 const subscriptionDraftSummarySelection = {
   id: true,
+  originalContract: { id: true },
   customer: { id: true, displayName: true, email: true },
   currencyCode: true,
   billingPolicy: {

package/dist/cli/verbs/themes.js

@@ -269,6 +269,15 @@ const runThemes = async ({
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.themeFilesDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const deleted = result.themeFilesDelete?.deletedThemeFiles ?? [];
+      for (const f of deleted) {
+        const name = typeof f?.filename === "string" ? f.filename : "";
+        if (name) process.stdout.write(`${name}
+`);
+      }
+      return;
+    }
     (0, import_output.printJson)(result.themeFilesDelete, ctx.format !== "raw");
     return;
   }
@@ -285,6 +294,15 @@ const runThemes = async ({
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.themeFilesCopy, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const copied = result.themeFilesCopy?.copiedThemeFiles ?? [];
+      for (const f of copied) {
+        const name = typeof f?.filename === "string" ? f.filename : "";
+        if (name) process.stdout.write(`${name}
+`);
+      }
+      return;
+    }
     (0, import_output.printJson)(result.themeFilesCopy, ctx.format !== "raw");
     return;
   }

package/dist/cli/verbs/url-redirects.js

@@ -193,8 +193,26 @@ const runUrlRedirects = async ({
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.urlRedirectImportSubmit, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.urlRedirectImportSubmit?.job?.id ?? "");
-    (0, import_output.printJson)(result.urlRedirectImportSubmit, ctx.format !== "raw");
+    if (ctx.quiet) return console.log(id ?? "");
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "UrlRedirectImport",
+      view: ctx.view,
+      baseSelection: getUrlRedirectImportSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: true
+    });
+    const importResult = await (0, import_router.runQuery)(ctx, { urlRedirectImport: { __args: { id }, ...selection } });
+    if (importResult === void 0) return;
+    (0, import_output.printJson)(
+      {
+        urlRedirectImport: importResult.urlRedirectImport ?? null,
+        job: result.urlRedirectImportSubmit?.job ?? null,
+        userErrors: result.urlRedirectImportSubmit?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
     return;
   }
   if (verb === "import-get") {
@@ -224,6 +242,9 @@ const runUrlRedirects = async ({
     });
     if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
     if (verb === "bulk-delete-all") {
+      const countResult2 = await (0, import_router.runQuery)(ctx, {
+        urlRedirectsCount: { count: true, precision: true }
+      });
       const result2 = await (0, import_router.runMutation)(ctx, {
         urlRedirectBulkDeleteAll: {
           job: { id: true, done: true },
@@ -233,7 +254,14 @@ const runUrlRedirects = async ({
       if (result2 === void 0) return;
       (0, import_userErrors.maybeFailOnUserErrors)({ payload: result2.urlRedirectBulkDeleteAll, failOnUserErrors: ctx.failOnUserErrors });
       if (ctx.quiet) return console.log(result2.urlRedirectBulkDeleteAll?.job?.id ?? "");
-      (0, import_output.printJson)(result2.urlRedirectBulkDeleteAll, ctx.format !== "raw");
+      (0, import_output.printJson)(
+        {
+          job: result2.urlRedirectBulkDeleteAll?.job ?? null,
+          count: countResult2?.urlRedirectsCount ?? null,
+          userErrors: result2.urlRedirectBulkDeleteAll?.userErrors ?? []
+        },
+        ctx.format !== "raw"
+      );
       return;
     }
     if (verb === "bulk-delete-ids") {
@@ -248,13 +276,24 @@ const runUrlRedirects = async ({
       if (result2 === void 0) return;
       (0, import_userErrors.maybeFailOnUserErrors)({ payload: result2.urlRedirectBulkDeleteByIds, failOnUserErrors: ctx.failOnUserErrors });
       if (ctx.quiet) return console.log(result2.urlRedirectBulkDeleteByIds?.job?.id ?? "");
-      (0, import_output.printJson)(result2.urlRedirectBulkDeleteByIds, ctx.format !== "raw");
+      (0, import_output.printJson)(
+        {
+          job: result2.urlRedirectBulkDeleteByIds?.job ?? null,
+          requestedIds: ids,
+          requestedCount: ids.length,
+          userErrors: result2.urlRedirectBulkDeleteByIds?.userErrors ?? []
+        },
+        ctx.format !== "raw"
+      );
       return;
     }
     if (verb === "bulk-delete-saved-search") {
       const raw = args["saved-search-id"];
       if (!raw) throw new import_errors.CliError("Missing --saved-search-id", 2);
       const savedSearchId = (0, import_gid.coerceGid)(raw, "SavedSearch");
+      const countResult2 = await (0, import_router.runQuery)(ctx, {
+        urlRedirectsCount: { __args: { savedSearchId }, count: true, precision: true }
+      });
       const result2 = await (0, import_router.runMutation)(ctx, {
         urlRedirectBulkDeleteBySavedSearch: {
           __args: { savedSearchId },
@@ -268,11 +307,22 @@ const runUrlRedirects = async ({
         failOnUserErrors: ctx.failOnUserErrors
       });
       if (ctx.quiet) return console.log(result2.urlRedirectBulkDeleteBySavedSearch?.job?.id ?? "");
-      (0, import_output.printJson)(result2.urlRedirectBulkDeleteBySavedSearch, ctx.format !== "raw");
+      (0, import_output.printJson)(
+        {
+          job: result2.urlRedirectBulkDeleteBySavedSearch?.job ?? null,
+          count: countResult2?.urlRedirectsCount ?? null,
+          savedSearchId,
+          userErrors: result2.urlRedirectBulkDeleteBySavedSearch?.userErrors ?? []
+        },
+        ctx.format !== "raw"
+      );
       return;
     }
     const search = args.search;
     if (!search) throw new import_errors.CliError("Missing --search", 2);
+    const countResult = await (0, import_router.runQuery)(ctx, {
+      urlRedirectsCount: { __args: { query: search }, count: true, precision: true }
+    });
     const result = await (0, import_router.runMutation)(ctx, {
       urlRedirectBulkDeleteBySearch: {
         __args: { search },
@@ -286,7 +336,15 @@ const runUrlRedirects = async ({
       failOnUserErrors: ctx.failOnUserErrors
     });
     if (ctx.quiet) return console.log(result.urlRedirectBulkDeleteBySearch?.job?.id ?? "");
-    (0, import_output.printJson)(result.urlRedirectBulkDeleteBySearch, ctx.format !== "raw");
+    (0, import_output.printJson)(
+      {
+        job: result.urlRedirectBulkDeleteBySearch?.job ?? null,
+        count: countResult?.urlRedirectsCount ?? null,
+        search,
+        userErrors: result.urlRedirectBulkDeleteBySearch?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
     return;
   }
   if (verb === "get") {

package/dist/cli/workflows/files/stagedUploads.d.ts

@@ -15,11 +15,11 @@ export type StagedUploadTarget = {
         value: string;
     }>;
 };
-export declare const buildLocalFilesForStagedUpload: ({ filePaths, contentType, resource, }: {
+export declare const buildLocalFilesForStagedUpload: ({ filePaths, mimeType, resource, }: {
     filePaths: string[];
-    contentType?: string;
+    mimeType?: string;
     resource?: StagedUploadResource;
-}) => LocalFileForStagedUpload[];
+}) => Promise<LocalFileForStagedUpload[]>;
 export declare const stagedUploadsCreate: (ctx: CommandContext, localFiles: LocalFileForStagedUpload[]) => Promise<StagedUploadTarget[] | undefined>;
 export declare const uploadToStagedTarget: ({ target, localFile, }: {
     target: StagedUploadTarget;

package/dist/cli/workflows/files/stagedUploads.js

@@ -36,14 +36,15 @@ __export(stagedUploads_exports, {
 module.exports = __toCommonJS(stagedUploads_exports);
 var import_node_fs = require("node:fs");
 var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
 var import_mime_types = require("mime-types");
 var import_errors = require("../../errors");
 var import_router = require("../../router");
 var import_userErrors = require("../../userErrors");
-const guessMimeTypeFromFilename = (filename) => {
+const mimeTypeFromFilename = (filename) => {
   const mimeType = (0, import_mime_types.lookup)(filename);
   if (typeof mimeType === "string") return mimeType;
-  return "application/octet-stream";
+  return void 0;
 };
 const inferStagedUploadResource = ({
   filename,
@@ -57,26 +58,51 @@ const inferStagedUploadResource = ({
   }
   return "FILE";
 };
-const buildLocalFilesForStagedUpload = ({
+const sniffMimeTypeFromFile = async (filePath) => {
+  try {
+    const mod = await import("file-type");
+    const result = await mod.fileTypeFromFile(filePath);
+    return result?.mime;
+  } catch {
+    return void 0;
+  }
+};
+const resolveMimeType = async ({
+  filePath,
+  filename,
+  forcedMimeType
+}) => {
+  const forced = typeof forcedMimeType === "string" ? forcedMimeType.trim() : "";
+  if (forced) return forced;
+  const sniffed = await sniffMimeTypeFromFile(filePath);
+  if (sniffed) return sniffed;
+  const byExt = mimeTypeFromFilename(filename);
+  if (byExt) return byExt;
+  throw new import_errors.CliError(
+    `Unable to determine MIME type for ${filename}. Pass --mime-type <mime>.`,
+    2
+  );
+};
+const buildLocalFilesForStagedUpload = async ({
   filePaths,
-  contentType,
+  mimeType,
   resource
 }) => {
   if (filePaths.length === 0) return [];
-  return filePaths.map((filePath) => {
+  return Promise.all(filePaths.map(async (filePath) => {
     const stats = (0, import_node_fs.statSync)(filePath);
     if (!stats.isFile()) throw new import_errors.CliError(`Not a file: ${filePath}`, 2);
     const filename = import_node_path.default.basename(filePath);
-    const mimeType = contentType ?? guessMimeTypeFromFilename(filename);
-    const inferredResource = inferStagedUploadResource({ filename, mimeType });
+    const resolvedMimeType = await resolveMimeType({ filePath, filename, forcedMimeType: mimeType });
+    const inferredResource = inferStagedUploadResource({ filename, mimeType: resolvedMimeType });
     return {
       filePath,
       filename,
-      mimeType,
+      mimeType: resolvedMimeType,
       resource: resource ?? inferredResource,
       fileSize: stats.size
     };
-  });
+  }));
 };
 const stagedUploadsCreate = async (ctx, localFiles) => {
   const input = localFiles.map((f) => ({
@@ -137,19 +163,45 @@ const uploadToStagedTarget = async ({
   target,
   localFile
 }) => {
-  const body = (0, import_node_fs.readFileSync)(localFile.filePath);
-  const form = new FormData();
-  for (const p of target.parameters) form.set(p.name, p.value);
-  form.set("file", new Blob([body], { type: localFile.mimeType }), localFile.filename);
-  const res = await fetch(target.url, { method: "POST", body: form });
-  if (res.ok) return;
-  let details = "";
+  const args = ["--fail-with-body", "--silent", "--show-error", "-X", "POST"];
+  for (const p of target.parameters) {
+    args.push("--form-string", `${p.name}=${p.value}`);
+  }
+  args.push(
+    "--form",
+    `file=@${localFile.filePath};type=${localFile.mimeType};filename=${localFile.filename}`,
+    target.url
+  );
+  let child;
   try {
-    details = await res.text();
-  } catch {
+    child = (0, import_node_child_process.spawn)("curl", args, { stdio: ["ignore", "pipe", "pipe"] });
+  } catch (err) {
+    throw err;
   }
+  let stdout = "";
+  let stderr = "";
+  child.stdout?.on("data", (chunk) => {
+    stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+  });
+  const code = await new Promise((resolve, reject) => {
+    child.on("error", (err) => {
+      if (err && err.code === "ENOENT") {
+        reject(new import_errors.CliError("curl is required for streaming staged uploads (curl not found on PATH)", 2));
+        return;
+      }
+      reject(err);
+    });
+    child.on("close", (c) => resolve(c ?? 1));
+  });
+  if (code === 0) return;
+  const trimmedErr = stderr.trim();
+  const trimmedOut = stdout.trim();
+  const details = trimmedErr || trimmedOut;
   throw new import_errors.CliError(
-    `Staged upload failed for ${localFile.filename}: ${res.status} ${res.statusText}${details ? `
+    `Staged upload failed for ${localFile.filename}: curl exited with code ${code}${details ? `
 ${details}` : ""}`,
     2
   );

package/dist/cli/workflows/files/stdinFile.d.ts

@@ -0,0 +1,7 @@
+export declare const writeStdinToTempFile: ({ filename, stdin, }: {
+    filename: string;
+    stdin?: NodeJS.ReadableStream;
+}) => Promise<{
+    filePath: string;
+    cleanup: () => Promise<void>;
+}>;

package/dist/cli/workflows/files/stdinFile.js

@@ -0,0 +1,65 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdinFile_exports = {};
+__export(stdinFile_exports, {
+  writeStdinToTempFile: () => writeStdinToTempFile
+});
+module.exports = __toCommonJS(stdinFile_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_promises2 = require("node:stream/promises");
+var import_errors = require("../../errors");
+const safeBasename = (name) => name.replace(/[\\/]/g, "_");
+const writeStdinToTempFile = async ({
+  filename,
+  stdin = process.stdin
+}) => {
+  const raw = typeof filename === "string" ? filename.trim() : "";
+  if (!raw) throw new import_errors.CliError("Missing --filename (required with --file -)", 2);
+  const tempDir = await (0, import_promises.mkdtemp)(import_node_path.default.join(import_node_os.default.tmpdir(), "shop-cli-stdin-"));
+  const cleanup = async () => {
+    await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
+  };
+  try {
+    const filePath = import_node_path.default.join(tempDir, safeBasename(raw) || "stdin");
+    const out = (0, import_node_fs.createWriteStream)(filePath);
+    await (0, import_promises2.pipeline)(stdin, out);
+    return { filePath, cleanup };
+  } catch (err) {
+    await cleanup();
+    throw err;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeStdinToTempFile
+});
+//# sourceMappingURL=stdinFile.js.map

package/dist/cli/workflows/files/urlDownloads.d.ts

@@ -0,0 +1,14 @@
+export declare const inferFilenameFromUrl: (rawUrl: string) => string;
+export type DownloadedUrlFile = {
+    url: string;
+    filePath: string;
+    filename: string;
+};
+export declare const downloadUrlsToTempDir: ({ urls, filenameOverride, }: {
+    urls: string[];
+    filenameOverride?: string;
+}) => Promise<{
+    tempDir: string;
+    files: DownloadedUrlFile[];
+    cleanup: () => Promise<void>;
+}>;

package/dist/cli/workflows/files/urlDownloads.js

@@ -0,0 +1,114 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var urlDownloads_exports = {};
+__export(urlDownloads_exports, {
+  downloadUrlsToTempDir: () => downloadUrlsToTempDir,
+  inferFilenameFromUrl: () => inferFilenameFromUrl
+});
+module.exports = __toCommonJS(urlDownloads_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_promises2 = require("node:stream/promises");
+var import_node_stream = require("node:stream");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_errors = require("../../errors");
+const safeBasename = (name) => name.replace(/[\\/]/g, "_");
+const inferFilenameFromUrl = (rawUrl) => {
+  let u;
+  try {
+    u = new URL(rawUrl);
+  } catch {
+    throw new import_errors.CliError(`Invalid URL: ${rawUrl}`, 2);
+  }
+  const base = import_node_path.default.posix.basename(u.pathname || "");
+  if (base && base !== "/" && base !== ".") {
+    try {
+      const decoded = decodeURIComponent(base);
+      return safeBasename(decoded) || "download";
+    } catch {
+      return safeBasename(base) || "download";
+    }
+  }
+  return "download";
+};
+const uniqueFilename = (requested, used) => {
+  const base = safeBasename(requested) || "download";
+  const count = used.get(base) ?? 0;
+  used.set(base, count + 1);
+  if (count === 0) return base;
+  const ext = import_node_path.default.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  return `${stem}-${count + 1}${ext}`;
+};
+const downloadUrlsToTempDir = async ({
+  urls,
+  filenameOverride
+}) => {
+  if (urls.length === 0) throw new import_errors.CliError("Missing --url (repeatable)", 2);
+  if (filenameOverride && urls.length !== 1) {
+    throw new import_errors.CliError("--filename is only valid when exactly 1 --url is provided", 2);
+  }
+  const tempDir = await (0, import_promises.mkdtemp)(import_node_path.default.join(import_node_os.default.tmpdir(), "shop-cli-files-upload-"));
+  const cleanup = async () => {
+    await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
+  };
+  try {
+    await (0, import_promises.mkdir)(tempDir, { recursive: true });
+    const used = /* @__PURE__ */ new Map();
+    const files = [];
+    for (let i = 0; i < urls.length; i++) {
+      const url = urls[i];
+      const inferred = filenameOverride ?? inferFilenameFromUrl(url);
+      const filename = uniqueFilename(inferred, used);
+      const filePath = import_node_path.default.join(tempDir, filename);
+      const res = await fetch(url, { redirect: "follow" });
+      if (!res.ok) {
+        throw new import_errors.CliError(`Failed to download ${url}: ${res.status} ${res.statusText}`, 2);
+      }
+      if (!res.body) {
+        throw new import_errors.CliError(`Failed to download ${url}: empty response body`, 2);
+      }
+      const nodeStream = import_node_stream.Readable.fromWeb(res.body);
+      const out = (0, import_node_fs.createWriteStream)(filePath);
+      await (0, import_promises2.pipeline)(nodeStream, out);
+      files.push({ url, filePath, filename });
+    }
+    return { tempDir, files, cleanup };
+  } catch (err) {
+    await cleanup();
+    throw err;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadUrlsToTempDir,
+  inferFilenameFromUrl
+});
+//# sourceMappingURL=urlDownloads.js.map

package/dist/cli/workflows/files/waitForReady.d.ts

@@ -0,0 +1,20 @@
+import { type CommandContext } from '../../router';
+export type WaitForFilesResult = {
+    nodes: any[];
+    readyIds: string[];
+    failedIds: string[];
+};
+export declare const pollFilesReadyOrFailed: ({ ids, pollIntervalMs, timeoutMs, fetchNodes, now, sleep, }: {
+    ids: string[];
+    pollIntervalMs: number;
+    timeoutMs: number;
+    fetchNodes: (ids: string[]) => Promise<any[]>;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}) => Promise<WaitForFilesResult>;
+export declare const waitForFilesReadyOrFailed: ({ ctx, ids, pollIntervalMs, timeoutMs, }: {
+    ctx: CommandContext;
+    ids: string[];
+    pollIntervalMs: number;
+    timeoutMs: number;
+}) => Promise<WaitForFilesResult>;