shop-cli 0.1.1

package/dist/cli/verbs/events.js

@@ -0,0 +1,182 @@
+"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 events_exports = {};
+__export(events_exports, {
+  runEvents: () => runEvents
+});
+module.exports = __toCommonJS(events_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_shared = require("./_shared");
+const eventSummarySelection = {
+  id: true,
+  action: true,
+  message: true,
+  createdAt: true
+};
+const eventFullSelection = {
+  ...eventSummarySelection,
+  appTitle: true,
+  attributeToApp: true,
+  attributeToUser: true,
+  criticalAlert: true,
+  __typename: true
+};
+const getEventSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return eventFullSelection;
+  if (view === "raw") return {};
+  return eventSummarySelection;
+};
+const deletionEventSelection = {
+  subjectId: true,
+  subjectType: true,
+  occurredAt: true
+};
+const runEvents = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop events <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|list|count|deletion-events",
+        "",
+        "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 === "deletion-events") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "subject-types": { type: "string" } }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const query = args.query;
+    const subjectTypesRaw = args["subject-types"];
+    const subjectTypes = subjectTypesRaw ? (0, import_shared.parseCsv)(subjectTypesRaw, "--subject-types") : void 0;
+    const result = await (0, import_router.runQuery)(ctx, {
+      deletionEvents: {
+        __args: {
+          first,
+          after,
+          reverse,
+          ...sortKey ? { sortKey } : {},
+          ...query ? { query } : {},
+          ...subjectTypes ? { subjectTypes } : {}
+        },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: deletionEventSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.deletionEvents,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop events deletion-events",
+        first,
+        query: typeof query === "string" ? query : void 0,
+        sort: typeof sortKey === "string" ? sortKey : void 0,
+        reverse: reverse === true,
+        extraFlags: [...subjectTypesRaw ? [{ flag: "--subject-types", value: subjectTypesRaw }] : []]
+      }
+    });
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Event");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "events",
+      view: ctx.view,
+      baseSelection: getEventSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { event: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.event, 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: "events",
+      view: ctx.view,
+      baseSelection: getEventSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      events: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.events,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("events", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const query = args.query;
+    const result = await (0, import_router.runQuery)(ctx, { eventsCount: { __args: { query }, count: true, precision: true } });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.eventsCount?.count ?? "");
+    (0, import_output.printJson)(result.eventsCount, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for events: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runEvents
+});
+//# sourceMappingURL=events.js.map

package/dist/cli/verbs/file-saved-searches.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runFileSavedSearches: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;

package/dist/cli/verbs/file-saved-searches.js

@@ -0,0 +1,83 @@
+"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 file_saved_searches_exports = {};
+__export(file_saved_searches_exports, {
+  runFileSavedSearches: () => runFileSavedSearches
+});
+module.exports = __toCommonJS(file_saved_searches_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_shared = require("./_shared");
+const savedSearchSelection = {
+  id: true,
+  name: true,
+  query: true,
+  resourceType: true,
+  searchTerms: true
+};
+const runFileSavedSearches = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop file-saved-searches <verb> [flags]",
+        "",
+        "Verbs:",
+        "  list",
+        "",
+        "Common output flags:",
+        "  --format json|jsonl|table|markdown|raw",
+        "  --quiet               (IDs only when possible)"
+      ].join("\n")
+    );
+    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 reverse = args.reverse;
+    const result = await (0, import_router.runQuery)(ctx, {
+      fileSavedSearches: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: savedSearchSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.fileSavedSearches,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("file-saved-searches", { first, reverse })
+    });
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for file-saved-searches: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runFileSavedSearches
+});
+//# sourceMappingURL=file-saved-searches.js.map

package/dist/cli/verbs/files.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runFiles: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;

package/dist/cli/verbs/files.js

