shop-cli 0.1.1

package/dist/cli/verbs/webhooks.js

@@ -0,0 +1,336 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webhooks_exports = {};
+__export(webhooks_exports, {
+  runWebhooks: () => runWebhooks
+});
+module.exports = __toCommonJS(webhooks_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_shared = require("./_shared");
+const webhookSummarySelection = {
+  id: true,
+  topic: true,
+  uri: true,
+  format: true,
+  createdAt: true,
+  updatedAt: true
+};
+const webhookFullSelection = {
+  ...webhookSummarySelection,
+  filter: true,
+  includeFields: true,
+  metafieldNamespaces: true
+};
+const getWebhookSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return webhookFullSelection;
+  if (view === "raw") return {};
+  return webhookSummarySelection;
+};
+const runWebhooks = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop webhooks <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete|count",
+        "  pubsub-create|pubsub-update",
+        "  event-bridge-create|event-bridge-update",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { limit: { type: "string" } }
+    });
+    const query = args.query;
+    const limitRaw = args.limit;
+    const limit = limitRaw === void 0 || limitRaw === null || limitRaw === "" ? void 0 : Number(limitRaw);
+    if (limit !== void 0 && (!Number.isFinite(limit) || limit <= 0)) {
+      throw new import_errors.CliError("--limit must be a positive number", 2);
+    }
+    const result = await (0, import_router.runQuery)(ctx, {
+      webhookSubscriptionsCount: {
+        __args: {
+          ...query ? { query } : {},
+          ...limit !== void 0 ? { limit: Math.floor(limit) } : {}
+        },
+        count: true,
+        precision: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.webhookSubscriptionsCount?.count ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "event-bridge-create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { topic: { type: "string" } } });
+    const topic = args.topic;
+    if (!topic) throw new import_errors.CliError("Missing --topic", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      eventBridgeWebhookSubscriptionCreate: {
+        __args: { topic, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.eventBridgeWebhookSubscriptionCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.eventBridgeWebhookSubscriptionCreate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.eventBridgeWebhookSubscriptionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "event-bridge-update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      eventBridgeWebhookSubscriptionUpdate: {
+        __args: { id, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.eventBridgeWebhookSubscriptionUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.eventBridgeWebhookSubscriptionUpdate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.eventBridgeWebhookSubscriptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "webhooks",
+      view: ctx.view,
+      baseSelection: getWebhookSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { webhookSubscription: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.webhookSubscription, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const query = args.query;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "webhooks",
+      view: ctx.view,
+      baseSelection: getWebhookSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      webhookSubscriptions: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.webhookSubscriptions,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("webhooks", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "pubsub-create") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { topic: { type: "string" }, "pubsub-project": { type: "string" }, "pubsub-topic": { type: "string" } }
+    });
+    const topic = args.topic;
+    if (!topic) throw new import_errors.CliError("Missing --topic", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : {};
+    const pubSubProject = args["pubsub-project"] ?? input.pubSubProject;
+    const pubSubTopic = args["pubsub-topic"] ?? input.pubSubTopic;
+    if (!pubSubProject) throw new import_errors.CliError("Missing --pubsub-project", 2);
+    if (!pubSubTopic) throw new import_errors.CliError("Missing --pubsub-topic", 2);
+    const webhookSubscription = { ...input, pubSubProject, pubSubTopic };
+    const result = await (0, import_router.runMutation)(ctx, {
+      pubSubWebhookSubscriptionCreate: {
+        __args: { topic, webhookSubscription },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.pubSubWebhookSubscriptionCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.pubSubWebhookSubscriptionCreate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.pubSubWebhookSubscriptionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "pubsub-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "pubsub-project": { type: "string" }, "pubsub-topic": { type: "string" } }
+    });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : {};
+    const pubSubProject = args["pubsub-project"] ?? input.pubSubProject;
+    const pubSubTopic = args["pubsub-topic"] ?? input.pubSubTopic;
+    if (!pubSubProject) throw new import_errors.CliError("Missing --pubsub-project", 2);
+    if (!pubSubTopic) throw new import_errors.CliError("Missing --pubsub-topic", 2);
+    const webhookSubscription = { ...input, pubSubProject, pubSubTopic };
+    const result = await (0, import_router.runMutation)(ctx, {
+      pubSubWebhookSubscriptionUpdate: {
+        __args: { id, webhookSubscription },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.pubSubWebhookSubscriptionUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.pubSubWebhookSubscriptionUpdate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.pubSubWebhookSubscriptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { topic: { type: "string" } } });
+    const topic = args.topic;
+    if (!topic) throw new import_errors.CliError("Missing --topic", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      webhookSubscriptionCreate: {
+        __args: { topic, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.webhookSubscriptionCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.webhookSubscriptionCreate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json (webhookSubscription)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      webhookSubscriptionUpdate: {
+        __args: { id, webhookSubscription: built.input },
+        webhookSubscription: webhookSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.webhookSubscriptionUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.webhookSubscriptionUpdate?.webhookSubscription?.id ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "WebhookSubscription");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      webhookSubscriptionDelete: {
+        __args: { id },
+        deletedWebhookSubscriptionId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.webhookSubscriptionDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.webhookSubscriptionDelete?.deletedWebhookSubscriptionId ?? "");
+    (0, import_output.printJson)(result.webhookSubscriptionDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for webhooks: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runWebhooks
+});
+//# sourceMappingURL=webhooks.js.map

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

@@ -0,0 +1,28 @@
+import { type CommandContext } from '../../router';
+export type StagedUploadResource = 'FILE' | 'IMAGE' | 'VIDEO' | 'MODEL_3D';
+export type LocalFileForStagedUpload = {
+    filePath: string;
+    filename: string;
+    mimeType: string;
+    resource: StagedUploadResource;
+    fileSize: number;
+};
+export type StagedUploadTarget = {
+    url: string;
+    resourceUrl: string;
+    parameters: Array<{
+        name: string;
+        value: string;
+    }>;
+};
+export declare const buildLocalFilesForStagedUpload: ({ filePaths, mimeType, resource, }: {
+    filePaths: string[];
+    mimeType?: string;
+    resource?: StagedUploadResource;
+}) => Promise<LocalFileForStagedUpload[]>;
+export declare const stagedUploadsCreate: (ctx: CommandContext, localFiles: LocalFileForStagedUpload[]) => Promise<StagedUploadTarget[] | undefined>;
+export declare const uploadToStagedTarget: ({ target, localFile, }: {
+    target: StagedUploadTarget;
+    localFile: LocalFileForStagedUpload;
+}) => Promise<void>;
+export declare const stagedUploadLocalFiles: (ctx: CommandContext, localFiles: LocalFileForStagedUpload[]) => Promise<StagedUploadTarget[] | undefined>;

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

@@ -0,0 +1,227 @@
+"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 stagedUploads_exports = {};
+__export(stagedUploads_exports, {
+  buildLocalFilesForStagedUpload: () => buildLocalFilesForStagedUpload,
+  stagedUploadLocalFiles: () => stagedUploadLocalFiles,
+  stagedUploadsCreate: () => stagedUploadsCreate,
+  uploadToStagedTarget: () => uploadToStagedTarget
+});
+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 mimeTypeFromFilename = (filename) => {
+  const mimeType = (0, import_mime_types.lookup)(filename);
+  if (typeof mimeType === "string") return mimeType;
+  return void 0;
+};
+const inferStagedUploadResource = ({
+  filename,
+  mimeType
+}) => {
+  if (mimeType.startsWith("image/")) return "IMAGE";
+  if (mimeType.startsWith("video/")) return "VIDEO";
+  const ext = import_node_path.default.extname(filename).toLowerCase();
+  if (mimeType.startsWith("model/") || ext === ".glb" || ext === ".gltf" || ext === ".usdz") {
+    return "MODEL_3D";
+  }
+  return "FILE";
+};
+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,
+  mimeType,
+  resource
+}) => {
+  if (filePaths.length === 0) return [];
+  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 resolvedMimeType = await resolveMimeType({ filePath, filename, forcedMimeType: mimeType });
+    const inferredResource = inferStagedUploadResource({ filename, mimeType: resolvedMimeType });
+    return {
+      filePath,
+      filename,
+      mimeType: resolvedMimeType,
+      resource: resource ?? inferredResource,
+      fileSize: stats.size
+    };
+  }));
+};
+const stagedUploadsCreate = async (ctx, localFiles) => {
+  const input = localFiles.map((f) => ({
+    filename: f.filename,
+    mimeType: f.mimeType,
+    resource: f.resource,
+    fileSize: String(f.fileSize),
+    httpMethod: "POST"
+  }));
+  if (ctx.dryRun) {
+    await (0, import_router.runMutation)(ctx, {
+      stagedUploadsCreate: {
+        __args: { input },
+        stagedTargets: {
+          url: true,
+          resourceUrl: true,
+          parameters: { name: true, value: true }
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    return localFiles.map((f, i) => ({
+      url: `https://example.invalid/staged-uploads/${i}`,
+      resourceUrl: `https://example.invalid/staged-resources/${encodeURIComponent(f.filename)}`,
+      parameters: []
+    }));
+  }
+  const result = await (0, import_router.runMutation)(ctx, {
+    stagedUploadsCreate: {
+      __args: { input },
+      stagedTargets: {
+        url: true,
+        resourceUrl: true,
+        parameters: { name: true, value: true }
+      },
+      userErrors: { field: true, message: true }
+    }
+  });
+  if (result === void 0) return void 0;
+  (0, import_userErrors.maybeFailOnUserErrors)({
+    payload: result.stagedUploadsCreate,
+    failOnUserErrors: ctx.failOnUserErrors
+  });
+  const targets = result.stagedUploadsCreate?.stagedTargets ?? [];
+  if (!Array.isArray(targets) || targets.length !== localFiles.length) {
+    throw new import_errors.CliError(
+      `Expected ${localFiles.length} stagedTargets, got ${Array.isArray(targets) ? targets.length : "non-array"}`,
+      2
+    );
+  }
+  return targets.map((t) => ({
+    url: String(t.url ?? ""),
+    resourceUrl: String(t.resourceUrl ?? ""),
+    parameters: (t.parameters ?? []).map((p) => ({ name: p.name, value: p.value }))
+  }));
+};
+const uploadToStagedTarget = async ({
+  target,
+  localFile
+}) => {
+  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 {
+    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}: curl exited with code ${code}${details ? `
+${details}` : ""}`,
+    2
+  );
+};
+const stagedUploadLocalFiles = async (ctx, localFiles) => {
+  const targets = await stagedUploadsCreate(ctx, localFiles);
+  if (targets === void 0) return void 0;
+  if (ctx.dryRun) return targets;
+  for (let i = 0; i < targets.length; i++) {
+    const target = targets[i];
+    const localFile = localFiles[i];
+    await uploadToStagedTarget({ target, localFile });
+  }
+  return targets;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildLocalFilesForStagedUpload,
+  stagedUploadLocalFiles,
+  stagedUploadsCreate,
+  uploadToStagedTarget
+});
+//# sourceMappingURL=stagedUploads.js.map

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>;
+}>;