@mediaruntime/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,895 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { constants, realpathSync } from "fs";
+import {
+  access,
+  link,
+  rename,
+  rm
+} from "fs/promises";
+import { createWriteStream } from "fs";
+import { basename, dirname, resolve } from "path";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+import { fileURLToPath } from "url";
+import {
+  JobWaitTimeoutError,
+  MediaRuntime,
+  MediaRuntimeApiError,
+  MediaRuntimeConnectionError
+} from "@mediaruntime/node";
+
+// src/errors.ts
+var CliError = class extends Error {
+  code;
+  exitCode;
+  constructor(code, message, exitCode, options) {
+    super(message, options);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = exitCode;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var UsageError = class extends CliError {
+  constructor(message, options) {
+    super("usage_error", message, 2, options);
+    this.name = "UsageError";
+  }
+};
+var TriggerDeliveryError = class extends CliError {
+  constructor(message, options) {
+    super("trigger_delivery_error", message, 8, options);
+    this.name = "TriggerDeliveryError";
+  }
+};
+var BundleDownloadError = class extends CliError {
+  constructor(message, options) {
+    super("bundle_download_error", message, 9, options);
+    this.name = "BundleDownloadError";
+  }
+};
+
+// src/commands/jobs.ts
+var UNSUCCESSFUL_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["FAILED", "REJECTED", "PARTIAL"]);
+function optionValue(args, index, option) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new UsageError(`${option} requires a value`);
+  return value;
+}
+function detailsProjection(job) {
+  return {
+    id: job.id,
+    status: job.status,
+    tier: job.tier,
+    usage: job.usage,
+    billing: job.billing,
+    bundle: {
+      available: job.bundle.available,
+      expiresAt: job.bundle.expiresAt,
+      sizeBytes: job.bundle.sizeBytes,
+      sha256: job.bundle.sha256,
+      retentionDays: job.bundle.retentionDays
+    },
+    media: job.media,
+    metadata: job.metadata,
+    error: job.error,
+    createdAt: job.createdAt,
+    updatedAt: job.updatedAt,
+    startedAt: job.startedAt,
+    completedAt: job.completedAt
+  };
+}
+function humanDetails(job) {
+  const lines = [
+    `Job: ${job.id}`,
+    `Status: ${job.status}`,
+    `Tier: ${job.tier.billed ?? job.tier.effective ?? job.tier.requested ?? "-"}`,
+    `Bundle: ${job.bundle.available ? "available" : "unavailable"}`
+  ];
+  if (job.bundle.sizeBytes !== null) lines.push(`Bundle size: ${job.bundle.sizeBytes} bytes`);
+  if (job.error) lines.push(`Error: ${job.error}`);
+  return `${lines.join("\n")}
+`;
+}
+function cell(value) {
+  if (value === null || value === void 0 || value === "") return "-";
+  return String(value);
+}
+function humanList(page) {
+  const rows = page.jobs.map((job) => [
+    job.id,
+    job.status,
+    cell(job.tierBilled),
+    cell(job.unitsTotal),
+    job.bundleAvailable ? "yes" : "no",
+    cell(job.updatedAt)
+  ]);
+  const headings = ["ID", "STATUS", "TIER", "UNITS", "BUNDLE", "UPDATED"];
+  const widths = headings.map(
+    (heading, index) => Math.max(heading.length, ...rows.map((row) => row[index]?.length ?? 0))
+  );
+  const render = (row) => row.map((value, index) => value.padEnd(widths[index] ?? value.length)).join("  ").trimEnd();
+  const lines = [render(headings), render(widths.map((width) => "-".repeat(width))), ...rows.map(render)];
+  if (page.nextCursor) lines.push(`Next cursor: ${page.nextCursor}`);
+  return `${lines.join("\n")}
+`;
+}
+async function listCommand(args, dependencies) {
+  let status;
+  let limit;
+  let cursor;
+  let json = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--status") {
+      status = optionValue(args, index, argument).toUpperCase();
+      index += 1;
+    } else if (argument === "--limit") {
+      const value = Number(optionValue(args, index, argument));
+      if (!Number.isSafeInteger(value) || value < 1 || value > 100) {
+        throw new UsageError("--limit must be an integer between 1 and 100");
+      }
+      limit = value;
+      index += 1;
+    } else if (argument === "--cursor") {
+      cursor = optionValue(args, index, argument);
+      index += 1;
+    } else if (argument === "--json") {
+      json = true;
+    } else {
+      throw new UsageError(`Unknown jobs list option: ${argument}`);
+    }
+  }
+  const params = {
+    ...status === void 0 ? {} : { status },
+    ...limit === void 0 ? {} : { limit },
+    ...cursor === void 0 ? {} : { cursor }
+  };
+  const page = await dependencies.jobs.list(params);
+  dependencies.writeStdout(json ? `${JSON.stringify(page)}
+` : humanList(page));
+  return 0;
+}
+async function getCommand(args, dependencies) {
+  let jobId;
+  let download;
+  let force = false;
+  let json = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--download") {
+      download = optionValue(args, index, argument);
+      index += 1;
+    } else if (argument === "--force") {
+      force = true;
+    } else if (argument === "--json") {
+      json = true;
+    } else if (argument?.startsWith("-")) {
+      throw new UsageError(`Unknown jobs get option: ${argument}`);
+    } else if (!jobId) {
+      jobId = argument;
+    } else {
+      throw new UsageError("jobs get accepts exactly one job ID");
+    }
+  }
+  if (!jobId) throw new UsageError("Usage: mediaruntime jobs get <job_id>");
+  if (force && !download) throw new UsageError("--force requires --download");
+  const job = await dependencies.jobs.get(jobId);
+  if (!json) dependencies.writeStdout(humanDetails(job));
+  if (UNSUCCESSFUL_TERMINAL_STATUSES.has(String(job.status).toUpperCase())) {
+    if (json) dependencies.writeStdout(`${JSON.stringify(detailsProjection(job))}
+`);
+    return 6;
+  }
+  if (download) {
+    if (String(job.status).toUpperCase() !== "COMPLETED" || !job.bundle.available || !job.bundle.downloadUrl) {
+      throw new BundleDownloadError("Bundle download requires a COMPLETED job with an available canonical bundle");
+    }
+    try {
+      await dependencies.downloadBundle(job.bundle.downloadUrl, download, {
+        force,
+        expectedSizeBytes: job.bundle.sizeBytes,
+        expectedSha256: job.bundle.sha256
+      });
+    } catch (error) {
+      if (error instanceof BundleDownloadError) throw error;
+      throw new BundleDownloadError(`Could not download bundle to ${download}`, { cause: error });
+    }
+    if (!json) dependencies.writeStdout(`Downloaded bundle to ${download}
+`);
+  }
+  if (json) dependencies.writeStdout(`${JSON.stringify(detailsProjection(job))}
+`);
+  return 0;
+}
+async function runJobsCommand(args, dependencies) {
+  const subcommand = args[0];
+  if (subcommand === "list") return listCommand(args.slice(1), dependencies);
+  if (subcommand === "get") return getCommand(args.slice(1), dependencies);
+  throw new UsageError("Usage: mediaruntime jobs <list|get>");
+}
+
+// src/commands/run.ts
+var UNSUCCESSFUL_TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["FAILED", "REJECTED", "PARTIAL"]);
+var OUTPUT_ALIASES = /* @__PURE__ */ new Set([
+  "video.web",
+  "video.streaming",
+  "video.social",
+  "audio.web",
+  "audio.transcription",
+  "image.web"
+]);
+function optionValue2(args, index, option) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new UsageError(`${option} requires a value`);
+  return value;
+}
+function parseMetadata(value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new UsageError("--metadata must be a valid JSON object");
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new UsageError("--metadata must be a JSON object");
+  }
+  return parsed;
+}
+function parseRunOptions(args) {
+  let source;
+  const outputs = [];
+  let metadata;
+  let idempotencyKey;
+  let wait = false;
+  let timeoutMs;
+  let download;
+  let force = false;
+  let json = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--output" || argument === "-o") {
+      outputs.push(optionValue2(args, index, argument));
+      index += 1;
+    } else if (argument === "--metadata") {
+      metadata = parseMetadata(optionValue2(args, index, argument));
+      index += 1;
+    } else if (argument === "--idempotency-key") {
+      idempotencyKey = optionValue2(args, index, argument);
+      index += 1;
+    } else if (argument === "--wait") {
+      wait = true;
+    } else if (argument === "--timeout-ms") {
+      const value = Number(optionValue2(args, index, argument));
+      if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new UsageError("--timeout-ms must be a positive integer");
+      }
+      timeoutMs = value;
+      index += 1;
+    } else if (argument === "--download") {
+      download = optionValue2(args, index, argument);
+      wait = true;
+      index += 1;
+    } else if (argument === "--force") {
+      force = true;
+    } else if (argument === "--json") {
+      json = true;
+    } else if (argument?.startsWith("-")) {
+      throw new UsageError(`Unknown run option: ${argument}`);
+    } else if (source === void 0) {
+      source = argument;
+    } else {
+      throw new UsageError("run accepts exactly one source");
+    }
+  }
+  if (!source) throw new UsageError("Usage: mediaruntime run <source> --output <alias> [--wait]");
+  if (outputs.length === 0) throw new UsageError("run requires at least one --output");
+  const unsupported = outputs.find((output) => !OUTPUT_ALIASES.has(output));
+  if (unsupported) throw new UsageError(`Unsupported output alias: ${unsupported}`);
+  if (force && !download) throw new UsageError("--force requires --download");
+  if (timeoutMs !== void 0 && !wait) throw new UsageError("--timeout-ms requires --wait or --download");
+  return {
+    source,
+    outputs,
+    ...metadata === void 0 ? {} : { metadata },
+    ...idempotencyKey === void 0 ? {} : { idempotencyKey },
+    wait,
+    ...timeoutMs === void 0 ? {} : { timeoutMs },
+    ...download === void 0 ? {} : { download },
+    force,
+    json
+  };
+}
+function receiptProjection(job) {
+  return {
+    id: job.id,
+    status: job.status,
+    tier: job.tier,
+    requiredTier: job.requiredTier,
+    outputs: job.outputs,
+    message: job.message
+  };
+}
+function detailsProjection2(job) {
+  return {
+    id: job.id,
+    status: job.status,
+    tier: job.tier,
+    usage: job.usage,
+    billing: job.billing,
+    bundle: {
+      available: job.bundle.available,
+      expiresAt: job.bundle.expiresAt,
+      sizeBytes: job.bundle.sizeBytes,
+      sha256: job.bundle.sha256,
+      retentionDays: job.bundle.retentionDays
+    },
+    media: job.media,
+    metadata: job.metadata,
+    error: job.error,
+    createdAt: job.createdAt,
+    updatedAt: job.updatedAt,
+    startedAt: job.startedAt,
+    completedAt: job.completedAt
+  };
+}
+function writeHumanReceipt(job, write) {
+  write(`Job: ${job.id}
+Status: ${job.status}
+Tier: ${job.tier || "-"}
+`);
+}
+function writeHumanDetails(job, write) {
+  const error = job.error ? `
+Error: ${job.error}` : "";
+  write(
+    `Job: ${job.id}
+Status: ${job.status}
+Bundle: ${job.bundle.available ? "available" : "unavailable"}${error}
+`
+  );
+}
+async function runCommand(args, dependencies) {
+  const options = parseRunOptions(args);
+  const params = {
+    source: options.source,
+    outputs: options.outputs,
+    ...options.metadata === void 0 ? {} : { metadata: options.metadata },
+    ...options.idempotencyKey === void 0 ? {} : { idempotencyKey: options.idempotencyKey }
+  };
+  const submitted = await dependencies.jobs.create(params);
+  if (!options.wait) {
+    if (options.json) dependencies.writeStdout(`${JSON.stringify(receiptProjection(submitted))}
+`);
+    else writeHumanReceipt(submitted, dependencies.writeStdout);
+    return UNSUCCESSFUL_TERMINAL_STATUSES2.has(String(submitted.status).toUpperCase()) ? 6 : 0;
+  }
+  const details = await submitted.wait(
+    options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+  );
+  if (!options.json) writeHumanDetails(details, dependencies.writeStdout);
+  if (String(details.status).toUpperCase() !== "COMPLETED") {
+    if (options.json) dependencies.writeStdout(`${JSON.stringify(detailsProjection2(details))}
+`);
+    return 6;
+  }
+  if (options.download) {
+    const url = details.bundle.downloadUrl;
+    if (!details.bundle.available || !url) {
+      throw new BundleDownloadError("Completed job does not have an available canonical bundle");
+    }
+    try {
+      await dependencies.downloadBundle(url, options.download, {
+        force: options.force,
+        expectedSizeBytes: details.bundle.sizeBytes,
+        expectedSha256: details.bundle.sha256
+      });
+    } catch (error) {
+      if (error instanceof BundleDownloadError) throw error;
+      throw new BundleDownloadError(`Could not download bundle to ${options.download}`, { cause: error });
+    }
+    if (!options.json) dependencies.writeStdout(`Downloaded bundle to ${options.download}
+`);
+  }
+  if (options.json) dependencies.writeStdout(`${JSON.stringify(detailsProjection2(details))}
+`);
+  return 0;
+}
+
+// src/commands/trigger.ts
+import { randomBytes, randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+
+// src/trigger/destination.ts
+function isLoopbackDestination(value) {
+  let hostname = value.hostname.toLowerCase();
+  if (hostname.endsWith(".")) hostname = hostname.slice(0, -1);
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    hostname = hostname.slice(1, -1);
+  }
+  if (hostname === "localhost" || hostname === "::1" || hostname === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  const octets = hostname.split(".");
+  if (octets.length !== 4 || octets.some((part) => !/^\d{1,3}$/.test(part))) return false;
+  const numbers = octets.map(Number);
+  return numbers[0] === 127 && numbers.every((part) => part >= 0 && part <= 255);
+}
+function parseLocalDestination(raw) {
+  let destination;
+  try {
+    destination = new URL(raw);
+  } catch {
+    throw new UsageError("--to must be an absolute local HTTP(S) URL");
+  }
+  if (destination.protocol !== "http:" && destination.protocol !== "https:") {
+    throw new UsageError("--to must use http:// or https://");
+  }
+  if (destination.username || destination.password) {
+    throw new UsageError("--to must not contain URL credentials");
+  }
+  if (!isLoopbackDestination(destination)) {
+    throw new UsageError(
+      "trigger only sends to loopback destinations (localhost, 127.0.0.0/8, or ::1)"
+    );
+  }
+  return destination;
+}
+
+// src/trigger/event.ts
+var SUPPORTED_TRIGGER_EVENTS = [
+  "job.completed",
+  "job.failed",
+  "job.rejected"
+];
+function isTriggerEventType(value) {
+  return SUPPORTED_TRIGGER_EVENTS.includes(value);
+}
+function createSyntheticTerminalEvent(type, options) {
+  const status = type.slice("job.".length).toUpperCase();
+  const occurredAt = new Date(options.timestamp * 1e3).toISOString();
+  const base = {
+    event_id: options.eventId,
+    job_id: options.jobId,
+    account_id: options.accountId,
+    status
+  };
+  if (type === "job.completed") {
+    const expiresAt = new Date((options.timestamp + 7 * 24 * 60 * 60) * 1e3).toISOString();
+    return {
+      ...base,
+      completedAt: occurredAt,
+      delivery: {
+        mode: "PULL",
+        retentionDays: 7,
+        expiresAt,
+        bundle: {
+          type: "zip",
+          filename: `${options.jobId}_outputs.zip`,
+          size_bytes: 0,
+          sha256: "0".repeat(64),
+          download: {
+            url: `http://127.0.0.1/__mediaruntime_synthetic__/${encodeURIComponent(options.jobId)}.zip`,
+            expiresAt
+          }
+        },
+        layout: "bundle_relative_v1",
+        deliverables: [],
+        manifests: {}
+      },
+      billing: { status: "PAID" },
+      usage: { units_total: 0 },
+      meta: { synthetic: true, request_metadata: {} }
+    };
+  }
+  const failed = type === "job.failed";
+  return {
+    ...base,
+    [failed ? "failedAt" : "rejectedAt"]: occurredAt,
+    delivery: { mode: "NONE" },
+    billing: { status: "RELEASED" },
+    error: {
+      code: failed ? "SYNTHETIC_ENGINE_FAILED" : "SYNTHETIC_REJECTED",
+      message: `Synthetic ${type} event from the MediaRuntime CLI`
+    },
+    meta: { synthetic: true, request_metadata: {} }
+  };
+}
+
+// src/trigger/signature.ts
+import { createHmac } from "crypto";
+var WEBHOOK_HEADERS = {
+  id: "X-Transcoder-Id",
+  timestamp: "X-Transcoder-Timestamp",
+  signature: "X-Transcoder-Signature"
+};
+function signSyntheticWebhook(payload, options) {
+  if (!options.eventId.trim()) throw new Error("Webhook event ID must not be empty");
+  if (!Number.isInteger(options.timestamp) || options.timestamp < 0) {
+    throw new Error("Webhook timestamp must be a non-negative integer");
+  }
+  if (!options.secret) throw new Error("Webhook secret must not be empty");
+  const body = JSON.stringify(payload);
+  const bodyBytes = Buffer.from(body, "utf8");
+  const prefix = Buffer.from(`${options.timestamp}.${options.eventId}.`, "utf8");
+  const digest = createHmac("sha256", options.secret).update(prefix).update(bodyBytes).digest("hex");
+  return {
+    body,
+    headers: {
+      "Content-Type": "application/json",
+      [WEBHOOK_HEADERS.id]: options.eventId,
+      [WEBHOOK_HEADERS.timestamp]: String(options.timestamp),
+      [WEBHOOK_HEADERS.signature]: `t=${options.timestamp},v1=${digest}`
+    }
+  };
+}
+
+// src/commands/trigger.ts
+function requireOptionValue(args, index, option) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new UsageError(`${option} requires a value`);
+  return value;
+}
+function parseTriggerArguments(args) {
+  const typeValue = args[0];
+  if (!typeValue || typeValue.startsWith("--")) {
+    throw new UsageError(
+      `trigger requires an event type: ${SUPPORTED_TRIGGER_EVENTS.join(", ")}`
+    );
+  }
+  if (!isTriggerEventType(typeValue)) {
+    throw new UsageError(
+      `Unsupported trigger event ${JSON.stringify(typeValue)}; expected ${SUPPORTED_TRIGGER_EVENTS.join(", ")}`
+    );
+  }
+  let to;
+  let secretFile;
+  let generateSecret = false;
+  let jobId;
+  let accountId;
+  let json = false;
+  for (let index = 1; index < args.length; index += 1) {
+    const option = args[index];
+    if (!option) continue;
+    if (option === "--generate-secret") {
+      generateSecret = true;
+      continue;
+    }
+    if (option === "--json") {
+      json = true;
+      continue;
+    }
+    if (["--to", "--secret-file", "--job-id", "--account-id"].includes(option)) {
+      const value = requireOptionValue(args, index, option);
+      index += 1;
+      if (option === "--to") to = value;
+      else if (option === "--secret-file") secretFile = value;
+      else if (option === "--job-id") jobId = value;
+      else accountId = value;
+      continue;
+    }
+    throw new UsageError(`Unknown trigger option: ${option}`);
+  }
+  if (!to) throw new UsageError("trigger requires an explicit --to local URL");
+  if (generateSecret && secretFile) {
+    throw new UsageError("--generate-secret and --secret-file are mutually exclusive");
+  }
+  if (generateSecret && json) {
+    throw new UsageError("--generate-secret and --json are mutually exclusive");
+  }
+  if (jobId !== void 0 && !jobId.trim()) throw new UsageError("--job-id must not be empty");
+  if (accountId !== void 0 && !accountId.trim()) {
+    throw new UsageError("--account-id must not be empty");
+  }
+  return {
+    type: typeValue,
+    destination: parseLocalDestination(to),
+    ...secretFile === void 0 ? {} : { secretFile },
+    generateSecret,
+    ...jobId === void 0 ? {} : { jobId: jobId.trim() },
+    ...accountId === void 0 ? {} : { accountId: accountId.trim() },
+    json
+  };
+}
+async function resolveSecret(args, dependencies) {
+  if (args.generateSecret) {
+    const generated = Buffer.from(dependencies.randomBytes(32)).toString("base64url");
+    dependencies.writeStdout(
+      `Generated webhook secret (configure the local receiver with this value): ${generated}
+`
+    );
+    return generated;
+  }
+  let secret;
+  if (args.secretFile) {
+    try {
+      secret = await dependencies.readFile(args.secretFile, "utf8");
+    } catch (error) {
+      throw new UsageError(`Could not read webhook secret file: ${args.secretFile}`, { cause: error });
+    }
+  } else {
+    secret = dependencies.env.MEDIARUNTIME_WEBHOOK_SECRET;
+  }
+  const normalized = secret?.trim();
+  if (!normalized) {
+    throw new UsageError(
+      "Set MEDIARUNTIME_WEBHOOK_SECRET, pass --secret-file, or explicitly use --generate-secret"
+    );
+  }
+  return normalized;
+}
+async function runTriggerCommand(args, dependencies = {}) {
+  const parsed = parseTriggerArguments(args);
+  const deps = {
+    env: dependencies.env ?? process.env,
+    fetch: dependencies.fetch ?? globalThis.fetch,
+    now: dependencies.now ?? Date.now,
+    randomUUID: dependencies.randomUUID ?? randomUUID,
+    randomBytes: dependencies.randomBytes ?? randomBytes,
+    readFile: dependencies.readFile ?? readFile,
+    writeStdout: dependencies.writeStdout ?? ((text) => process.stdout.write(text))
+  };
+  const secret = await resolveSecret(parsed, deps);
+  const timestamp = Math.floor(deps.now() / 1e3);
+  const unique = deps.randomUUID();
+  const eventId = `evt_cli_${unique}`;
+  const jobId = parsed.jobId ?? `job_cli_${unique}`;
+  const accountId = parsed.accountId ?? "acc_cli_local";
+  const payload = createSyntheticTerminalEvent(parsed.type, {
+    eventId,
+    jobId,
+    accountId,
+    timestamp
+  });
+  const signed = signSyntheticWebhook(payload, { eventId, timestamp, secret });
+  const response = await deps.fetch(parsed.destination, {
+    method: "POST",
+    headers: signed.headers,
+    body: signed.body,
+    redirect: "manual",
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!response.ok) {
+    throw new TriggerDeliveryError(
+      `Local webhook endpoint returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`
+    );
+  }
+  if (parsed.json) {
+    deps.writeStdout(`${JSON.stringify({
+      eventId,
+      type: parsed.type,
+      jobId,
+      status: payload.status,
+      destination: parsed.destination.href,
+      httpStatus: response.status
+    })}
+`);
+  } else {
+    deps.writeStdout(
+      `Sent synthetic ${parsed.type} event ${eventId} to ${parsed.destination.href} (HTTP ${response.status})
+`
+    );
+  }
+  return 0;
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var HELP = `MediaRuntime CLI
+
+Usage:
+  mediaruntime run <source> --output <alias> [--output <alias>] [--wait]
+  mediaruntime jobs list [--status <status>] [--limit <n>] [--cursor <cursor>]
+  mediaruntime jobs get <job_id> [--download <bundle.zip>] [--force]
+  mediaruntime trigger <job.completed|job.failed|job.rejected> --to <local-url>
+
+Global options:
+  --base-url <url>  Developer override; normally leave unset
+  --help            Show help
+  --version         Show version
+
+Run/jobs options:
+  --json            Machine-readable, URL-redacted output
+
+Authentication uses MEDIARUNTIME_API_KEY.
+`;
+function isFileExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function exists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function downloadBundleAtomically(url, destination, options) {
+  const target = resolve(destination);
+  if (!options.force && await exists(target)) {
+    throw new BundleDownloadError(`Refusing to overwrite existing file: ${destination}`);
+  }
+  const temporary = resolve(
+    dirname(target),
+    `.${basename(target)}.${randomUUID2()}.part`
+  );
+  try {
+    let response;
+    try {
+      response = await fetch(url);
+    } catch (error) {
+      throw new BundleDownloadError("Bundle download failed before receiving a response", { cause: error });
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new BundleDownloadError(`Bundle download failed with HTTP ${response.status}`);
+    }
+    if (!response.body) throw new BundleDownloadError("Bundle download returned an empty response body");
+    const hash = createHash("sha256");
+    let sizeBytes = 0;
+    const integrity = new Transform({
+      transform(chunk, _encoding, callback) {
+        sizeBytes += chunk.length;
+        hash.update(chunk);
+        callback(null, chunk);
+      }
+    });
+    await pipeline(
+      Readable.fromWeb(response.body),
+      integrity,
+      createWriteStream(temporary, { flags: "wx", mode: 384 })
+    );
+    const sha256 = hash.digest("hex");
+    if (options.expectedSizeBytes !== void 0 && options.expectedSizeBytes !== null && sizeBytes !== options.expectedSizeBytes) {
+      throw new BundleDownloadError(
+        `Bundle size mismatch: expected ${options.expectedSizeBytes} bytes, received ${sizeBytes}`
+      );
+    }
+    if (options.expectedSha256 && sha256 !== options.expectedSha256.toLowerCase()) {
+      throw new BundleDownloadError("Bundle SHA-256 mismatch");
+    }
+    if (options.force) {
+      await rename(temporary, target);
+    } else {
+      try {
+        await link(temporary, target);
+      } catch (error) {
+        if (isFileExistsError(error)) {
+          throw new BundleDownloadError(`Refusing to overwrite existing file: ${destination}`);
+        }
+        throw error;
+      }
+      await rm(temporary);
+    }
+  } catch (error) {
+    await rm(temporary, { force: true });
+    if (error instanceof BundleDownloadError) throw error;
+    throw new BundleDownloadError(`Could not write bundle to ${destination}`, { cause: error });
+  }
+}
+function normalizeBaseUrl(raw) {
+  let value;
+  try {
+    value = new URL(raw);
+  } catch {
+    throw new UsageError("--base-url must be an absolute HTTP(S) origin");
+  }
+  if (value.username || value.password || value.search || value.hash || value.pathname !== "/") {
+    throw new UsageError("--base-url must be an origin without credentials, path, query, or fragment");
+  }
+  if (value.protocol !== "https:" && !(value.protocol === "http:" && isLoopbackDestination(value))) {
+    throw new UsageError("--base-url must use HTTPS unless it points to loopback");
+  }
+  return value.origin;
+}
+function extractGlobalOptions(argv) {
+  const args = [...argv];
+  let baseUrl;
+  while (args[0] === "--base-url") {
+    const value = args[1];
+    if (!value || value.startsWith("--")) throw new UsageError("--base-url requires a value");
+    baseUrl = normalizeBaseUrl(value);
+    args.splice(0, 2);
+  }
+  return { ...baseUrl === void 0 ? {} : { baseUrl }, args };
+}
+function safeApiError(error) {
+  return {
+    name: error.name,
+    message: error.message,
+    code: error.code,
+    status: error.status,
+    retryable: error.retryable,
+    requestId: error.requestId ?? null,
+    field: error.field ?? null
+  };
+}
+function exitCodeFor(error) {
+  if (error instanceof CliError) return error.exitCode;
+  if (error instanceof JobWaitTimeoutError) return 7;
+  if (error instanceof MediaRuntimeConnectionError) return 5;
+  if (error instanceof MediaRuntimeApiError) {
+    if ([401, 402, 403].includes(error.status)) return 3;
+    if (error.status >= 500) return 5;
+    return 4;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") return 130;
+  if (error instanceof TypeError && /fetch|network|socket|connect/i.test(error.message)) return 5;
+  return 1;
+}
+function safeError(error, exitCode) {
+  if (error instanceof MediaRuntimeApiError) return { ...safeApiError(error), exitCode };
+  return {
+    code: error instanceof CliError ? error.code : "cli_error",
+    message: error instanceof Error ? error.message : "Unknown error",
+    exitCode
+  };
+}
+async function executeCli(argv, dependencies = {}) {
+  const writeStdout = dependencies.writeStdout ?? ((text) => process.stdout.write(text));
+  const writeStderr = dependencies.writeStderr ?? ((text) => process.stderr.write(text));
+  const json = argv.includes("--json");
+  try {
+    const global = extractGlobalOptions(argv);
+    const command = global.args[0];
+    if (!command || command === "--help" || command === "-h") {
+      writeStdout(HELP);
+      return 0;
+    }
+    if (command === "--version" || command === "-v") {
+      writeStdout(`${VERSION}
+`);
+      return 0;
+    }
+    if (command === "trigger") {
+      return await runTriggerCommand(global.args.slice(1), { writeStdout });
+    }
+    const configuredBaseUrl = global.baseUrl ?? process.env.MEDIARUNTIME_API_URL;
+    const baseUrl = configuredBaseUrl ? normalizeBaseUrl(configuredBaseUrl) : void 0;
+    if (!dependencies.createClient && !process.env.MEDIARUNTIME_API_KEY?.trim()) {
+      throw new UsageError("Set MEDIARUNTIME_API_KEY before using run or jobs");
+    }
+    const client = dependencies.createClient?.({
+      ...baseUrl === void 0 ? {} : { baseUrl }
+    }) ?? new MediaRuntime({ ...baseUrl === void 0 ? {} : { baseUrl } });
+    const downloadBundle = dependencies.downloadBundle ?? downloadBundleAtomically;
+    const commandDependencies = { jobs: client.jobs, writeStdout, downloadBundle };
+    if (command === "run") return await runCommand(global.args.slice(1), commandDependencies);
+    if (command === "jobs") {
+      return await runJobsCommand(global.args.slice(1), commandDependencies);
+    }
+    throw new UsageError(`Unknown command: ${command}`);
+  } catch (error) {
+    const exitCode = exitCodeFor(error);
+    if (json) {
+      writeStderr(`${JSON.stringify({ error: safeError(error, exitCode) })}
+`);
+    } else {
+      const requestId = error instanceof MediaRuntimeApiError && error.requestId ? ` (request ${error.requestId})` : "";
+      writeStderr(`Error: ${error instanceof Error ? error.message : "Unknown error"}${requestId}
+`);
+    }
+    return exitCode;
+  }
+}
+var isEntrypoint = false;
+if (process.argv[1] !== void 0) {
+  try {
+    isEntrypoint = realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    isEntrypoint = false;
+  }
+}
+if (isEntrypoint) process.exitCode = await executeCli(process.argv.slice(2));
+export {
+  createSyntheticTerminalEvent,
+  downloadBundleAtomically,
+  executeCli,
+  parseTriggerArguments,
+  runTriggerCommand,
+  signSyntheticWebhook
+};
+//# sourceMappingURL=cli.js.map