@@ -0,0 +1,329 @@
+"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 files_exports = {};
+__export(files_exports, {
+  runFiles: () => runFiles
+});
+module.exports = __toCommonJS(files_exports);
+var import_errors = require("../errors");
+var import_router = require("../router");
+var import_userErrors = require("../userErrors");
+var import_stagedUploads = require("../workflows/files/stagedUploads");
+var import_stdinFile = require("../workflows/files/stdinFile");
+var import_urlDownloads = require("../workflows/files/urlDownloads");
+var import_waitForReady = require("../workflows/files/waitForReady");
+var import_output = require("../output");
+var import_command = require("../command");
+var import_shared = require("./_shared");
+const fileSelection = {
+  id: true,
+  alt: true,
+  fileStatus: true,
+  createdAt: true,
+  updatedAt: true,
+  preview: { status: true, image: { url: true } },
+  fileErrors: { code: true, message: true, details: true }
+};
+const FILES_MEDIA_TYPES = /* @__PURE__ */ new Set(["FILE", "IMAGE", "VIDEO", "MODEL_3D"]);
+const normalizeFilesMediaType = (raw, flag) => {
+  const v = raw.trim().toUpperCase();
+  if (!v) throw new import_errors.CliError(`Invalid ${flag} value`, 2);
+  if (FILES_MEDIA_TYPES.has(v)) return v;
+  throw new import_errors.CliError(`${flag} must be FILE|IMAGE|VIDEO|MODEL_3D`, 2);
+};
+const parsePositiveIntFlag = ({
+  value,
+  flag
+}) => {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new import_errors.CliError(`Invalid ${flag} value`, 2);
+  const trimmed = value.trim();
+  if (!trimmed) throw new import_errors.CliError(`Invalid ${flag} value`, 2);
+  const n = Number(trimmed);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+    throw new import_errors.CliError(`${flag} must be a positive integer`, 2);
+  }
+  return n;
+};
+const runFiles = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    const command = (0, import_command.resolveCliCommand)();
+    console.log(
+      [
+        "Usage:",
+        `  ${command} files <verb> [flags]`,
+        "",
+        "Verbs:",
+        "  get|list|upload|update|delete|acknowledge-update-failed",
+        "",
+        "Upload flags:",
+        "  --file <path>                 (repeatable)",
+        "  --file -                      (read from stdin; requires --filename)",
+        "  --url <url>                   (repeatable)",
+        "  --filename <name>             (only with exactly 1 --url, or with --file -)",
+        "  --mime-type <mime>            (override MIME detection)",
+        "  --media-type FILE|IMAGE|VIDEO|MODEL_3D",
+        "  (aliases: --resource, --content-type)",
+        "  --alt <text>",
+        "  --wait",
+        "  --poll-interval-ms <n>        (default: 1000)",
+        "  --timeout-ms <n>              (default: 600000)",
+        "",
+        "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 === "acknowledge-update-failed") {
+    const args2 = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const ids = args2.ids !== void 0 ? (0, import_shared.parseIds)(args2.ids, "File") : args2.id ? [(0, import_shared.requireId)(args2.id, "File")] : [];
+    if (ids.length === 0) throw new import_errors.CliError("Missing --id or --ids", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileAcknowledgeUpdateFailed: {
+        __args: { fileIds: ids },
+        files: fileSelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileAcknowledgeUpdateFailed, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      (0, import_output.printIds)((result.fileAcknowledgeUpdateFailed?.files ?? []).map((f) => f?.id));
+      return;
+    }
+    (0, import_output.printJson)(result.fileAcknowledgeUpdateFailed, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "get") {
+    const args2 = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const raw = args2.id;
+    if (!raw) throw new import_errors.CliError("Missing --id", 2);
+    const trimmed = raw.trim();
+    if (!trimmed) throw new import_errors.CliError("Missing --id", 2);
+    const query = trimmed.startsWith("gid://") ? `ids:${trimmed}` : /^\d+$/.test(trimmed) ? `id:${trimmed}` : (() => {
+      throw new import_errors.CliError("--id must be a numeric ID or full gid://shopify/... GID", 2);
+    })();
+    const result = await (0, import_router.runQuery)(ctx, {
+      files: { __args: { first: 1, query }, nodes: fileSelection }
+    });
+    if (result === void 0) return;
+    const node = (result.files?.nodes ?? [])[0];
+    (0, import_output.printNode)({ node, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args2 = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args2.first);
+    const after = args2.after;
+    const query = args2.query;
+    const reverse = args2.reverse;
+    const sortKey = args2.sort;
+    const result = await (0, import_router.runQuery)(ctx, {
+      files: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: fileSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.files,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("files", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "delete") {
+    const args2 = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    if (!args2.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const ids = args2.ids !== void 0 ? (0, import_shared.parseIds)(args2.ids, "File") : args2.id ? [(0, import_shared.requireId)(args2.id, "File")] : [];
+    if (ids.length === 0) throw new import_errors.CliError("Missing --id or --ids", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileDelete: {
+        __args: { fileIds: ids },
+        deletedFileIds: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      (0, import_output.printIds)((result.fileDelete?.deletedFileIds ?? []).map((id) => id));
+      return;
+    }
+    (0, import_output.printJson)(result.fileDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args2 = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        alt: { type: "string" }
+      }
+    });
+    const id = (0, import_shared.requireId)(args2.id, "File");
+    const alt = args2.alt;
+    if (alt === void 0) throw new import_errors.CliError("Missing --alt", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileUpdate: {
+        __args: { files: [{ id, alt }] },
+        files: fileSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log((result.fileUpdate?.files ?? [])[0]?.id ?? "");
+    (0, import_output.printJson)(result.fileUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb !== "upload") {
+    throw new import_errors.CliError(`Unknown verb for files: ${verb}`, 2);
+  }
+  const args = (0, import_router.parseStandardArgs)({
+    argv,
+    extraOptions: {
+      file: { type: "string", multiple: true },
+      url: { type: "string", multiple: true },
+      filename: { type: "string" },
+      alt: { type: "string" },
+      "mime-type": { type: "string" },
+      "media-type": { type: "string" },
+      resource: { type: "string" },
+      "content-type": { type: "string" },
+      wait: { type: "boolean" },
+      "poll-interval-ms": { type: "string" },
+      "timeout-ms": { type: "string" }
+    }
+  });
+  const filePaths = args.file ?? [];
+  const urls = args.url ?? [];
+  const filenameOverride = args.filename;
+  const usesStdin = filePaths.includes("-");
+  if (usesStdin && filePaths.length !== 1) {
+    throw new import_errors.CliError("When using --file -, provide exactly one --file", 2);
+  }
+  if (filenameOverride && urls.length === 0 && !usesStdin) {
+    throw new import_errors.CliError("--filename is only valid with --url or --file -", 2);
+  }
+  if (filePaths.length > 0 && urls.length > 0) {
+    throw new import_errors.CliError("Do not mix --file and --url in a single invocation", 2);
+  }
+  if (filePaths.length === 0 && urls.length === 0) {
+    throw new import_errors.CliError("Missing --file (repeatable) or --url (repeatable)", 2);
+  }
+  const mediaTypeRaw = args["media-type"];
+  const resourceAliasRaw = args.resource;
+  const contentTypeAliasRaw = args["content-type"];
+  const parsedMediaType = mediaTypeRaw ? normalizeFilesMediaType(mediaTypeRaw, "--media-type") : void 0;
+  const parsedResourceAlias = resourceAliasRaw ? normalizeFilesMediaType(resourceAliasRaw, "--resource") : void 0;
+  const parsedContentTypeAlias = contentTypeAliasRaw ? normalizeFilesMediaType(contentTypeAliasRaw, "--content-type") : void 0;
+  const distinct = new Set([parsedMediaType, parsedResourceAlias, parsedContentTypeAlias].filter(Boolean));
+  if (distinct.size > 1) {
+    throw new import_errors.CliError("Do not pass conflicting values for --media-type/--resource/--content-type", 2);
+  }
+  const mediaType = parsedMediaType ?? parsedResourceAlias ?? parsedContentTypeAlias;
+  const wait = args.wait === true;
+  const pollIntervalMs = parsePositiveIntFlag({
+    value: args["poll-interval-ms"],
+    flag: "--poll-interval-ms"
+  }) ?? 1e3;
+  const timeoutMs = parsePositiveIntFlag({
+    value: args["timeout-ms"],
+    flag: "--timeout-ms"
+  }) ?? 10 * 60 * 1e3;
+  let cleanupDownloads;
+  let cleanupStdin;
+  let effectiveFilePaths = filePaths;
+  try {
+    if (urls.length > 0) {
+      const downloaded = await (0, import_urlDownloads.downloadUrlsToTempDir)({ urls, filenameOverride });
+      cleanupDownloads = downloaded.cleanup;
+      effectiveFilePaths = downloaded.files.map((f) => f.filePath);
+    }
+    if (usesStdin) {
+      const stdinFile = await (0, import_stdinFile.writeStdinToTempFile)({ filename: filenameOverride ?? "" });
+      cleanupStdin = stdinFile.cleanup;
+      effectiveFilePaths = [stdinFile.filePath];
+    }
+    const localFiles = await (0, import_stagedUploads.buildLocalFilesForStagedUpload)({
+      filePaths: effectiveFilePaths,
+      mimeType: args["mime-type"],
+      resource: mediaType
+    });
+    const targets = await (0, import_stagedUploads.stagedUploadLocalFiles)(ctx, localFiles);
+    if (targets === void 0) return;
+    const alt = args.alt;
+    const files = targets.map((t, i) => {
+      const local = localFiles[i];
+      if (!t.resourceUrl) throw new import_errors.CliError(`Missing staged target resourceUrl for ${local.filename}`, 2);
+      return {
+        originalSource: t.resourceUrl,
+        filename: local.filename,
+        // Keep fileCreate contentType consistent with staged upload resource.
+        contentType: mediaType ?? local.resource,
+        ...alt ? { alt } : {}
+      };
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileCreate: {
+        __args: { files },
+        files: fileSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileCreate, failOnUserErrors: ctx.failOnUserErrors });
+    const createdIds = (result.fileCreate?.files ?? []).map((f) => f?.id).filter((id) => typeof id === "string" && id.trim() !== "");
+    if (ctx.quiet) {
+      (0, import_output.printIds)(createdIds);
+    } else {
+      (0, import_output.printJson)(result.fileCreate);
+    }
+    if (!wait) return;
+    const final = await (0, import_waitForReady.waitForFilesReadyOrFailed)({
+      ctx,
+      ids: createdIds,
+      pollIntervalMs,
+      timeoutMs
+    });
+    if (!ctx.quiet) {
+      (0, import_output.printJson)(final);
+    }
+    if (final.failedIds.length > 0) {
+      throw new import_errors.CliError(`One or more files failed processing: ${final.failedIds.join(", ")}`, 2);
+    }
+  } finally {
+    if (cleanupStdin) await cleanupStdin();
+    if (cleanupDownloads) await cleanupDownloads();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runFiles
+});
+//# sourceMappingURL=files.js.map

package/dist/cli/verbs/finance.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runFinance: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;