yungle-cli 0.1.1 → 0.2.0

package/dist/yungle.mjs

@@ -1,14 +1,177 @@
 #!/usr/bin/env node
+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 __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e2) {
+    throw mod = 0, e2;
+  }
+};
+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
+));
+
+// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env2 = p.env || {};
+    var isColorSupported = !(!!env2.NO_COLOR || argv.includes("--no-color")) && (!!env2.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env2.TERM !== "dumb" || !!env2.CI);
+    var formatter = (open2, close, replace = open2) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open2.length);
+      return ~index ? open2 + replaceClose(string, close, replace, index) + close : open2 + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor3 = 0;
+      do {
+        result += string.substring(cursor3, index) + replace;
+        cursor3 = index + close.length;
+        index = string.indexOf(close, cursor3);
+      } while (~index);
+      return result + string.substring(cursor3);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      to(x, y2) {
+        if (!y2) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y2 + 1};${x + 1}H`;
+      },
+      move(x, y2) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y2 < 0) ret += `${CSI2}${-y2}A`;
+        else if (y2 > 0) ret += `${CSI2}${y2}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase3 = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
+
+// src/index.ts
+import { isAbsolute, join as join6, relative as relative2, resolve as resolve3 } from "node:path";
 
 // ../../packages/api-client/dist/index.mjs
 var YungleApiError = class extends Error {
-  constructor(status, code, message, details) {
+  constructor(status2, code, message, details) {
     super(message);
-    this.status = status;
+    this.status = status2;
     this.code = code;
     this.details = details;
     this.name = "YungleApiError";
   }
+  status;
+  code;
+  details;
   /** Worth trying again: throttled, or our fault. */
   get retryable() {
     return this.status === 429 || this.status >= 500;
@@ -20,25 +183,49 @@ var YungleApiError = class extends Error {
   }
 };
 var DEFAULT_BASE = "https://yungle.co/api/v1";
+function pageQuery(page, extra = {}) {
+  const params = new URLSearchParams(extra);
+  if (page.limit !== void 0) params.set("limit", String(page.limit));
+  if (page.cursor) params.set("cursor", page.cursor);
+  const q = params.toString();
+  return q ? `?${q}` : "";
+}
+var CLIENT_VERSION = true ? "0.2.0" : "dev";
 var YungleClient = class {
   baseUrl;
   apiKey;
   doFetch;
   maxRetries;
+  userAgent;
   constructor(options) {
     if (!options.apiKey) throw new Error("An API key is required.");
     this.apiKey = options.apiKey;
     this.baseUrl = (options.baseUrl ?? DEFAULT_BASE).replace(/\/+$/, "");
     this.doFetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.maxRetries = options.maxRetries ?? 3;
+    this.userAgent = options.userAgent ?? `yungle-client/${CLIENT_VERSION}`;
   }
   // ── Account ───────────────────────────────────────────────────────────────
   me() {
     return this.request("GET", "/me");
   }
   // ── Transfers ─────────────────────────────────────────────────────────────
-  listTransfers() {
-    return this.request("GET", "/transfers");
+  /**
+   * One page of transfers, newest first — 100 by default, up to 500. Pass the
+   * returned `nextCursor` back as `cursor` for the next page; it is null on the
+   * last one. `allTransfers()` does the walking for you.
+   */
+  listTransfers(page = {}) {
+    return this.request("GET", `/transfers${pageQuery(page)}`);
+  }
+  /** Every transfer, newest first, fetched a page at a time as you iterate. */
+  async *allTransfers(pageSize = 500) {
+    let cursor3;
+    do {
+      const page = await this.listTransfers({ limit: pageSize, cursor: cursor3 });
+      yield* page.transfers;
+      cursor3 = page.nextCursor ?? void 0;
+    } while (cursor3);
   }
   /**
    * Create a draft. Nothing is live and nobody is emailed until `finalizeTransfer`.
@@ -90,11 +277,24 @@ var YungleClient = class {
   deleteCollection(id) {
     return this.request("DELETE", `/collections/${enc(id)}`);
   }
-  /** `folderId` omitted lists everything; `'root'` lists the top level only. */
-  listCollectionFiles(id, folderId) {
-    const query = folderId ? `?folderId=${encodeURIComponent(folderId)}` : "";
+  /**
+   * `folderId` omitted lists everything; `'root'` lists the top level only.
+   * Without `page.limit` the whole collection comes back in one response; with
+   * it, follow `nextCursor` (or use `allCollectionFiles`).
+   */
+  listCollectionFiles(id, folderId, page = {}) {
+    const query = pageQuery(page, folderId ? { folderId } : {});
     return this.request("GET", `/collections/${enc(id)}/files${query}`);
   }
+  /** Every file in a collection, oldest first, a page at a time. */
+  async *allCollectionFiles(id, folderId, pageSize = 1e3) {
+    let cursor3;
+    do {
+      const page = await this.listCollectionFiles(id, folderId, { limit: pageSize, cursor: cursor3 });
+      yield* page.files;
+      cursor3 = page.nextCursor ?? void 0;
+    } while (cursor3);
+  }
   addCollectionFiles(id, files, folderId) {
     return this.request("POST", `/collections/${enc(id)}/files`, { files, folderId });
   }
@@ -116,6 +316,42 @@ var YungleClient = class {
   removeGuest(id, guestId) {
     return this.request("DELETE", `/collections/${enc(id)}/guests/${enc(guestId)}`);
   }
+  // ── Webhooks ──────────────────────────────────────────────────────────────
+  listWebhooks() {
+    return this.request("GET", "/webhooks");
+  }
+  /** `url: null` makes a pull endpoint. The `secret` is returned here only. */
+  createWebhook(input) {
+    return this.request("POST", "/webhooks", input);
+  }
+  getWebhook(id) {
+    return this.request("GET", `/webhooks/${enc(id)}`);
+  }
+  updateWebhook(id, input) {
+    return this.request("PATCH", `/webhooks/${enc(id)}`, input);
+  }
+  deleteWebhook(id) {
+    return this.request("DELETE", `/webhooks/${enc(id)}`);
+  }
+  rotateWebhookSecret(id) {
+    return this.request("POST", `/webhooks/${enc(id)}/rotate-secret`);
+  }
+  testWebhook(id) {
+    return this.request("POST", `/webhooks/${enc(id)}/test`);
+  }
+  listWebhookDeliveries(id) {
+    return this.request("GET", `/webhooks/${enc(id)}/deliveries`);
+  }
+  retryWebhookDelivery(id, deliveryId) {
+    return this.request("POST", `/webhooks/${enc(id)}/deliveries/${enc(deliveryId)}/retry`);
+  }
+  /**
+   * An endpoint's events, oldest first, after `cursor`. `nextCursor` comes back
+   * even when nothing is new, so keep the latest and poll with it.
+   */
+  listWebhookEvents(id, page = {}) {
+    return this.request("GET", `/webhooks/${enc(id)}/events${pageQuery(page)}`);
+  }
   // ── Contacts ──────────────────────────────────────────────────────────────
   listContacts() {
     return this.request("GET", "/contacts");
@@ -135,15 +371,15 @@ var YungleClient = class {
   }
   // ── Transport ─────────────────────────────────────────────────────────────
   /**
-   * `idempotent` widens what may be retried.
+   * What may be retried after a 5xx or a lost connection.
    *
-   * GET and DELETE are safe by nature. POST is not — retrying `createTransfer`
-   * after a 500 would make a second draft — so it is opt-in per method, and set
-   * only where the server documents the operation as repeatable. Retrying a
-   * *throttle* is always fine regardless: a 429 means nothing happened.
+   * GET and DELETE are safe by nature. A POST is safe because it carries an
+   * `Idempotency-Key` (see below). PATCH is not retried. Retrying a *throttle*
+   * is always fine regardless: a 429 means nothing happened.
    */
   async request(method, path, body, opts) {
-    const safe = method === "GET" || method === "DELETE" || opts?.idempotent === true;
+    const idempotencyKey = method === "POST" ? globalThis.crypto.randomUUID() : void 0;
+    const safe = method === "GET" || method === "DELETE" || idempotencyKey !== void 0 || opts?.idempotent === true;
     let attempt = 0;
     for (; ; ) {
       const res = await this.doFetch(`${this.baseUrl}${path}`, {
@@ -151,6 +387,8 @@ var YungleClient = class {
         headers: {
           Authorization: `Bearer ${this.apiKey}`,
           Accept: "application/json",
+          "User-Agent": this.userAgent,
+          ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {},
           ...body === void 0 ? {} : { "Content-Type": "application/json" }
         },
         ...body === void 0 ? {} : { body: JSON.stringify(body) }
@@ -187,12 +425,9 @@ function backoffMs(attempt, error) {
   return Math.min(2 ** attempt * 500, 8e3) + Math.floor(Math.random() * 250);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
-// src/index.ts
-import { createInterface } from "node:readline/promises";
-
 // src/args.ts
 var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "to",
@@ -204,16 +439,25 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "folder",
   "out",
   "url",
-  "key"
+  "key",
+  // `yungle mcp install --client cursor` silently installed into EVERY client
+  // before this was added: the flag parsed as a boolean, `cursor` became a stray
+  // positional, and the filter was never applied. The help text promised
+  // `--client <id>`, so the command line was correct and the parser was not.
+  // `helpFlagsAreParsed` in args.test.ts now derives this from HELP.
+  "client",
+  "forward-to",
+  "interval"
 ]);
+var OPTIONAL_VALUE = /* @__PURE__ */ new Set(["key"]);
 function parseArgs(argv) {
   const [command = "help", ...rest] = argv;
   const positionals = [];
   const flags = {};
-  for (let i = 0; i < rest.length; i++) {
-    const token = rest[i];
+  for (let i2 = 0; i2 < rest.length; i2++) {
+    const token = rest[i2];
     if (token === "--") {
-      positionals.push(...rest.slice(i + 1));
+      positionals.push(...rest.slice(i2 + 1));
       break;
     }
     if (token.startsWith("--")) {
@@ -224,12 +468,16 @@ function parseArgs(argv) {
         continue;
       }
       if (VALUE_FLAGS.has(body)) {
-        const value = rest[i + 1];
+        const value = rest[i2 + 1];
         if (value === void 0 || value.startsWith("--")) {
+          if (OPTIONAL_VALUE.has(body)) {
+            flags[body] = true;
+            continue;
+          }
           throw new Error(`--${body} needs a value.`);
         }
         flags[body] = value;
-        i++;
+        i2++;
         continue;
       }
       flags[body] = true;
@@ -245,25 +493,415 @@ function listFlag(value) {
 }
 function numberFlag(value, name) {
   if (value === void 0 || typeof value === "boolean") return void 0;
-  const n = Number(value);
-  if (!Number.isInteger(n) || n <= 0) throw new Error(`--${name} must be a positive whole number.`);
-  return n;
+  const n3 = Number(value);
+  if (!Number.isInteger(n3) || n3 <= 0) throw new Error(`--${name} must be a positive whole number.`);
+  return n3;
 }
 function stringFlag(value) {
   return typeof value === "string" ? value : void 0;
 }
 
+// src/files.ts
+import { readdir, stat } from "node:fs/promises";
+import { basename, join, relative, resolve, sep } from "node:path";
+function isHidden(name) {
+  return name.startsWith(".");
+}
+async function collectFiles(inputs) {
+  const out2 = [];
+  for (const input of inputs) {
+    const absolute = resolve(input);
+    const info = await stat(absolute);
+    if (info.isDirectory()) {
+      await walk(absolute, basename(absolute), out2);
+    } else {
+      out2.push({
+        path: absolute,
+        name: basename(absolute),
+        size: info.size,
+        relativeDir: "",
+        mtimeMs: info.mtimeMs
+      });
+    }
+  }
+  return out2;
+}
+async function walk(dir, prefix, out2) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (isHidden(entry.name)) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(full, `${prefix}/${entry.name}`, out2);
+    } else if (entry.isFile()) {
+      const info = await stat(full);
+      out2.push({
+        path: full,
+        name: entry.name,
+        size: info.size,
+        relativeDir: prefix,
+        mtimeMs: info.mtimeMs
+      });
+    }
+  }
+}
+function toFileInputs(files) {
+  return files.map((f) => ({
+    name: f.name,
+    size: f.size,
+    ...f.relativeDir ? { path: f.relativeDir } : {}
+  }));
+}
+function pairWithTargets(files, targets) {
+  if (files.length !== targets.length) {
+    throw new Error(
+      `The server returned ${targets.length} upload targets for ${files.length} files. Refusing to guess which is which.`
+    );
+  }
+  return files.map((file, i2) => ({ file, target: targets[i2] }));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}
+
+// src/ui.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var env = process.env;
+function colourFor(stream) {
+  if (env.NO_COLOR) return false;
+  if (env.FORCE_COLOR && env.FORCE_COLOR !== "0") return true;
+  return Boolean(stream.isTTY) && env.TERM !== "dumb";
+}
+var outColour = colourFor(process.stdout);
+var errColour = colourFor(process.stderr);
+var o = import_picocolors.default.createColors(outColour);
+var e = import_picocolors.default.createColors(errColour);
+var trueColour = env.COLORTERM === "truecolor" || env.COLORTERM === "24bit";
+function brand(enabled, fallback) {
+  return (s) => !enabled ? s : trueColour ? `\x1B[38;2;52;168;104m${s}\x1B[39m` : fallback(s);
+}
+var accentOut = brand(outColour, o.green);
+var accentErr = brand(errColour, e.green);
+var ascii = process.platform === "win32" && !env.WT_SESSION && env.TERM_PROGRAM !== "vscode";
+var sym = {
+  ok: ascii ? "\u221A" : "\u2714",
+  fail: ascii ? "\xD7" : "\u2716",
+  warn: ascii ? "!" : "\u25B2",
+  arrow: ascii ? "->" : "\u2192",
+  dot: "\xB7",
+  full: ascii ? "#" : "\u2588",
+  empty: ascii ? "-" : "\u2591"
+};
+var isTTY = Boolean(process.stdout.isTTY);
+function interactive(flags) {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY) && flags.json !== true && flags.yes !== true && !env.CI;
+}
+function formatDuration(seconds) {
+  const s = Math.max(0, Math.round(seconds));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+}
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function formatDate(iso, now = /* @__PURE__ */ new Date()) {
+  if (!iso) return "\u2014";
+  const d = new Date(iso);
+  const day = `${d.getDate()} ${MONTHS[d.getMonth()]}`;
+  return d.getFullYear() === now.getFullYear() ? day : `${day} ${d.getFullYear()}`;
+}
+function formatUntil(iso, now = Date.now()) {
+  if (!iso) return "no expiry";
+  const ms = new Date(iso).getTime() - now;
+  if (ms <= 0) return "expired";
+  const h2 = ms / 36e5;
+  if (h2 < 1) return `in ${Math.max(1, Math.round(ms / 6e4))} min`;
+  if (h2 < 48) return `in ${Math.round(h2)} hours`;
+  return `in ${Math.round(h2 / 24)} days`;
+}
+function plural(n3, one, many = `${one}s`) {
+  return `${n3} ${n3 === 1 ? one : many}`;
+}
+function bar(fraction, width = 20) {
+  const f = Math.min(1, Math.max(0, fraction));
+  const full = Math.round(f * width);
+  return accentErr(sym.full.repeat(full)) + e.dim(sym.empty.repeat(width - full));
+}
+function progressLine(done, total, startedAt, extra = "") {
+  const secs = Math.max(0.5, (Date.now() - startedAt) / 1e3);
+  const rate = done / secs;
+  const pct = total > 0 ? done / total : 1;
+  const left = rate > 0 && total > done ? `${formatDuration((total - done) / rate)} left` : "";
+  const parts = [`${formatBytes(done)} of ${formatBytes(total)}`, `${formatBytes(rate)}/s`, left, extra].filter(Boolean);
+  return `  ${bar(pct)}  ${String(Math.floor(pct * 100)).padStart(3)}%  ${e.dim(parts.join(` ${sym.dot} `))}`;
+}
+var lastLine = "";
+function drawProgress(line) {
+  if (!process.stderr.isTTY || line === lastLine) return;
+  lastLine = line;
+  process.stderr.write(`\r\x1B[2K${line}`);
+}
+function endProgress() {
+  if (!process.stderr.isTTY || !lastLine) return;
+  process.stderr.write("\r\x1B[2K");
+  lastLine = "";
+}
+var ANSI = /\x1b\[[0-9;]*m/g;
+var visible = (s) => s.replace(ANSI, "").length;
+function fit(s, width) {
+  const len = visible(s);
+  if (len <= width) return s + " ".repeat(width - len);
+  const plain = s.replace(ANSI, "");
+  return `${plain.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function table(rows, opts = { flex: 0 }) {
+  const all = opts.header ? [opts.header.map((h2) => o.dim(h2)), ...rows] : rows;
+  if (all.length === 0) return "";
+  const cols = all[0].length;
+  const widths = Array.from({ length: cols }, (_, i2) => Math.max(...all.map((r2) => visible(r2[i2] ?? ""))));
+  const gap = 2;
+  const total = widths.reduce((a2, b) => a2 + b, 0) + gap * (cols - 1) + 2;
+  const room = process.stdout.columns ?? 120;
+  if (total > room) widths[opts.flex] = Math.max(8, widths[opts.flex] - (total - room));
+  return all.map((r2) => `  ${r2.map((cell, i2) => i2 === cols - 1 && i2 !== opts.flex ? cell : fit(cell, widths[i2])).join(" ".repeat(gap))}`.trimEnd()).join("\n");
+}
+function success(title, lines = []) {
+  return [`  ${accentOut(sym.ok)} ${o.bold(title)}`, ...lines.map((l) => `    ${l}`)].join("\n");
+}
+function next(command, why) {
+  return `  ${o.dim("Next:")} ${accentOut(command)}${why ? o.dim(`  (${why})`) : ""}`;
+}
+function note(text2) {
+  process.stderr.write(`  ${e.dim(text2)}
+`);
+}
+function heading(text2) {
+  process.stderr.write(`
+  ${text2}
+`);
+}
+
+// src/help.ts
+var HELP = `yungle \u2014 send, receive and keep files with Yungle
+
+Get started
+  yungle login                            sign in with your browser
+    --key <key>           use an API key instead (servers, CI); asks if left out
+    --no-browser          print the link instead of opening it
+  yungle whoami                           show who you are signed in as
+  yungle logout                           sign out and revoke the session
+
+Send and receive
+  yungle send <paths\u2026>                    send files or folders, print the link
+    --to <email>          recipient (repeatable, or comma-separated)
+    --message <text>      note for the recipients
+    --title <text>        label for your dashboard
+    --password <text>     recipients must enter this
+    --expires <days>      lifetime, clamped to your plan
+  yungle get <link>                       download a transfer sent to you
+    --out <dir>           where to save (default: current directory)
+    --zip                 one zip instead of separate files
+    --password <text>     for a protected link; asks if left out
+  yungle status [<id|link>]               who opened and downloaded a transfer
+  yungle transfers                        list your recent transfers
+  yungle revoke <id>                      stop a transfer's link for good
+
+Collections
+  yungle push <paths\u2026> --collection <id>  upload into a collection
+    --folder <id>         target folder
+  yungle watch <dir> --collection <id>    keep uploading new files as they appear
+    --interval <seconds>  how often to look (default 10)
+    --existing            also upload what is already in the folder
+  yungle collections                      list your collections
+  yungle contacts                         list your contacts
+
+In the browser
+  yungle open [<id>|plan|keys|webhooks]   open the dashboard, or a transfer
+
+Developers
+  yungle webhooks ls                      list webhook endpoints
+  yungle webhooks listen                  print events as they happen
+    --forward-to <url>    also POST each one, signed, to a local server
+  yungle mcp install                      connect an AI assistant on this machine
+    --client <id>         claude-desktop | claude-code | cursor | windsurf
+    --dry-run             show what would change, write nothing
+    --allow-write         accept a key with transfers:write (share links)
+  yungle mcp status                       show where it is installed
+  yungle completion <shell>               tab completion for zsh, bash or fish
+  yungle --version                        print the version
+
+Global flags
+  --json                  machine-readable output
+  --yes                   never ask; for scripts
+  --url <base>            use another Yungle (development)
+
+Run a command with --help for examples. Docs: https://yungle.co/developers/cli`;
+var COMMANDS = [
+  "login",
+  "whoami",
+  "logout",
+  "send",
+  "get",
+  "status",
+  "transfers",
+  "revoke",
+  "push",
+  "watch",
+  "collections",
+  "contacts",
+  "open",
+  "webhooks",
+  "mcp",
+  "completion",
+  "help"
+];
+var ALIASES = {
+  "auth login": ["login", "--key"],
+  "auth status": ["whoami"],
+  "ls transfers": ["transfers"],
+  "ls collections": ["collections"],
+  "ls contacts": ["contacts"],
+  ls: ["transfers"],
+  "rm transfer": ["revoke"],
+  upload: ["push"],
+  download: ["get"]
+};
+function resolveAlias(argv) {
+  for (const n3 of [2, 1]) {
+    const key = argv.slice(0, n3).join(" ");
+    const to = ALIASES[key];
+    if (to && argv.length >= n3) return [...to, ...argv.slice(n3)];
+  }
+  return argv;
+}
+var EXAMPLES = {
+  login: ["yungle login", "yungle login --key            # on a server: paste a key from Settings \u2192 API keys"],
+  send: [
+    'yungle send ~/Shoot --to anna@studio.nl --message "Final selects"',
+    "yungle send report.pdf                        # just a link, nobody emailed",
+    "yungle send dist/ --json | jq -r .url         # in a script"
+  ],
+  get: ["yungle get https://yungle.co/t/emerald-palm-a5mt", "yungle get <link> --zip --out ~/Downloads"],
+  status: ["yungle status                                 # pick from your recent transfers", "yungle status https://yungle.co/t/emerald-palm-a5mt"],
+  push: ["yungle push ~/Shoot --collection 01J8Z3M9Q0W4", "yungle push raw/ --collection 01J8Z3M9Q0W4 --folder 01J8Z4AB"],
+  watch: ["yungle watch ~/Renders --collection 01J8Z3M9Q0W4", "yungle watch /Volumes/CARD --collection 01J8Z3M9Q0W4 --interval 30"],
+  open: ["yungle open", "yungle open 01J8Z3M9Q0W4                     # a transfer", "yungle open keys"],
+  webhooks: ["yungle webhooks listen --forward-to http://localhost:8080/hooks"],
+  mcp: ["yungle mcp install --client claude-code --dry-run", "yungle mcp status"],
+  completion: ["yungle completion zsh > ~/.zfunc/_yungle", "yungle completion bash >> ~/.bashrc", "yungle completion fish > ~/.config/fish/completions/yungle.fish"]
+};
+function renderHelp(text2) {
+  return text2.split("\n").map((line) => {
+    if (/^\S/.test(line) && !line.startsWith("yungle") && !line.startsWith("Run ")) return o.bold(line);
+    const cmd = line.match(/^( {2})(yungle [^ ].*?)( {2,}.*)?$/);
+    if (cmd) return `${cmd[1]}${accentOut(cmd[2])}${o.dim(cmd[3] ?? "")}`;
+    if (/^ {2,4}--/.test(line)) return o.dim(line);
+    return line;
+  }).join("\n");
+}
+function commandHelp(command) {
+  const lines = HELP.split("\n");
+  const start = lines.findIndex((l) => l.startsWith(`  yungle ${command}`));
+  if (start < 0) return null;
+  const block2 = [lines[start]];
+  for (let i2 = start + 1; i2 < lines.length && (lines[i2].startsWith("    ") || lines[i2].startsWith(`  yungle ${command} `)); i2++) {
+    block2.push(lines[i2]);
+  }
+  const ex = EXAMPLES[command];
+  return [...block2, ...ex ? ["", "Examples", ...ex.map((l) => `  ${l}`)] : []].join("\n");
+}
+
+// src/completion.ts
+function flagsByCommand() {
+  const out2 = {};
+  let current = null;
+  for (const line of HELP.split("\n")) {
+    const cmd = line.match(/^ {2}yungle ([a-z-]+)/);
+    if (cmd) {
+      current = cmd[1];
+      out2[current] ??= [];
+      continue;
+    }
+    const flag = line.match(/^ {4}(--[a-z-]+)/);
+    if (flag && current) out2[current].push(flag[1]);
+    if (/^\S/.test(line)) current = null;
+  }
+  for (const k of Object.keys(out2)) out2[k] = [.../* @__PURE__ */ new Set([...out2[k], "--json", "--help"])];
+  return out2;
+}
+var PATH_COMMANDS = ["send", "push", "watch"];
+function completionScript(shell) {
+  const flags = flagsByCommand();
+  const cmds = COMMANDS.join(" ");
+  if (shell === "bash") {
+    const cases = Object.entries(flags).map(([c2, f]) => `      ${c2}) opts="${f.join(" ")}" ;;`).join("\n");
+    return `# yungle bash completion. Add to ~/.bashrc:  eval "$(yungle completion bash)"
+_yungle() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}" cmd="\${COMP_WORDS[1]}" opts=""
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${cmds}" -- "$cur") ); return
+  fi
+  case "$cmd" in
+${cases}
+  esac
+  if [[ "$cur" == -* ]]; then COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
+  else case "$cmd" in ${PATH_COMMANDS.join("|")}) COMPREPLY=( $(compgen -f -- "$cur") ) ;; esac
+  fi
+}
+complete -o default -F _yungle yungle
+`;
+  }
+  if (shell === "zsh") {
+    const cases = Object.entries(flags).map(([c2, f]) => `    ${c2}) _arguments '*:file:_files' ${f.map((x) => `'${x}[]'`).join(" ")} ;;`).join("\n");
+    return `#compdef yungle
+# yungle zsh completion. Save as _yungle somewhere on your $fpath, e.g.:
+#   yungle completion zsh > "\${fpath[1]}/_yungle"
+_yungle() {
+  if (( CURRENT == 2 )); then
+    compadd ${cmds}
+    return
+  fi
+  case $words[2] in
+${cases}
+  esac
+}
+_yungle "$@"
+`;
+  }
+  if (shell === "fish") {
+    const lines = [
+      "# yungle fish completion. Save to ~/.config/fish/completions/yungle.fish",
+      `complete -c yungle -f -n '__fish_use_subcommand' -a '${cmds}'`
+    ];
+    for (const [c2, f] of Object.entries(flags)) {
+      for (const flag of f) lines.push(`complete -c yungle -n '__fish_seen_subcommand_from ${c2}' -l ${flag.slice(2)}`);
+    }
+    for (const c2 of PATH_COMMANDS) lines.push(`complete -c yungle -n '__fish_seen_subcommand_from ${c2}' -F`);
+    return `${lines.join("\n")}
+`;
+  }
+  return null;
+}
+
 // src/config.ts
 import { createHash } from "node:crypto";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join as join2 } from "node:path";
 function xdg(envVar, fallback) {
   const configured = process.env[envVar];
-  return configured && configured.startsWith("/") ? configured : join(homedir(), fallback);
+  return configured && configured.startsWith("/") ? configured : join2(homedir(), fallback);
 }
-var CONFIG_PATH = join(xdg("XDG_CONFIG_HOME", ".config"), "yungle", "config.json");
-var RESUME_PATH = join(xdg("XDG_CACHE_HOME", ".cache"), "yungle", "uploads.json");
+var CONFIG_PATH = join2(xdg("XDG_CONFIG_HOME", ".config"), "yungle", "config.json");
+var RESUME_PATH = join2(xdg("XDG_CACHE_HOME", ".cache"), "yungle", "uploads.json");
 async function readConfig() {
   try {
     return JSON.parse(await readFile(CONFIG_PATH, "utf8"));
@@ -283,11 +921,37 @@ async function resolveKey() {
   const baseUrl = process.env.YUNGLE_API_URL?.trim() || config.baseUrl;
   if (fromEnv) return { apiKey: fromEnv, baseUrl, source: "YUNGLE_API_KEY" };
   if (config.apiKey) return { apiKey: config.apiKey, baseUrl, source: CONFIG_PATH };
+  if (config.oauth) {
+    const token = await freshAccessToken(config, baseUrl);
+    if (token) return { apiKey: token, baseUrl, source: `${CONFIG_PATH} (yungle login)` };
+  }
   return null;
 }
+var CLI_CLIENT_ID = "yungle-cli";
+var DEFAULT_API = "https://yungle.co/api/v1";
+function originOf(baseUrl) {
+  return new URL(baseUrl ?? DEFAULT_API).origin;
+}
+async function freshAccessToken(config, baseUrl) {
+  const o2 = config.oauth;
+  if (!o2) return null;
+  if (o2.expiresAt - Date.now() > 10 * 6e4) return o2.accessToken;
+  const res = await fetch(`${originOf(baseUrl)}/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: o2.refreshToken, client_id: CLI_CLIENT_ID })
+  }).catch(() => null);
+  if (!res?.ok) return null;
+  const t2 = await res.json();
+  await writeConfig({
+    ...config,
+    oauth: { accessToken: t2.access_token, refreshToken: t2.refresh_token, expiresAt: Date.now() + t2.expires_in * 1e3 }
+  });
+  return t2.access_token;
+}
 var SESSION_TTL_MS = 2 * 60 * 60 * 1e3;
 function sessionKey(inputs, target) {
-  const parts = inputs.map((f) => [f.path, f.size, Math.floor(f.mtimeMs)]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  const parts = inputs.map((f) => [f.path, f.size, Math.floor(f.mtimeMs)]).sort((a2, b) => a2[0] < b[0] ? -1 : a2[0] > b[0] ? 1 : 0);
   return createHash("sha256").update(JSON.stringify([target, parts])).digest("hex").slice(0, 32);
 }
 async function readSessions() {
@@ -309,15 +973,15 @@ async function findSession(key) {
 async function saveSession(key, session) {
   const sessions = await readSessions();
   sessions[key] = session;
-  await mkdir(dirname(RESUME_PATH), { recursive: true });
-  await writeFile(RESUME_PATH, JSON.stringify(sessions));
+  await mkdir(dirname(RESUME_PATH), { recursive: true, mode: 448 });
+  await writeFile(RESUME_PATH, JSON.stringify(sessions), { mode: 384 });
 }
 async function dropSession(key) {
   const sessions = await readSessions();
   if (!(key in sessions)) return;
   delete sessions[key];
-  await mkdir(dirname(RESUME_PATH), { recursive: true });
-  await writeFile(RESUME_PATH, JSON.stringify(sessions));
+  await mkdir(dirname(RESUME_PATH), { recursive: true, mode: 448 });
+  await writeFile(RESUME_PATH, JSON.stringify(sessions), { mode: 384 });
 }
 var URL_PATH = RESUME_PATH.replace(/uploads\.json$/, "upload-urls.json");
 async function readUploadUrls() {
@@ -331,8 +995,8 @@ async function saveUploadUrl(fileId, uploadUrl) {
   const current = await readUploadUrls();
   if (current[fileId] === uploadUrl) return;
   current[fileId] = uploadUrl;
-  await mkdir(dirname(URL_PATH), { recursive: true });
-  await writeFile(URL_PATH, JSON.stringify(current));
+  await mkdir(dirname(URL_PATH), { recursive: true, mode: 448 });
+  await writeFile(URL_PATH, JSON.stringify(current), { mode: 384 });
 }
 async function clearUploadUrls(fileIds) {
   const current = await readUploadUrls();
@@ -343,103 +1007,1779 @@ async function clearUploadUrls(fileIds) {
       changed = true;
     }
   }
-  if (changed) await writeFile(URL_PATH, JSON.stringify(current));
+  if (changed) await writeFile(URL_PATH, JSON.stringify(current), { mode: 384 });
 }
 
-// src/files.ts
-import { readdir, stat } from "node:fs/promises";
-import { basename, join as join2, relative, resolve, sep } from "node:path";
-function isHidden(name) {
-  return name.startsWith(".");
-}
-async function collectFiles(inputs) {
-  const out2 = [];
-  for (const input of inputs) {
-    const absolute = resolve(input);
-    const info = await stat(absolute);
-    if (info.isDirectory()) {
-      await walk(absolute, basename(absolute), out2);
-    } else {
-      out2.push({
-        path: absolute,
-        name: basename(absolute),
-        size: info.size,
-        relativeDir: "",
-        mtimeMs: info.mtimeMs
-      });
+// src/errors.ts
+var CliError = class extends Error {
+  constructor(message, hint, code = "cli_error", exitCode = 1) {
+    super(message);
+    this.hint = hint;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+  hint;
+  code;
+  exitCode;
+};
+var NotSignedIn = class extends CliError {
+  constructor() {
+    super("You are not signed in.", "yungle login", "not_signed_in");
+  }
+};
+function explain(err) {
+  if (err instanceof CliError) return { message: err.message, hint: err.hint, code: err.code };
+  if (err instanceof YungleApiError) {
+    const base = { code: err.code, details: err.details };
+    switch (err.code) {
+      case "unauthorized":
+        return { ...base, message: "Your sign-in is no longer valid (revoked, expired or mistyped).", hint: "yungle login" };
+      case "insufficient_scope": {
+        const required = typeof err.details?.required === "string" ? err.details.required : null;
+        return {
+          ...base,
+          message: err.message,
+          hint: required === "transfers:send" ? "yungle open keys   (allow emailing, or send without --to)" : "yungle open keys   (create a key that may do this)"
+        };
+      }
+      case "upgrade_required":
+        return { ...base, message: err.message, hint: "yungle open plan" };
+      case "quota_exceeded":
+        return { ...base, message: "Your storage is full.", hint: "yungle open   (free up space, or upgrade)" };
+      case "out_of_credit":
+        return { ...base, message: err.message, hint: "yungle open usage   (add credit)" };
+      case "rate_limited":
+        return {
+          ...base,
+          message: `Too many requests.${err.retryAfterSeconds ? ` Try again in ${err.retryAfterSeconds}s.` : " Try again shortly."}`
+        };
+      case "not_found":
+        return { ...base, message: err.message, hint: "yungle transfers   (list what you have)" };
+      case "email_budget_exhausted":
+        return { ...base, message: err.message, hint: "Share the link yourself; the transfer is live." };
+      default:
+        return { ...base, message: err.message };
     }
   }
-  return out2;
+  const e2 = err;
+  const netCode = e2?.cause?.code ?? e2?.code;
+  if (netCode && ["ENOTFOUND", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "EAI_AGAIN"].includes(netCode)) {
+    return { code: "network", message: "Could not reach Yungle. Check your connection and try again." };
+  }
+  if (e2?.code === "ENOENT" && typeof e2.path === "string") {
+    return { code: "not_found", message: `No such file or folder: ${e2.path}` };
+  }
+  return { code: "cli_error", message: e2 instanceof Error ? e2.message : String(err) };
 }
-async function walk(dir, prefix, out2) {
-  const entries = await readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (isHidden(entry.name)) continue;
-    const full = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      await walk(full, `${prefix}/${entry.name}`, out2);
-    } else if (entry.isFile()) {
-      const info = await stat(full);
-      out2.push({
-        path: full,
-        name: entry.name,
-        size: info.size,
-        relativeDir: prefix,
-        mtimeMs: info.mtimeMs
-      });
+function distance(a2, b) {
+  const dp = Array.from({ length: a2.length + 1 }, (_, i2) => [i2, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++) dp[0][j] = j;
+  for (let i2 = 1; i2 <= a2.length; i2++) {
+    for (let j = 1; j <= b.length; j++) {
+      dp[i2][j] = Math.min(
+        dp[i2 - 1][j] + 1,
+        dp[i2][j - 1] + 1,
+        dp[i2 - 1][j - 1] + (a2[i2 - 1] === b[j - 1] ? 0 : 1)
+      );
+      if (i2 > 1 && j > 1 && a2[i2 - 1] === b[j - 2] && a2[i2 - 2] === b[j - 1]) {
+        dp[i2][j] = Math.min(dp[i2][j], dp[i2 - 2][j - 2] + 1);
+      }
     }
   }
+  return dp[a2.length][b.length];
 }
-function toFileInputs(files) {
-  return files.map((f) => ({
-    name: f.name,
-    size: f.size,
-    ...f.relativeDir ? { path: f.relativeDir } : {}
-  }));
+function suggest(word, known) {
+  let best = null;
+  let bestD = Infinity;
+  for (const k of known) {
+    const d = distance(word.toLowerCase(), k);
+    if (d < bestD) {
+      bestD = d;
+      best = k;
+    }
+  }
+  return best !== null && bestD <= Math.max(1, Math.floor(best.length / 3)) ? best : null;
 }
-function pairWithTargets(files, targets) {
-  if (files.length !== targets.length) {
+
+// src/get.ts
+import { createWriteStream } from "node:fs";
+import { mkdir as mkdir2, rename, stat as stat2 } from "node:fs/promises";
+import { basename as basename2, join as join3 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var SLUG = /^[A-Za-z0-9_-]{8,128}$/;
+function parseTransferLink(input, defaultOrigin) {
+  const text2 = input.trim();
+  if (SLUG.test(text2)) return { origin: defaultOrigin, slug: text2, recipient: null, hasKey: false };
+  let url;
+  try {
+    url = new URL(text2);
+  } catch {
+    throw new Error(`Not a Yungle transfer link: ${text2}`);
+  }
+  const m = url.pathname.match(/^\/t\/([^/]+)\/?$/);
+  if (!m || !SLUG.test(m[1])) {
     throw new Error(
-      `The server returned ${targets.length} upload targets for ${files.length} files. Refusing to guess which is which.`
+      url.pathname.startsWith("/c/") ? "That is a collection link. `yungle get` downloads transfers (/t/\u2026) for now." : `Not a Yungle transfer link: ${text2}`
     );
   }
-  return files.map((file, i) => ({ file, target: targets[i] }));
+  return { origin: url.origin, slug: m[1], recipient: url.searchParams.get("r"), hasKey: url.hash.length > 1 };
 }
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  const units = ["KB", "MB", "GB", "TB"];
-  let value = bytes / 1024;
-  let unit = 0;
-  while (value >= 1024 && unit < units.length - 1) {
-    value /= 1024;
-    unit++;
-  }
-  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+function safeFileName(name) {
+  const last = basename2(name.replace(/\\/g, "/"));
+  const cleaned = last.replace(/[\x00-\x1f<>:"|?*]/g, "_").replace(/^\.+$/, "_").trim();
+  return cleaned || "file";
 }
-
-// src/upload.ts
-import { createReadStream } from "node:fs";
-import { stat as stat2 } from "node:fs/promises";
-var CONCURRENCY = 3;
-async function uploadAll(files, endpoint, onProgress) {
-  const queue = [...files];
-  const workers = Array.from({ length: Math.min(CONCURRENCY, queue.length) }, async () => {
-    for (; ; ) {
-      const next = queue.shift();
-      if (!next) return;
-      await uploadOne(next, endpoint, onProgress);
-    }
+function dedupeNames(names) {
+  const used = /* @__PURE__ */ new Set();
+  return names.map((name) => {
+    let candidate = name;
+    const dot = name.lastIndexOf(".");
+    const [stem, ext] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    for (let n3 = 2; used.has(candidate.toLowerCase()); n3++) candidate = `${stem} (${n3})${ext}`;
+    used.add(candidate.toLowerCase());
+    return candidate;
+  });
+}
+function resumeFrom(partialBytes, expectedSize) {
+  if (partialBytes <= 0 || partialBytes >= expectedSize) return null;
+  return partialBytes;
+}
+var ManifestError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ManifestError";
+  }
+  code;
+};
+async function fetchManifest(link, password2, userAgent) {
+  const res = await fetch(`${link.origin}/api/t/${encodeURIComponent(link.slug)}/manifest`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "User-Agent": userAgent },
+    body: JSON.stringify({ ...password2 ? { password: password2 } : {}, ...link.recipient ? { r: link.recipient } : {} })
+  });
+  const body = await res.json().catch(() => null);
+  if (!res.ok || !body || body.error) {
+    const code = body?.error?.code ?? `http_${res.status}`;
+    const message = code === "not_found" ? "No such transfer. Check the link, or it may have been deleted." : body?.error?.message ?? `The server answered ${res.status}.`;
+    throw new ManifestError(code, message);
+  }
+  return body;
+}
+async function downloadTo(url, dest, expectedSize, userAgent, onBytes) {
+  await mkdir2(join3(dest, ".."), { recursive: true });
+  const part = `${dest}.part`;
+  const have = await stat2(part).then((s) => s.size, () => 0);
+  const from = expectedSize === null ? null : resumeFrom(have, expectedSize);
+  const res = await fetch(url, {
+    headers: { "User-Agent": userAgent, ...from !== null ? { Range: `bytes=${from}-` } : {} }
+  });
+  if (res.status === 410) throw new ManifestError("expired", "The transfer expired, was revoked, or reached its download limit.");
+  if (!res.ok || !res.body) throw new ManifestError(`http_${res.status}`, `Download failed with ${res.status}.`);
+  const appending = from !== null && res.status === 206;
+  if (appending) onBytes(from);
+  const counter = new TransformStream({
+    transform(chunk, controller) {
+      onBytes(chunk.byteLength);
+      controller.enqueue(chunk);
+    }
+  });
+  await pipeline(
+    Readable.fromWeb(res.body.pipeThrough(counter)),
+    createWriteStream(part, { flags: appending ? "a" : "w" })
+  );
+  await rename(part, dest);
+}
+
+// ../../node_modules/.pnpm/@clack+core@1.5.1/node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import l__default from "node:readline";
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i2 = 0, l = PARSE_BLOCKS.length; i2 < l; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/.pnpm/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible2 = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible2 + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible2 = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible2 += characterLength;
+      if (visible2 === columns && !nextCharacter.done) {
+        rows.push("");
+        visible2 = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible2 && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// ../../node_modules/.pnpm/@clack+core@1.5.1/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+function findCursor(s, o2, l) {
+  if (!l.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o2, n3 = Math.max(l.length - 1, 0), e2 = t2 < 0 ? n3 : t2 > n3 ? 0 : t2;
+  return l[e2]?.disabled ? findCursor(e2, o2 < 0 ? -1 : 1, l) : e2;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  accessible: void 0,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n3, e2) => `There are only ${n3} days in ${e2}`,
+      afterMin: (n3) => `Date must be on or after ${n3.toISOString().slice(0, 10)}`,
+      beforeMax: (n3) => `Date must be on or before ${n3.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isAccessible(n3) {
+  if (n3 !== void 0) return n3;
+  if (settings.accessible !== void 0) return settings.accessible;
+  const e2 = process.env.ACCESSIBLE;
+  return e2 !== void 0 && e2 !== "" && e2 !== "0" && e2 !== "false";
+}
+function isActionKey(n3, e2) {
+  if (typeof n3 == "string")
+    return settings.aliases.get(n3) === e2;
+  for (const s of n3)
+    if (s !== void 0 && isActionKey(s, e2))
+      return true;
+  return false;
+}
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e2 = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e2.length, t2.length), f = [];
+  for (let n3 = 0; n3 < r2; n3++)
+    e2[n3] !== t2[n3] && f.push(n3);
+  return {
+    lines: f,
+    numLinesBefore: e2.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e2) {
+  return e2 === CANCEL_SYMBOL;
+}
+function setRawMode(e2, r2) {
+  const o2 = e2;
+  o2.isTTY && o2.setRawMode(r2);
+}
+var getColumns = (e2) => "columns" in e2 && typeof e2.columns == "number" ? e2.columns : 80;
+var getRows = (e2) => "rows" in e2 && typeof e2.rows == "number" ? e2.rows : 20;
+function wrapTextWithPrefix(e2, r2, o2, n3 = o2, s = o2, t2) {
+  const f = getColumns(e2 ?? stdout);
+  return wrapAnsi(r2, f - o2.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c2, i2, m) => {
+    const d = t2 ? t2(c2, i2) : c2;
+    return i2 === 0 ? `${n3}${d}` : i2 === m.length - 1 ? `${s}${d}` : `${o2}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e2, a2) {
+  if ("~standard" in e2) {
+    const n3 = e2["~standard"].validate(a2);
+    return n3 instanceof Promise ? n3.then((r2) => r2.issues?.at(0)?.message) : n3.issues?.at(0)?.message;
+  }
+  return e2(a2);
+}
+var y = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  /**
+   * Whether accessible (static, screen-reader friendly) output is enabled for
+   * this prompt, resolved from the `accessible` option, the global setting,
+   * and the `ACCESSIBLE` env var.
+   */
+  get accessible() {
+    return isAccessible(this.opts.accessible);
+  }
+  constructor(t2, e2 = true) {
+    const { input: i2 = stdin, output: s = stdout, render: r2, signal: n3, ...o2 } = t2;
+    this.opts = o2, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = r2.bind(this), this._track = e2, this._abortSignal = n3, this.input = i2, this.output = s;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e2) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e2), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e2) {
+    this.setSubscriber(t2, { cb: e2 });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e2) {
+    this.setSubscriber(t2, { cb: e2, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e2) {
+    const i2 = this._subscribers.get(t2) ?? [], s = [];
+    for (const r2 of i2)
+      r2.cb(...e2), r2.once && s.push(() => i2.splice(i2.indexOf(r2), 1));
+    for (const r2 of s)
+      r2();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener(
+          "abort",
+          () => {
+            this.state = "cancel", this.close();
+          },
+          { once: true }
+        );
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e2) {
+    return t2 === "	";
+  }
+  _shouldSubmit(t2, e2) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e2) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e2 && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  async onKeypress(t2, e2) {
+    if (this.state !== "validating") {
+      if (this._track && e2.name !== "return" && (e2.name && this._isActionKey(t2, e2) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e2?.name && (!this._track && settings.aliases.has(e2.name) && this.emit("cursor", settings.aliases.get(e2.name)), settings.actions.has(e2.name) && this.emit("cursor", e2.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e2), e2?.name === "return" && this._shouldSubmit(t2, e2)) {
+        if (this.opts.validate) {
+          const i2 = runValidation(this.opts.validate, this.value);
+          let s;
+          i2 instanceof Promise ? (this.state = "validating", this.render(), s = await i2) : s = i2, s && (this.error = s instanceof Error ? s.message : s, this.state = "error", this.rl?.write(this.userInput));
+        }
+        this.state !== "error" && (this.state = "submit");
+      }
+      isActionKey([t2, e2?.name, e2?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+    }
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e2 = diffLines(this._prevFrame, t2), i2 = getRows(this.output);
+        if (this.restoreCursor(), e2) {
+          const s = Math.max(0, e2.numLinesAfter - i2), r2 = Math.max(0, e2.numLinesBefore - i2);
+          let n3 = e2.lines.find((o2) => o2 >= s);
+          if (n3 === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e2.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, n3 - r2)), this.output.write(import_sisteransi.erase.lines(1));
+            const o2 = t2.split(`
+`);
+            this.output.write(o2[n3]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o2.length - n3 - 1));
+            return;
+          } else if (e2.lines.length > 1) {
+            if (s < r2)
+              n3 = s;
+            else {
+              const h2 = n3 - r2;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(n3);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+};
+var r = class extends y {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i2) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i2, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var u$1 = class u extends y {
+  _mask = "\u2022";
+  get cursor() {
+    return this._cursor;
+  }
+  get masked() {
+    return this.userInput.replaceAll(/./g, this._mask);
+  }
+  get userInputWithCursor() {
+    if (this.state === "submit" || this.state === "cancel")
+      return this.masked;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.masked}${styleText(["inverse", "hidden"], "_")}`;
+    const s = this.masked, r2 = s.slice(0, this.cursor), i2 = s.slice(this.cursor, this.cursor + 1), o2 = s.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", i2)}${o2}`;
+  }
+  clear() {
+    this._clearUserInput();
+  }
+  constructor({ mask: t2, ...s }) {
+    super(s), this._mask = t2 ?? "\u2022", this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value === void 0 && (this.value = "");
+    });
+  }
+};
+var n$1 = class n extends y {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e2 = this._selectedValue;
+    this.value = e2 === void 0 ? void 0 : e2.value;
+  }
+  constructor(e2) {
+    super(e2, false), this.options = e2.options;
+    const o2 = this.options.findIndex(({ value: s }) => s === e2.initialValue), t2 = o2 === -1 ? 0 : o2;
+    this.cursor = this.options[t2]?.disabled ? findCursor(t2, 1, this.options) : t2, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+var n2 = class extends y {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}\u2588`;
+    const r2 = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e2 = t2.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", s)}${e2}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@clack+prompts@1.8.1/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var unicodeOr = (o2, e2) => unicode ? o2 : e2;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_BAR_START_RIGHT = unicodeOr("\u2510", "T");
+var S_BAR_END_RIGHT = unicodeOr("\u2518", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("\u256D", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var symbol = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+    case "validating":
+      return styleText2("dim", S_STEP_ACTIVE);
+  }
+};
+var symbolBar = (o2) => {
+  switch (o2) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_BAR);
+    case "cancel":
+      return styleText2("red", S_BAR);
+    case "error":
+      return styleText2("yellow", S_BAR);
+    case "submit":
+      return styleText2("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o2, e2) {
+  const r2 = [`${e2 ? `${styleText2("cyan", S_BAR)}  ` : ""}${o2.join(" \u2022 ")}`];
+  return e2 && r2.push(styleText2("cyan", S_BAR_END)), r2;
+}
+var I = (l, e2, w, p, b, C = false) => {
+  let r2 = e2, O = 0;
+  if (C)
+    for (let i2 = p - 1; i2 >= w; i2--) {
+      const m = l[i2];
+      if (m && (r2 -= m.length), O++, r2 <= b) break;
+    }
+  else
+    for (let i2 = w; i2 < p; i2++) {
+      const m = l[i2];
+      if (m && (r2 -= m.length), O++, r2 <= b) break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l,
+  options: e2,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(p) - C, m = getRows(p), M = styleText2("dim", "..."), v = Math.max(m - r2, 0), a2 = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l >= a2 - 3 && (f = Math.max(
+    Math.min(l - a2 + 3, e2.length - a2),
+    0
+  ));
+  let d = a2 < e2.length && f > 0, c2 = a2 < e2.length && f + a2 < e2.length;
+  const W = Math.min(
+    f + a2,
+    e2.length
+  ), s = [];
+  let g = 0;
+  d && g++, c2 && g++;
+  const T = f + (d ? 1 : 0), y2 = W - (c2 ? 1 : 0);
+  for (let t2 = T; t2 < y2; t2++) {
+    const n3 = e2[t2], o2 = n3 ? w(n3, t2 === l) : "", h2 = wrapAnsi(o2, i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g += h2.length;
+  }
+  if (g > v) {
+    let t2 = 0, n3 = 0, o2 = g;
+    const h2 = l - T;
+    let u4 = v;
+    const L = () => I(s, o2, 0, h2, u4), E = () => I(
+      s,
+      o2,
+      h2 + 1,
+      s.length,
+      u4,
+      true
+    );
+    d ? ({ lineCount: o2, removals: t2 } = L(), o2 > u4 && (c2 || (u4 -= 1), { lineCount: o2, removals: n3 } = E())) : (c2 || (u4 -= 1), { lineCount: o2, removals: n3 } = E(), o2 > u4 && (u4 -= 1, { lineCount: o2, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n3 > 0 && (c2 = true, s.splice(s.length - n3, n3));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t2 of s)
+    for (const n3 of t2)
+      x.push(n3);
+  return c2 && x.push(M), x;
+};
+var confirm = (e2) => {
+  const a2 = e2.active ?? "Yes", o2 = e2.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: o2,
+    signal: e2.signal,
+    input: e2.input,
+    output: e2.output,
+    initialValue: e2.initialValue ?? true,
+    render() {
+      const i2 = e2.withGuide ?? settings.withGuide, u4 = `${symbol(this.state)}  `, l = i2 ? `${styleText2("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(
+        e2.output,
+        e2.message,
+        l,
+        u4
+      ), s = `${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${f}
+`, c2 = this.value ? a2 : o2;
+      switch (this.state) {
+        case "submit": {
+          const r2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${s}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${s}${r2}${styleText2(["strikethrough", "dim"], c2)}${i2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", g = i2 ? styleText2("cyan", S_BAR_END) : "";
+          return `${s}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a2)}`}${e2.vertical ? i2 ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", o2)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${o2}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var password = (e2) => new u$1({
+  validate: e2.validate,
+  mask: e2.mask ?? S_PASSWORD_MASK,
+  signal: e2.signal,
+  input: e2.input,
+  output: e2.output,
+  render() {
+    const r2 = e2.withGuide ?? settings.withGuide, o2 = `${r2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  ${e2.message}
+`, m = this.userInputWithCursor, i2 = this.masked;
+    switch (this.state) {
+      case "error": {
+        const s = r2 ? `${styleText2("yellow", S_BAR)}  ` : "", n3 = r2 ? `${styleText2("yellow", S_BAR_END)}  ` : "", d = i2 ?? "";
+        return e2.clearOnError && this.clear(), `${o2.trim()}
+${s}${d}
+${n3}${styleText2("yellow", this.error)}
+`;
+      }
+      case "submit": {
+        const s = r2 ? `${styleText2("gray", S_BAR)}  ` : "", n3 = i2 ? styleText2("dim", i2) : "";
+        return `${o2}${s}${n3}`;
+      }
+      case "cancel": {
+        const s = r2 ? `${styleText2("gray", S_BAR)}  ` : "", n3 = i2 ? styleText2(["strikethrough", "dim"], i2) : "";
+        return `${o2}${s}${n3}${i2 && r2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+      }
+      default: {
+        const s = r2 ? `${styleText2("cyan", S_BAR)}  ` : "", n3 = r2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${o2}${s}${m}
+${n3}
+`;
+      }
+    }
+  }
+}).prompt();
+var u3 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c = (t2, o2) => t2.includes(`
+`) ? t2.split(`
+`).map((d) => o2(d)).join(`
+`) : o2(t2);
+var select = (t2) => {
+  const o2 = (n3, m) => {
+    if (n3 === void 0)
+      return "";
+    const s = n3.label ?? String(n3.value);
+    switch (m) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (i2) => styleText2("gray", i2))}${n3.hint ? ` ${styleText2("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (i2) => styleText2("dim", i2))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${styleText2("dim", `(${n3.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (i2) => styleText2(["strikethrough", "dim"], i2))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s, (i2) => styleText2("dim", i2))}`;
+    }
+  }, d = t2.showInstructions ?? true;
+  return new n$1({
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
+    render() {
+      const n3 = t2.withGuide ?? settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i2 = wrapTextWithPrefix(
+        t2.output,
+        t2.message,
+        s,
+        m
+      ), u4 = `${n3 ? `${styleText2("gray", S_BAR)}
+` : ""}${i2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+            t2.output,
+            o2(this.options[this.cursor], "selected"),
+            r2
+          );
+          return `${u4}${a2}`;
+        }
+        case "cancel": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+            t2.output,
+            o2(this.options[this.cursor], "cancelled"),
+            r2
+          );
+          return `${u4}${a2}${n3 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = n3 ? `${styleText2("cyan", S_BAR)}  ` : "", a2 = u4.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [styleText2("cyan", S_BAR_END)] : [], f = p.join(`
+`), b = p.length + 1;
+          return `${u4}${r2}${limitOptions({
+            output: t2.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t2.maxItems,
+            columnPadding: r2.length,
+            rowPadding: a2 + b,
+            style: (g, x) => o2(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${f}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (t2) => new n2({
+  validate: t2.validate,
+  placeholder: t2.placeholder,
+  defaultValue: t2.defaultValue,
+  initialValue: t2.initialValue,
+  output: t2.output,
+  signal: t2.signal,
+  input: t2.input,
+  render() {
+    const r2 = t2?.withGuide ?? settings.withGuide, l = `${`${r2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${t2.message}
+`, d = t2.placeholder && t2.placeholder.length > 0 ? (
+      // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
+      styleText2("inverse", t2.placeholder[0]) + styleText2("dim", t2.placeholder.slice(1))
+    ) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : d, s = this.value ?? "";
+    switch (this.state) {
+      case "validating": {
+        const n3 = r2 ? `${styleText2("cyan", S_BAR)}  ` : "", i2 = r2 ? styleText2("cyan", S_BAR_END) : "", c2 = styleText2("dim", o2), $ = styleText2("dim", "Validating...");
+        return `${l}${n3}${c2}
+${i2}  ${$}
+`;
+      }
+      case "error": {
+        const n3 = this.error ? `  ${styleText2("yellow", this.error)}` : "", i2 = r2 ? `${styleText2("yellow", S_BAR)}  ` : "", c2 = r2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${l.trim()}
+${i2}${o2}
+${c2}${n3}
+`;
+      }
+      case "submit": {
+        const n3 = s ? `${r2 ? "  " : ""}${styleText2("dim", s)}` : "", i2 = r2 ? styleText2("gray", S_BAR) : "";
+        return `${l}${i2}${n3}`;
+      }
+      case "cancel": {
+        const n3 = s ? `  ${styleText2(["strikethrough", "dim"], s)}` : "", i2 = r2 ? styleText2("gray", S_BAR) : "";
+        return `${l}${i2}${n3}${s.trim() ? `
+${i2}` : ""}`;
+      }
+      default: {
+        const n3 = r2 ? `${styleText2("cyan", S_BAR)}  ` : "", i2 = r2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${l}${n3}${o2}
+${i2}
+`;
+      }
+    }
+  }
+}).prompt();
+
+// src/guided.ts
+import { stat as stat3 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+function answered(v) {
+  if (isCancel(v) || typeof v === "symbol") throw new CliError("Cancelled.", void 0, "cancelled", 130);
+  return v;
+}
+async function askSend() {
+  const path = answered(
+    await text({
+      message: "What should I send?",
+      placeholder: "a file or folder, e.g. ~/Shoot",
+      validate: (v) => v?.trim() ? void 0 : "Give a path."
+    })
+  ).trim();
+  const expanded = path.startsWith("~/") ? resolve2(process.env.HOME ?? "", path.slice(2)) : resolve2(path);
+  await stat3(expanded).catch(() => {
+    throw new CliError(`No such file or folder: ${path}`, void 0, "not_found");
+  });
+  const to = answered(
+    await text({
+      message: "Email it to anyone?",
+      placeholder: "addresses, comma-separated; leave empty for a link only"
+    })
+  ).split(/[,\s]+/).filter(Boolean);
+  const message = to.length ? answered(await text({ message: "A note for them?", placeholder: "optional" })).trim() || void 0 : void 0;
+  return { paths: [expanded], to, message };
+}
+async function confirm2(message) {
+  return answered(await confirm({ message, initialValue: true }));
+}
+async function askLink() {
+  return answered(
+    await text({ message: "Paste the link", placeholder: "https://yungle.co/t/\u2026", validate: (v) => v?.includes("/t/") || /^[\w-]{8,}$/.test(v ?? "") ? void 0 : "That is not a transfer link." })
+  ).trim();
+}
+async function askPassword() {
+  return answered(await password({ message: "This transfer has a password" })).trim();
+}
+async function pick(message, options) {
+  return answered(await select({ message, options }));
+}
+async function askKey() {
+  return answered(
+    await password({
+      message: "Paste an API key (create one at yungle.co/dashboard/settings/api)",
+      validate: (v) => v?.startsWith("yk_live_") ? void 0 : "Keys start with yk_live_."
+    })
+  ).trim();
+}
+
+// src/listen.ts
+import { createHmac } from "node:crypto";
+var LISTEN_DESCRIPTION = "yungle webhooks listen";
+var ALL = [
+  "transfer.ready",
+  "transfer.downloaded",
+  "transfer.expiring",
+  "transfer.expired",
+  "collection.file_uploaded"
+];
+function signForForward(secret, body, now = Date.now()) {
+  const t2 = Math.floor(now / 1e3);
+  return `t=${t2},v1=${createHmac("sha256", secret).update(`${t2}.${body}`).digest("hex")}`;
+}
+async function ensureListenEndpoint(api) {
+  const { webhooks: webhooks2 } = await api.listWebhooks();
+  const existing = webhooks2.find((w) => w.mode === "pull" && w.description === LISTEN_DESCRIPTION);
+  if (existing) {
+    if (!existing.enabled) await api.updateWebhook(existing.id, { enabled: true });
+    const { secret } = await api.rotateWebhookSecret(existing.id);
+    return { id: existing.id, secret };
+  }
+  try {
+    const { webhook, secret } = await api.createWebhook({ url: null, events: ALL, description: LISTEN_DESCRIPTION });
+    return { id: webhook.id, secret };
+  } catch (err) {
+    if (err instanceof YungleApiError && err.code === "upgrade_required" && /collection/.test(err.message)) {
+      const { webhook, secret } = await api.createWebhook({
+        url: null,
+        events: ALL.filter((e2) => e2.startsWith("transfer.")),
+        description: LISTEN_DESCRIPTION
+      });
+      return { id: webhook.id, secret };
+    }
+    if (err instanceof YungleApiError && err.code === "insufficient_scope") {
+      throw new Error(
+        "This session cannot add webhook endpoints: `yungle login` never grants that, so a phished code cannot wire your account to someone else\u2019s server. Use an API key with webhooks:write (yungle login --key), or add a pull endpoint in Settings \u2192 Webhooks and listen with a key."
+      );
+    }
+    if (err instanceof YungleApiError && err.code === "upgrade_required") {
+      throw new Error(
+        "The free plan includes one webhook endpoint and this workspace already has one. Remove it in Settings \u2192 Webhooks to listen here, or upgrade for more."
+      );
+    }
+    throw err;
+  }
+}
+async function cursorAtNow(api, id) {
+  let cursor3;
+  for (; ; ) {
+    const page = await api.listWebhookEvents(id, { limit: 500, cursor: cursor3 });
+    cursor3 = page.nextCursor ?? cursor3;
+    if (!page.hasMore) return cursor3;
+  }
+}
+function describeEvent(e2) {
+  const d = e2.data;
+  if (d.file) return `${d.file.name} \u2192 ${d.collection?.title ?? "collection"}`;
+  const what = d.transfer?.title || d.transfer?.id || "";
+  if (d.download) return `${what}${d.download.recipient ? ` by ${d.download.recipient}` : ""}`;
+  return d.reason ? `${what} (${d.reason})` : what;
+}
+
+// src/login.ts
+import { spawn } from "node:child_process";
+var SCOPES = [
+  "transfers:read",
+  "transfers:write",
+  "collections:read",
+  "collections:write",
+  "contacts:read",
+  "contacts:write",
+  "webhooks:read",
+  "webhooks:write"
+];
+function nextPoll(answer, interval) {
+  if (answer.access_token) return { done: true };
+  switch (answer.error) {
+    case "authorization_pending":
+      return { wait: interval };
+    case "slow_down":
+      return { wait: interval + 5 };
+    // RFC 8628 §3.5
+    case "access_denied":
+      return { fail: "The request was declined in the browser." };
+    case "expired_token":
+      return { fail: "The code expired. Run `yungle login` again." };
+    default:
+      return { fail: `Sign-in failed: ${answer.error ?? "unexpected answer"}.` };
+  }
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => void 0).unref();
+  } catch {
+  }
+}
+async function deviceLogin(baseUrl, opts) {
+  const origin = originOf(baseUrl);
+  const start = await fetch(`${origin}/oauth/device_authorization`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ client_id: CLI_CLIENT_ID, scope: SCOPES.join(" ") })
+  });
+  if (!start.ok) throw new Error(`Could not start sign-in (HTTP ${start.status}).`);
+  const d = await start.json();
+  process.stderr.write(`
+Open ${d.verification_uri}
+and type the code  ${d.user_code}
+
+`);
+  if (opts.openBrowser) openBrowser(d.verification_uri);
+  let interval = d.interval;
+  const deadline = Date.now() + d.expires_in * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r2) => setTimeout(r2, interval * 1e3));
+    const res = await fetch(`${origin}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: d.device_code,
+        client_id: CLI_CLIENT_ID
+      })
+    });
+    const answer = await res.json();
+    const step = nextPoll(answer, interval);
+    if ("fail" in step) throw new Error(step.fail);
+    if ("done" in step) {
+      const config = await readConfig();
+      await writeConfig({
+        ...config,
+        ...baseUrl ? { baseUrl } : {},
+        oauth: {
+          accessToken: answer.access_token,
+          refreshToken: answer.refresh_token,
+          expiresAt: Date.now() + (answer.expires_in ?? 3600) * 1e3
+        }
+      });
+      return answer.scope ?? "";
+    }
+    interval = step.wait;
+  }
+  throw new Error("The code expired. Run `yungle login` again.");
+}
+async function logout(baseUrl) {
+  const config = await readConfig();
+  if (!config.oauth) return false;
+  const origin = originOf(baseUrl ?? config.baseUrl);
+  for (const token of [config.oauth.refreshToken, config.oauth.accessToken]) {
+    await fetch(`${origin}/oauth/revoke`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ token })
+    }).catch(() => void 0);
+  }
+  const { oauth: _gone, ...rest } = config;
+  await writeConfig(rest);
+  return true;
+}
+
+// src/mcp-install.ts
+import { homedir as homedir2, platform } from "node:os";
+import { join as join4 } from "node:path";
+function mcpClients(os = platform(), home = homedir2(), env2 = process.env) {
+  const appData = env2.APPDATA ?? join4(home, "AppData", "Roaming");
+  return [
+    {
+      id: "claude-desktop",
+      label: "Claude Desktop",
+      serversKey: "mcpServers",
+      configPath: os === "darwin" ? join4(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : os === "win32" ? join4(appData, "Claude", "claude_desktop_config.json") : (
+        // No Linux build of Claude Desktop exists, so there is nothing to write.
+        null
+      )
+    },
+    {
+      id: "claude-code",
+      label: "Claude Code",
+      serversKey: "mcpServers",
+      configPath: join4(home, ".claude.json"),
+      viaCli: {
+        bin: "claude",
+        // `-s user` so it applies everywhere, not just the directory the install
+        // happened to be run from — the default scope is `local`, which would
+        // silently give a per-project install nobody asked for.
+        args: (name, json) => ["mcp", "add-json", "-s", "user", name, json]
+      }
+    },
+    {
+      id: "cursor",
+      label: "Cursor",
+      serversKey: "mcpServers",
+      configPath: join4(home, ".cursor", "mcp.json")
+    },
+    {
+      id: "windsurf",
+      label: "Windsurf",
+      serversKey: "mcpServers",
+      configPath: join4(home, ".codeium", "windsurf", "mcp_config.json")
+    }
+  ];
+}
+function serverEntry(opts) {
+  const env2 = { YUNGLE_API_KEY: opts.apiKey };
+  if (opts.baseUrl) env2.YUNGLE_API_URL = opts.baseUrl;
+  return { command: "npx", args: ["-y", "yungle-mcp"], env: env2 };
+}
+function mergeServerEntry(existing, serversKey, name, entry) {
+  const root = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
+  const servers = root[serversKey];
+  const nextServers = servers && typeof servers === "object" && !Array.isArray(servers) ? { ...servers } : {};
+  const before = nextServers[name];
+  if (before !== void 0 && deepEqual(before, entry)) return { kind: "unchanged" };
+  nextServers[name] = entry;
+  root[serversKey] = nextServers;
+  return before === void 0 ? { kind: "added", config: root } : { kind: "updated", config: root, previous: before };
+}
+function deepEqual(a2, b) {
+  if (a2 === b) return true;
+  if (typeof a2 !== typeof b || a2 === null || b === null) return false;
+  if (Array.isArray(a2) || Array.isArray(b)) {
+    if (!Array.isArray(a2) || !Array.isArray(b) || a2.length !== b.length) return false;
+    return a2.every((v, i2) => deepEqual(v, b[i2]));
+  }
+  if (typeof a2 !== "object") return false;
+  const ka = Object.keys(a2);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  return ka.every(
+    (k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a2[k], b[k])
+  );
+}
+function writeScopes(scopes) {
+  return scopes.filter((s) => s.endsWith(":write"));
+}
+function unusableWriteScopes(scopes) {
+  return writeScopes(scopes).filter((s) => s !== "transfers:write");
+}
+
+// src/output.ts
+function out(json, data, pretty, plain = pretty, code = 0) {
+  const human = isTTY ? `${pretty.startsWith("\n") ? "" : "\n"}${pretty}
+` : `${plain}
+`;
+  process.stdout.write(json ? `${JSON.stringify(data, null, 2)}
+` : human);
+  return code;
+}
+function fail(err, json) {
+  const x = explain(err);
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ error: { code: x.code, message: x.message, ...x.details ? { details: x.details } : {} } }, null, 2)}
+`);
+  } else {
+    process.stderr.write(`
+  ${e.red(sym.fail)} ${x.message}
+`);
+    if (x.hint) process.stderr.write(`    ${e.dim(sym.arrow)} ${accentErr(x.hint)}
+`);
+    process.stderr.write("\n");
+  }
+  return x.code === "usage" ? 2 : 1;
+}
+
+// src/mcp-command.ts
+async function mcp(positionals, flags, json, client2) {
+  const sub = positionals[0] ?? "install";
+  if (sub !== "install" && sub !== "status") {
+    throw new CliError(`Unknown: yungle mcp ${sub}.`, "yungle mcp install   or   yungle mcp status", "usage", 2);
+  }
+  const { readFile: readFile3, writeFile: writeFile3, mkdir: mkdir4, copyFile } = await import("node:fs/promises");
+  const { dirname: dirname3 } = await import("node:path");
+  const all = mcpClients();
+  const only = stringFlag(flags.client);
+  if (only && !all.some((c2) => c2.id === only)) {
+    throw new CliError(`Unknown client: ${only}.`, `--client ${all.map((c2) => c2.id).join(" | ")}`, "usage", 2);
+  }
+  const targets = only ? all.filter((c2) => c2.id === only) : all;
+  if (sub === "status") {
+    const rows = [];
+    for (const c2 of targets) {
+      let installed = false;
+      if (c2.configPath) {
+        try {
+          const doc = JSON.parse(await readFile3(c2.configPath, "utf8"));
+          const servers = doc[c2.serversKey];
+          installed = !!servers && typeof servers === "object" && "yungle" in servers;
+        } catch {
+          installed = false;
+        }
+      }
+      rows.push({ client: c2.id, path: c2.configPath, installed });
+    }
+    return out(
+      json,
+      { clients: rows },
+      table(
+        rows.map((r2) => [r2.client, r2.installed ? "installed" : r2.path ? "not installed" : "not available on this platform"]),
+        { flex: 1 }
+      )
+    );
+  }
+  const resolved = await resolveKey();
+  if (!resolved) {
+    throw new CliError(
+      "The local MCP server needs an API key. Or skip keys: add https://yungle.co/mcp to your assistant and sign in there.",
+      "yungle login --key",
+      "not_signed_in"
+    );
+  }
+  if (resolved.source.includes("(yungle login)")) {
+    throw new CliError(
+      "The local MCP server needs an API key; a browser sign-in expires within the hour. Easiest: add https://yungle.co/mcp to your assistant and sign in there. Or save a key for this:",
+      "yungle login --key",
+      "not_signed_in"
+    );
+  }
+  let scopes;
+  try {
+    const me = await client2(flags).me();
+    scopes = me.key.scopes ?? [];
+  } catch (err) {
+    throw new CliError(
+      `Could not check what this key may do (${err.message}), so nothing was installed: an assistant should never get a key of unknown scope.`
+    );
+  }
+  const writes = writeScopes(scopes);
+  const unusable = unusableWriteScopes(scopes);
+  if (unusable.length > 0 || writes.length > 0 && flags["allow-write"] !== true) {
+    throw new CliError(
+      (unusable.length > 0 ? `This key can ${unusable.join(", ")}, which the MCP server never uses.` : `This key can write (${writes.join(", ")}).`) + " Give an assistant as little as it needs: the :read scopes to answer questions, plus transfers:write (with --allow-write) to share links. Or skip keys: add https://yungle.co/mcp to your assistant and sign in.",
+      "yungle open keys",
+      "insufficient_scope"
+    );
+  }
+  const entry = serverEntry({ apiKey: resolved.apiKey, baseUrl: resolved.baseUrl });
+  const dryRun = flags["dry-run"] === true;
+  const results = [];
+  for (const c2 of targets) {
+    const r2 = await installInto(c2, entry, { dryRun, readFile: readFile3, writeFile: writeFile3, mkdir: mkdir4, copyFile, dirname: dirname3 });
+    results.push({ client: c2.id, ...r2 });
+  }
+  const changed = results.filter((r2) => r2.action === "added" || r2.action === "updated");
+  const lines = [table(results.map((r2) => [r2.client, `${r2.action}${r2.detail ? ` \u2014 ${r2.detail}` : ""}`]), { flex: 1 })];
+  if (changed.length > 0 && !dryRun) {
+    lines.push("");
+    lines.push("Restart the client(s) above to pick it up.");
+    lines.push('Then ask: "what did I send recently?" or "did the client download it?"');
+    lines.push("");
+    lines.push(`Your API key is now also in ${changed.length === 1 ? "that config file" : "those config files"}, in plain text.`);
+  }
+  if (changed.length === 0 && !dryRun) {
+    lines.push("");
+    lines.push("Nothing to do. `yungle mcp status` shows where it is installed.");
+  }
+  return out(json, { installed: results, dryRun }, lines.join("\n"));
+}
+async function installInto(c2, entry, io) {
+  if (!c2.configPath) return { action: "skipped", detail: "not available on this platform" };
+  if (c2.viaCli) {
+    const { spawnSync } = await import("node:child_process");
+    const probe = spawnSync(c2.viaCli.bin, ["--version"], { stdio: "ignore", shell: false });
+    if (probe.error) return { action: "skipped", detail: `${c2.viaCli.bin} not installed` };
+    if (io.dryRun) {
+      return { action: "would run", detail: `${c2.viaCli.bin} mcp add-json -s user yungle \u2026` };
+    }
+    const existed = spawnSync(c2.viaCli.bin, ["mcp", "get", "yungle"], { stdio: "ignore", shell: false }).status === 0;
+    if (existed) {
+      spawnSync(c2.viaCli.bin, ["mcp", "remove", "-s", "user", "yungle"], {
+        stdio: "ignore",
+        shell: false
+      });
+    }
+    const res = spawnSync(c2.viaCli.bin, c2.viaCli.args("yungle", JSON.stringify(entry)), {
+      stdio: "pipe",
+      shell: false,
+      encoding: "utf8"
+    });
+    if (res.status !== 0) {
+      const why = (res.stderr || res.stdout || "").trim().split("\n")[0] || `exit ${res.status}`;
+      return { action: "failed", detail: why };
+    }
+    return {
+      action: existed ? "updated" : "added",
+      detail: `via ${c2.viaCli.bin} mcp add-json`
+    };
+  }
+  let raw = null;
+  try {
+    raw = await io.readFile(c2.configPath, "utf8");
+  } catch {
+    let dirExists = true;
+    try {
+      await io.readFile(io.dirname(c2.configPath), "utf8");
+    } catch (err) {
+      dirExists = err.code === "EISDIR";
+    }
+    if (!dirExists) return { action: "skipped", detail: "not installed" };
+  }
+  let existing = {};
+  if (raw !== null && raw.trim() !== "") {
+    try {
+      existing = JSON.parse(raw);
+    } catch {
+      return {
+        action: "refused",
+        path: c2.configPath,
+        detail: `${c2.configPath} is not valid JSON \u2014 fix or move it, nothing was written`
+      };
+    }
+    if (existing === null || typeof existing !== "object" || Array.isArray(existing)) {
+      return {
+        action: "refused",
+        path: c2.configPath,
+        detail: `${c2.configPath} is not a JSON object \u2014 nothing was written`
+      };
+    }
+  }
+  const merged = mergeServerEntry(existing, c2.serversKey, "yungle", entry);
+  if (merged.kind === "unchanged") return { action: "already current", path: c2.configPath };
+  if (io.dryRun) {
+    return { action: `would be ${merged.kind}`, path: c2.configPath, detail: c2.configPath };
+  }
+  if (raw !== null) {
+    try {
+      await io.copyFile(c2.configPath, `${c2.configPath}.yungle-bak`);
+    } catch {
+    }
+  }
+  await io.mkdir(io.dirname(c2.configPath), { recursive: true });
+  await io.writeFile(c2.configPath, `${JSON.stringify(merged.config, null, 2)}
+`, { mode: 384 });
+  return { action: merged.kind, path: c2.configPath, detail: c2.configPath };
+}
+
+// src/upload.ts
+import { createReadStream } from "node:fs";
+import { stat as stat4 } from "node:fs/promises";
+var CONCURRENCY = 3;
+async function uploadAll(files, endpoint, onProgress) {
+  const queue = [...files];
+  const workers = Array.from({ length: Math.min(CONCURRENCY, queue.length) }, async () => {
+    for (; ; ) {
+      const next2 = queue.shift();
+      if (!next2) return;
+      await uploadOne(next2, endpoint, onProgress);
+    }
   });
   await Promise.all(workers);
   await clearUploadUrls(files.map((f) => f.target.id));
 }
 async function uploadOne(file, endpoint, onProgress) {
   const tus = await import("tus-js-client");
-  const { size } = await stat2(file.path);
+  const { size } = await stat4(file.path);
   const urls = await readUploadUrls();
   const uploadUrl = urls[file.target.id];
   const started = Date.now();
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve4, reject) => {
     const upload = new tus.Upload(createReadStream(file.path), {
       endpoint,
       /**
@@ -495,299 +2835,615 @@ async function uploadOne(file, endpoint, onProgress) {
           resumed: Boolean(uploadUrl)
         });
       },
-      onSuccess: () => resolve2(),
+      onSuccess: () => resolve4(),
       onError: (err) => reject(err)
     });
     upload.start();
   });
 }
 
-// src/index.ts
-var HELP = `yungle \u2014 send and sync files with Yungle
-
-  yungle auth login                       save an API key
-  yungle auth status                      show which key is in use
-  yungle send <paths\u2026>                    send files, print the share link
-    --to <email>          recipient (repeatable, or comma-separated)
-    --message <text>      note for the recipients
-    --title <text>        label for your dashboard
-    --password <text>     recipients must enter this
-    --expires <days>      lifetime, clamped to your plan
-  yungle push <paths\u2026> --collection <id>  upload into a collection
-    --folder <id>         target folder
-  yungle ls transfers|collections|contacts
-  yungle rm transfer <id>                 revoke a transfer
-
-Global flags
-  --json                  machine-readable output
-  --url <base>            override the API base URL
+// src/watch.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join5 } from "node:path";
+function fingerprint(f) {
+  return `${f.path}|${f.size}|${Math.floor(f.mtimeMs)}`;
+}
+function planTick(current, lastSeen, uploaded) {
+  const seen = new Set(current.map(fingerprint));
+  const ready = current.filter((f) => {
+    const fp = fingerprint(f);
+    return !uploaded.has(fp) && lastSeen.has(fp);
+  });
+  return { ready, seen };
+}
+function statePath(dir, collectionId) {
+  const key = createHash2("sha256").update(`${dir}
+${collectionId}`).digest("hex").slice(0, 16);
+  return join5(dirname2(RESUME_PATH), `watch-${key}.json`);
+}
+async function loadUploaded(dir, collectionId) {
+  try {
+    return new Set(JSON.parse(await readFile2(statePath(dir, collectionId), "utf8")));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function saveUploaded(dir, collectionId, uploaded) {
+  const p = statePath(dir, collectionId);
+  await mkdir3(dirname2(p), { recursive: true, mode: 448 });
+  await writeFile2(p, JSON.stringify([...uploaded]), { mode: 384 });
+}
 
-Credentials are read from YUNGLE_API_KEY, then ${CONFIG_PATH}.
-Docs: https://yungle.co/developers`;
-async function main(argv) {
+// src/index.ts
+var CLI_VERSION = true ? "0.2.0" : "dev";
+var USER_AGENT = `yungle-cli/${CLI_VERSION}`;
+async function main(argvIn) {
+  const argv = resolveAlias(argvIn);
   let parsed;
   try {
-    parsed = parseArgs(argv);
+    parsed = parseArgs(argv.length ? argv : ["help"]);
   } catch (err) {
-    process.stderr.write(`${err.message}
-`);
-    return 2;
+    return fail(new CliError(err.message, "yungle help", "usage", 2), false);
   }
   const { command, positionals, flags } = parsed;
   const json = flags.json === true;
   try {
+    if (flags.help === true && command !== "help") return help([command], json);
     switch (command) {
       case "help":
       case "--help":
       case "-h":
-        process.stdout.write(`${HELP}
-`);
-        return 0;
-      case "auth":
-        return await auth(positionals, flags, json);
+        if (argvIn.length === 0 && interactive(flags)) return await menu(flags);
+        return help(positionals, json);
+      case "version":
+      case "--version":
+      case "-v":
+        return out(json, { version: CLI_VERSION }, CLI_VERSION);
+      case "login":
+        return await login(flags, json);
+      case "logout": {
+        const had = await logout(stringFlag(flags.url));
+        return out(json, { signedOut: had }, had ? success("Signed out", [o.dim("The session is revoked.")]) : "  Not signed in with `yungle login`; nothing to do.");
+      }
+      case "whoami":
+        return await whoami(flags, json);
       case "send":
         return await send(positionals, flags, json);
+      case "get":
+        return await get(positionals, flags, json);
+      case "status":
+        return await status(positionals, flags, json);
+      case "transfers":
+        return await transfers(flags, json);
+      case "collections":
+        return await collections(flags, json);
+      case "contacts":
+        return await contacts(flags, json);
+      case "revoke":
+        return await revoke(positionals, flags, json);
       case "push":
         return await push(positionals, flags, json);
-      case "ls":
-        return await list(positionals, flags, json);
-      case "rm":
-        return await remove(positionals, flags, json);
-      default:
-        process.stderr.write(`Unknown command: ${command}
-
-${HELP}
-`);
-        return 2;
+      case "watch":
+        return await watch(positionals, flags, json);
+      case "open":
+        return await open(positionals, flags, json);
+      case "webhooks":
+        return await webhooks(positionals, flags, json);
+      case "mcp":
+        return await mcp(positionals, flags, json, client);
+      case "completion": {
+        const script = completionScript(positionals[0] ?? "");
+        if (!script) throw new CliError("Which shell?", "yungle completion zsh | bash | fish", "usage", 2);
+        process.stdout.write(script);
+        return 0;
+      }
+      default: {
+        const guess = suggest(command, COMMANDS);
+        throw new CliError(`Unknown command: ${command}.`, guess ? `yungle ${guess}   (did you mean this?)` : "yungle help", "usage", 2);
+      }
     }
   } catch (err) {
+    endProgress();
     return fail(err, json);
   }
 }
-async function auth(positionals, flags, json) {
-  const sub = positionals[0] ?? "status";
-  if (sub === "login") {
-    let key = stringFlag(flags.key);
-    if (!key) {
-      process.stderr.write(
-        `Create a key at https://yungle.co/dashboard/settings/api
-and paste it here.
-
-`
-      );
-      const rl = createInterface({ input: process.stdin, output: process.stderr });
-      key = (await rl.question("API key: ")).trim();
-      rl.close();
+function help(positionals, json) {
+  const topic = positionals[0];
+  if (topic) {
+    const text2 = commandHelp(topic);
+    if (!text2) {
+      const guess = suggest(topic, COMMANDS);
+      throw new CliError(`No help for "${topic}".`, guess ? `yungle help ${guess}` : "yungle help", "usage", 2);
     }
+    return out(json, { command: topic, help: text2 }, renderHelp(text2), text2);
+  }
+  return out(json, { help: HELP }, renderHelp(HELP), HELP);
+}
+async function menu(flags) {
+  const signedIn = Boolean(await resolveKey());
+  const choice = await pick("What would you like to do?", [
+    ...signedIn ? [] : [{ value: "login", label: "Sign in", hint: "opens your browser" }],
+    { value: "send", label: "Send files or a folder" },
+    { value: "get", label: "Download a link someone sent you" },
+    ...signedIn ? [{ value: "status", label: "See who downloaded a transfer" }, { value: "open", label: "Open the dashboard" }] : [],
+    { value: "help", label: "Show all commands" }
+  ]);
+  if (choice === "help") return help([], false);
+  return main([choice, ...stringFlag(flags.url) ? ["--url", stringFlag(flags.url)] : []]);
+}
+async function login(flags, json) {
+  const url = stringFlag(flags.url);
+  if (flags.key !== void 0) {
+    let key = stringFlag(flags.key);
     if (!key) {
-      process.stderr.write("No key given.\n");
-      return 2;
+      if (!interactive(flags)) throw new CliError("Give the key: --key yk_live_\u2026", void 0, "usage", 2);
+      key = await askKey();
     }
-    const client2 = new YungleClient({ apiKey: key, baseUrl: stringFlag(flags.url) });
-    const me = await client2.me();
+    const me2 = await new YungleClient({ apiKey: key, baseUrl: url, userAgent: USER_AGENT }).me();
     const config = await readConfig();
-    await writeConfig({ ...config, apiKey: key, baseUrl: stringFlag(flags.url) ?? config.baseUrl });
-    return out(
-      json,
-      { ok: true, workspace: me.workspace.email, plan: me.plan.name, scopes: me.key.scopes },
-      `Signed in as ${me.workspace.email ?? me.workspace.id} (${me.plan.name ?? "free"}).
-Saved to ${CONFIG_PATH}`
-    );
-  }
-  if (sub === "status") {
-    const resolved = await resolveKey();
-    if (!resolved) {
-      return out(json, { authenticated: false }, "Not signed in. Run `yungle auth login`.", 1);
-    }
-    const me = await client(flags).me();
+    await writeConfig({ ...config, apiKey: key, baseUrl: url ?? config.baseUrl });
     return out(
       json,
-      { authenticated: true, source: resolved.source, ...me },
-      [
-        `Workspace: ${me.workspace.email ?? me.workspace.id}`,
-        `Plan:      ${me.plan.name ?? "free"}`,
-        `Storage:   ${formatBytes(me.plan.usedBytes)} of ${formatBytes(me.plan.quotaBytes)}`,
-        `Key:       ${me.key.name} (${me.key.scopes.join(", ")})`,
-        `Source:    ${resolved.source}`
-      ].join("\n")
+      { ok: true, workspace: me2.workspace.email, plan: me2.plan.name, scopes: me2.key.scopes },
+      success(`Signed in as ${me2.workspace.email ?? me2.workspace.id}`, [o.dim(`with key ${me2.key.name} \xB7 saved to ${CONFIG_PATH}`)])
     );
   }
-  process.stderr.write("Usage: yungle auth login | yungle auth status\n");
-  return 2;
+  const scope = await deviceLogin(url, { openBrowser: flags["no-browser"] !== true });
+  await loadCredentials();
+  const me = await client(flags).me().catch(() => null);
+  return out(
+    json,
+    { signedIn: true, scope, workspace: me?.workspace.email ?? null },
+    [
+      success(`Signed in${me?.workspace.email ? ` as ${me.workspace.email}` : ""}`, [o.dim(scope.split(" ").join(", "))]),
+      "",
+      next("yungle send <folder>", "send something")
+    ].join("\n")
+  );
+}
+async function whoami(flags, json) {
+  const resolved = await resolveKey();
+  if (!resolved) throw new NotSignedIn();
+  const me = await client(flags).me();
+  const via = resolved.source.includes("(yungle login)") ? "browser sign-in" : resolved.source === "YUNGLE_API_KEY" ? "YUNGLE_API_KEY" : `key in ${CONFIG_PATH}`;
+  return out(
+    json,
+    { authenticated: true, source: resolved.source, ...me },
+    [
+      `  ${o.bold(me.workspace.email ?? me.workspace.id)}  ${o.dim(me.plan.name ?? "Free plan")}`,
+      `  ${o.dim("Storage")}   ${formatBytes(me.plan.usedBytes)} of ${formatBytes(me.plan.quotaBytes)}`,
+      `  ${o.dim("Signed in")} ${via} ${o.dim(`(${me.key.name})`)}`,
+      `  ${o.dim("May")}       ${me.key.scopes.join(", ")}`,
+      ...me.key.canEmail === false ? [`  ${o.dim("Email")}     ${o.dim("no, links only")}  ${o.dim("(yungle login --key to email recipients)")}`] : []
+    ].join("\n"),
+    me.workspace.email ?? me.workspace.id
+  );
 }
-async function send(paths, flags, json) {
+async function send(pathsIn, flags, json) {
+  let paths = pathsIn;
+  let recipients = listFlag(flags.to);
+  let message = stringFlag(flags.message);
+  let askedFor = false;
   if (paths.length === 0) {
-    process.stderr.write("Nothing to send. Give me one or more files or folders.\n");
-    return 2;
+    if (!interactive(flags)) throw new CliError("Nothing to send.", "yungle send <file or folder> [--to someone@example.com]", "usage", 2);
+    const answers = await askSend();
+    paths = answers.paths;
+    recipients = answers.to;
+    message = answers.message;
+    askedFor = true;
   }
   const api = client(flags);
-  const files = await collectFiles(paths);
-  if (files.length === 0) {
-    process.stderr.write("Those paths contained no files.\n");
-    return 2;
+  if (recipients.length > 0 && (await api.me()).key.canEmail === false) {
+    const hint = "yungle login --key   (an API key can email; or leave out --to)";
+    if (!interactive(flags)) throw new CliError("A browser sign-in can make links but cannot email people.", hint, "insufficient_scope");
+    note("A browser sign-in can make links but cannot email people.");
+    if (!await confirm2("Send it as a link you share yourself?")) throw new CliError("Cancelled; nothing was sent.", hint, "cancelled", 130);
+    recipients = [];
   }
-  const total = files.reduce((n, f) => n + f.size, 0);
-  progress(`Sending ${files.length} file${files.length === 1 ? "" : "s"} \xB7 ${formatBytes(total)}
-`);
+  const files = await collectFiles(paths);
+  if (files.length === 0) throw new CliError("Those paths contain no files (hidden files are skipped).", void 0, "usage", 2);
+  const total = files.reduce((n3, f) => n3 + f.size, 0);
+  const summary = `${plural(files.length, "file")} ${sym.dot} ${formatBytes(total)}${recipients.length ? ` to ${recipients.join(", ")}` : ""}`;
+  if (askedFor && !await confirm2(`Send ${summary}?`)) throw new CliError("Cancelled; nothing was sent.", void 0, "cancelled", 130);
+  heading(`Sending ${summary}`);
   const key = sessionKey(files, "transfer");
   const existing = await findSession(key);
   let created;
   if (existing && existing.kind === "transfer") {
-    progress("  resuming the interrupted upload\n");
-    created = {
-      transfer: { id: existing.targetId },
-      tusEndpoint: existing.tusEndpoint,
-      files: existing.files
-    };
+    note("Resuming the interrupted upload.");
+    created = { transfer: { id: existing.targetId }, tusEndpoint: existing.tusEndpoint, files: existing.files };
   } else {
     const fresh = await api.createTransfer({
       files: toFileInputs(files),
       title: stringFlag(flags.title),
       expiresInDays: numberFlag(flags.expires, "expires")
     });
-    created = { transfer: fresh.transfer, tusEndpoint: fresh.tusEndpoint, files: fresh.files.map((f, i) => ({ ...f, path: files[i].path })) };
-    await saveSession(key, {
-      createdAt: Date.now(),
-      kind: "transfer",
-      targetId: fresh.transfer.id,
-      tusEndpoint: fresh.tusEndpoint,
-      files: created.files
-    });
+    created = { transfer: fresh.transfer, tusEndpoint: fresh.tusEndpoint, files: fresh.files.map((f, i2) => ({ ...f, path: files[i2].path })) };
+    await saveSession(key, { createdAt: Date.now(), kind: "transfer", targetId: fresh.transfer.id, tusEndpoint: fresh.tusEndpoint, files: created.files });
   }
-  await streamAll(files, created, api);
+  await streamAll(files, created);
+  const after = await freshClient(flags, api);
   await dropSession(key);
-  const recipients = listFlag(flags.to);
-  const finalized = await api.finalizeTransfer(created.transfer.id, {
+  const finalized = await after.finalizeTransfer(created.transfer.id, {
     ...recipients.length ? { recipients } : {},
-    ...stringFlag(flags.message) ? { message: stringFlag(flags.message) } : {},
+    ...message ? { message } : {},
     ...stringFlag(flags.password) ? { password: stringFlag(flags.password) } : {},
     ...stringFlag(flags.title) ? { title: stringFlag(flags.title) } : {}
   });
+  const t2 = finalized.transfer;
   return out(
     json,
-    {
-      id: finalized.transfer.id,
-      url: finalized.transfer.url,
-      expiresAt: finalized.transfer.expiresAt,
-      notified: finalized.notified
-    },
+    { id: t2.id, url: t2.url, expiresAt: t2.expiresAt, notified: finalized.notified },
     [
-      finalized.transfer.url,
-      finalized.notified.length ? `Emailed ${finalized.notified.join(", ")}` : "Link only \u2014 nobody was emailed."
-    ].join("\n")
+      success("Sent", [
+        accentOut(t2.url),
+        o.dim(
+          `${finalized.notified.length ? `Emailed ${finalized.notified.join(", ")}` : "Link only; nobody was emailed"} ${sym.dot} expires ${formatDate(t2.expiresAt)}`
+        )
+      ]),
+      "",
+      next(`yungle status ${t2.id.slice(-8)}`, "see who downloaded")
+    ].join("\n"),
+    t2.url
   );
 }
-async function push(paths, flags, json) {
-  const collectionId = stringFlag(flags.collection);
-  if (!collectionId) {
-    process.stderr.write("Which collection? Pass --collection <id>.\n");
-    return 2;
+async function streamAll(files, targets) {
+  const paired = pairWithTargets(files, targets.files);
+  const totalBytes = paired.reduce((n3, { file }) => n3 + file.size, 0);
+  const sentPer = /* @__PURE__ */ new Map();
+  const finished = /* @__PURE__ */ new Set();
+  const started = Date.now();
+  let resumed = false;
+  const render = () => {
+    let sent = 0;
+    for (const v of sentPer.values()) sent += v;
+    drawProgress(progressLine(sent, totalBytes, started, `${finished.size}/${paired.length} files${resumed ? " (resumed)" : ""}`));
+  };
+  const timer = setInterval(render, 250);
+  try {
+    await uploadAll(
+      paired.map(({ file, target }) => ({ path: file.path, target })),
+      targets.tusEndpoint,
+      (p) => {
+        if (p.resumed) resumed = true;
+        sentPer.set(p.id, p.sent);
+        if (p.sent >= p.total) finished.add(p.id);
+      }
+    );
+  } finally {
+    clearInterval(timer);
+    endProgress();
   }
-  if (paths.length === 0) {
-    process.stderr.write("Nothing to push.\n");
-    return 2;
+}
+async function get(positionals, flags, json) {
+  let input = positionals[0];
+  if (!input) {
+    if (!interactive(flags)) throw new CliError("Which link?", "yungle get https://yungle.co/t/\u2026", "usage", 2);
+    input = await askLink();
+  }
+  const apiBase = stringFlag(flags.url) ?? cachedBaseUrl ?? "https://yungle.co/api/v1";
+  const link = parseTransferLink(input, new URL(apiBase).origin);
+  const outDir = resolve3(stringFlag(flags.out) ?? ".");
+  let password2 = stringFlag(flags.password);
+  let manifest;
+  for (; ; ) {
+    try {
+      manifest = await fetchManifest(link, password2, USER_AGENT);
+      break;
+    } catch (err) {
+      const needs = err instanceof ManifestError && (err.code === "password_required" || err.code === "wrong_password");
+      if (!needs || !interactive(flags)) {
+        if (err instanceof ManifestError && err.code === "password_required") {
+          throw new CliError("This transfer is password protected.", `yungle get ${input} --password <password>`, "password_required");
+        }
+        throw err;
+      }
+      if (err.code === "wrong_password") note("That password is not right.");
+      password2 = await askPassword();
+    }
+  }
+  if (manifest.e2ee) {
+    throw new CliError(
+      "This transfer is end-to-end encrypted: only a browser holding the key in the link can open it.",
+      "Open the link in a browser.",
+      "e2ee"
+    );
+  }
+  if (manifest.files.length === 0) return out(json, { saved: [] }, "  This transfer has no files.");
+  const useZip = flags.zip === true && manifest.zipUrl !== null;
+  const jobs = useZip ? [{ url: manifest.zipUrl, name: `yungle-${link.slug}.zip`, size: null }] : dedupeNames(manifest.files.map((f) => safeFileName(f.name))).map((name, i2) => ({ url: manifest.files[i2].downloadUrl, name, size: manifest.files[i2].size }));
+  const total = manifest.files.reduce((n3, f) => n3 + f.size, 0);
+  heading(`Downloading ${plural(manifest.files.length, "file")} ${sym.dot} ${formatBytes(total)}`);
+  let received = 0;
+  const started = Date.now();
+  const saved = [];
+  for (const [i2, job] of jobs.entries()) {
+    const dest = join6(outDir, job.name);
+    await downloadTo(job.url, dest, job.size, USER_AGENT, (n3) => {
+      received += n3;
+      drawProgress(progressLine(Math.min(received, total), total, started, `${i2 + 1}/${jobs.length} files`));
+    });
+    saved.push(dest);
+  }
+  endProgress();
+  return out(
+    json,
+    { saved, message: manifest.message, expiresAt: manifest.expiresAt },
+    success(`Saved ${saved.length === 1 ? shown(saved[0]) : `${plural(saved.length, "file")} to ${shown(outDir)}`}`, manifest.message ? [o.italic(`\u201C${manifest.message}\u201D`)] : []),
+    saved.join("\n")
+  );
+}
+function shown(path) {
+  const rel = relative2(process.cwd(), path);
+  return !rel ? "." : rel.startsWith("..") || isAbsolute(rel) ? path : `./${rel}`;
+}
+async function findTransferId(api, ref) {
+  if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(ref)) return ref;
+  const slug = ref.match(/\/t\/([^/?#]+)/)?.[1] ?? ref;
+  const short = /^[0-9A-HJKMNP-TV-Z]{6,25}$/i.test(ref) ? ref.toUpperCase() : null;
+  for await (const t2 of api.allTransfers()) {
+    if (t2.slug === slug || short && t2.id.endsWith(short)) return t2.id;
   }
+  throw new CliError("None of your transfers matches that.", "yungle transfers", "not_found");
+}
+async function status(positionals, flags, json) {
   const api = client(flags);
-  const files = await collectFiles(paths);
-  if (files.length === 0) {
-    process.stderr.write("Those paths contained no files.\n");
-    return 2;
+  let ref = positionals[0];
+  if (!ref) {
+    if (!interactive(flags)) throw new CliError("Which transfer?", "yungle status <id or link>", "usage", 2);
+    const { transfers: transfers2 } = await api.listTransfers({ limit: 15 });
+    if (transfers2.length === 0) throw new CliError("You have not sent anything yet.", "yungle send <folder>");
+    ref = await pick(
+      "Which transfer?",
+      transfers2.map((t3) => ({ value: t3.id, label: label(t3), hint: `${formatDate(t3.createdAt)} ${sym.dot} ${t3.downloadCount} downloads` }))
+    );
   }
-  const total = files.reduce((n, f) => n + f.size, 0);
-  progress(`Uploading ${files.length} file${files.length === 1 ? "" : "s"} \xB7 ${formatBytes(total)}
-`);
+  const id = await findTransferId(api, ref);
+  const [{ transfer: t2, files, recipients }, receipts] = await Promise.all([api.getTransfer(id), api.transferDownloads(id)]);
+  const live = t2.status === "active" && !(t2.expiresAt && new Date(t2.expiresAt).getTime() < Date.now());
+  const state = live ? accentOut(`${sym.ok} live ${sym.dot} expires ${formatUntil(t2.expiresAt)}`) : o.dim(`${t2.status === "active" ? "expired" : t2.status}`);
+  const lines = [
+    `  ${o.bold(t2.title ?? (files[0] ? `${files[0].name}${files.length > 1 ? ` + ${files.length - 1} more` : ""}` : "Untitled transfer"))}   ${state}`,
+    `  ${accentOut(t2.url)}`,
+    `  ${o.dim(`${plural(files.length, "file")} ${sym.dot} ${formatBytes(t2.sizeBytes)} ${sym.dot} ${receipts.totalDownloads ? `downloaded ${plural(receipts.totalDownloads, "time")}` : "not downloaded yet"}`)}`
+  ];
+  if (recipients.length) {
+    lines.push("", table(
+      recipients.map((r2) => [
+        r2.email,
+        r2.bouncedAt ? o.red("email bounced") : r2.downloaded ? accentOut("downloaded") : r2.opened ? "opened" : r2.notifiedAt ? o.dim("emailed") : o.dim("email queued")
+      ]),
+      { flex: 0, header: ["Recipient", "Status"] }
+    ));
+  }
+  const last = receipts.downloads[0];
+  if (last) lines.push("", `  ${o.dim(`Last download ${formatDate(last.createdAt)}${last.recipientEmail ? ` by ${last.recipientEmail}` : ""}`)}`);
+  return out(json, { transfer: t2, files, recipients, downloads: receipts }, lines.join("\n"), `${t2.url}	${receipts.totalDownloads}`);
+}
+function label(t2) {
+  return t2.title ?? t2.firstFileName ?? "Untitled";
+}
+async function transfers(flags, json) {
+  const { transfers: transfers2 } = await client(flags).listTransfers({ limit: 25 });
+  if (transfers2.length === 0) return out(json, { transfers: transfers2 }, `  No transfers yet.
+
+${next("yungle send <folder>")}`, "");
+  return out(
+    json,
+    { transfers: transfers2 },
+    table(
+      transfers2.map((t2) => [
+        o.dim(t2.id.slice(-8)),
+        label(t2),
+        formatBytes(t2.sizeBytes),
+        t2.downloadCount ? accentOut(`${t2.downloadCount} dl`) : o.dim("0 dl"),
+        t2.status === "active" ? formatUntil(t2.expiresAt) : o.dim(t2.status)
+      ]),
+      // No link column: a link cut to fit cannot be copied. `status` shows it.
+      { flex: 1, header: ["ID", "Title", "Size", "Downloads", "Expires"] }
+    ) + `
+
+${next("yungle status <id>", "who downloaded")}`,
+    transfers2.map((t2) => `${t2.id}	${t2.url}`).join("\n")
+  );
+}
+async function collections(flags, json) {
+  const { collections: collections2 } = await client(flags).listCollections();
+  if (collections2.length === 0) return out(json, { collections: collections2 }, "  No collections yet.", "");
+  return out(
+    json,
+    { collections: collections2 },
+    table(
+      collections2.map((c2) => [o.dim(c2.id), c2.title, plural(c2.fileCount, "file"), formatBytes(c2.sizeBytes)]),
+      { flex: 1, header: ["ID", "Title", "Files", "Size"] }
+    ),
+    collections2.map((c2) => `${c2.id}	${c2.title}`).join("\n")
+  );
+}
+async function contacts(flags, json) {
+  const { contacts: contacts2 } = await client(flags).listContacts();
+  if (contacts2.length === 0) return out(json, { contacts: contacts2 }, "  No contacts yet.", "");
+  return out(
+    json,
+    { contacts: contacts2 },
+    table(
+      contacts2.map((c2) => [[c2.firstName, c2.lastName].filter(Boolean).join(" ") || o.dim("\u2014"), c2.email, o.dim(c2.company ?? "")]),
+      { flex: 0, header: ["Name", "Email", "Company"] }
+    ),
+    contacts2.map((c2) => c2.email).join("\n")
+  );
+}
+async function revoke(positionals, flags, json) {
+  const ref = positionals[0];
+  if (!ref) throw new CliError("Which transfer?", "yungle revoke <id or link>", "usage", 2);
+  const api = client(flags);
+  const id = await findTransferId(api, ref);
+  if (interactive(flags) && !await confirm2("Revoke it? The link stops working and the files are destroyed. This cannot be undone.")) {
+    throw new CliError("Cancelled; nothing changed.", void 0, "cancelled", 130);
+  }
+  const { transfer } = await api.revokeTransfer(id);
+  return out(json, { id: transfer.id, status: transfer.status }, success("Revoked", [o.dim("The link no longer works and the files are gone.")]), transfer.id);
+}
+async function push(paths, flags, json) {
+  const collectionId = stringFlag(flags.collection);
+  if (!collectionId) throw new CliError("Which collection?", "yungle collections   then   yungle push <paths> --collection <id>", "usage", 2);
+  if (paths.length === 0) throw new CliError("Nothing to upload.", `yungle push <paths> --collection ${collectionId}`, "usage", 2);
+  const api = client(flags);
+  const files = await collectFiles(paths);
+  if (files.length === 0) throw new CliError("Those paths contain no files (hidden files are skipped).", void 0, "usage", 2);
+  heading(`Uploading ${plural(files.length, "file")} ${sym.dot} ${formatBytes(files.reduce((n3, f) => n3 + f.size, 0))}`);
   const key = sessionKey(files, `collection:${collectionId}:${stringFlag(flags.folder) ?? ""}`);
   const existing = await findSession(key);
   let targets;
   if (existing && existing.kind === "collection") {
-    progress("  resuming the interrupted upload\n");
+    note("Resuming the interrupted upload.");
     targets = { tusEndpoint: existing.tusEndpoint, files: existing.files };
   } else {
-    const fresh = await api.addCollectionFiles(
-      collectionId,
-      toFileInputs(files),
-      stringFlag(flags.folder) ?? null
-    );
-    targets = {
-      tusEndpoint: fresh.tusEndpoint,
-      files: fresh.files.map((f, i) => ({ ...f, path: files[i].path }))
-    };
-    await saveSession(key, {
-      createdAt: Date.now(),
-      kind: "collection",
-      targetId: collectionId,
-      tusEndpoint: fresh.tusEndpoint,
-      files: targets.files
-    });
+    const fresh = await api.addCollectionFiles(collectionId, toFileInputs(files), stringFlag(flags.folder) ?? null);
+    targets = { tusEndpoint: fresh.tusEndpoint, files: fresh.files.map((f, i2) => ({ ...f, path: files[i2].path })) };
+    await saveSession(key, { createdAt: Date.now(), kind: "collection", targetId: collectionId, tusEndpoint: fresh.tusEndpoint, files: targets.files });
   }
-  await streamAll(files, targets, api);
+  await streamAll(files, targets);
   await dropSession(key);
-  const collection = await api.getCollection(collectionId);
+  const { collection } = await (await freshClient(flags, api)).getCollection(collectionId);
   return out(
     json,
-    { collection: collection.collection.id, uploaded: files.length, url: collection.collection.url },
-    `Uploaded ${files.length} file${files.length === 1 ? "" : "s"} to \u201C${collection.collection.title}\u201D.
-${collection.collection.url ?? ""}`
+    { collection: collection.id, uploaded: files.length, url: collection.url },
+    success(`Uploaded ${plural(files.length, "file")} to \u201C${collection.title}\u201D`, collection.url ? [accentOut(collection.url)] : []),
+    collection.url ?? collection.id
   );
 }
-async function list(positionals, flags, json) {
-  const what = positionals[0] ?? "transfers";
+async function watch(positionals, flags, json) {
+  const dir = positionals[0] ? resolve3(positionals[0]) : null;
+  const collectionId = stringFlag(flags.collection);
+  if (!dir || !collectionId) throw new CliError("Which folder, into which collection?", "yungle watch <folder> --collection <id>", "usage", 2);
+  const interval = (numberFlag(flags.interval, "interval") ?? 10) * 1e3;
   const api = client(flags);
-  if (what === "transfers") {
-    const { transfers } = await api.listTransfers();
-    return out(
-      json,
-      { transfers },
-      transfers.length === 0 ? "No transfers yet." : transfers.map(
-        (t) => `${t.id}  ${pad(t.title ?? t.firstFileName ?? "(untitled)", 32)} ${pad(formatBytes(t.sizeBytes), 9)} ${t.downloadCount} dl  ${t.url}`
-      ).join("\n")
-    );
+  const { collection } = await api.getCollection(collectionId);
+  const uploaded = await loadUploaded(dir, collectionId);
+  let lastSeen = /* @__PURE__ */ new Set();
+  if (flags.existing !== true) {
+    for (const f of await collectFiles([dir])) uploaded.add(fingerprint(f));
+    await saveUploaded(dir, collectionId, uploaded);
   }
-  if (what === "collections") {
-    const { collections } = await api.listCollections();
-    return out(
-      json,
-      { collections },
-      collections.length === 0 ? "No collections yet." : collections.map(
-        (c) => `${c.id}  ${pad(c.title, 32)} ${pad(`${c.fileCount} files`, 12)} ${formatBytes(c.sizeBytes)}`
-      ).join("\n")
-    );
+  if (!json) heading(`Watching ${dir} ${sym.arrow} \u201C${collection.title}\u201D. New files go up once they stop changing. Ctrl-C to stop.`);
+  let stop = false;
+  process.once("SIGINT", () => {
+    stop = true;
+  });
+  while (!stop) {
+    const current = await collectFiles([dir]);
+    const { ready, seen } = planTick(current, lastSeen, uploaded);
+    lastSeen = seen;
+    if (ready.length > 0) {
+      const target = await (await freshClient(flags, api)).addCollectionFiles(collectionId, toFileInputs(ready), stringFlag(flags.folder) ?? null);
+      await streamAll(ready, target);
+      for (const f of ready) {
+        uploaded.add(fingerprint(f));
+        if (json) process.stdout.write(`${JSON.stringify({ uploaded: f.path, size: f.size })}
+`);
+        else process.stdout.write(`  ${accentOut(sym.ok)} ${join6(f.relativeDir, f.name)} ${o.dim(formatBytes(f.size))}
+`);
+      }
+      await saveUploaded(dir, collectionId, uploaded);
+    }
+    for (let waited = 0; waited < interval && !stop; waited += 250) await new Promise((r2) => setTimeout(r2, 250));
+  }
+  if (!json) process.stderr.write(`
+  ${e.dim("Stopped.")}
+`);
+  return 0;
+}
+var PLACES = {
+  plan: "/dashboard/settings/plan",
+  keys: "/dashboard/settings/api",
+  webhooks: "/dashboard/settings/webhooks",
+  usage: "/dashboard/settings/usage",
+  developers: "/dashboard/developers"
+};
+async function open(positionals, flags, json) {
+  const origin = originOf(stringFlag(flags.url) ?? cachedBaseUrl);
+  const what = positionals[0];
+  let path = "/dashboard";
+  if (what && PLACES[what]) path = PLACES[what];
+  else if (what) {
+    const api = client(flags);
+    const id = await findTransferId(api, what);
+    const { transfer } = await api.getTransfer(id);
+    path = `/dashboard/transfers/${transfer.slug}`;
   }
-  if (what === "contacts") {
-    const { contacts } = await api.listContacts();
+  const url = `${origin}${path}`;
+  if (!json) openBrowser(url);
+  return out(json, { url }, `  ${o.dim("Opened")} ${accentOut(url)}`, url);
+}
+async function webhooks(positionals, flags, json) {
+  const api = client(flags);
+  const sub = positionals[0] ?? "ls";
+  if (sub === "ls") {
+    const { webhooks: webhooks2 } = await api.listWebhooks();
+    if (webhooks2.length === 0) return out(json, { webhooks: webhooks2 }, `  No webhook endpoints.
+
+${next("yungle open webhooks")}`, "");
     return out(
       json,
-      { contacts },
-      contacts.length === 0 ? "No contacts yet." : contacts.map((c) => `${c.id}  ${pad([c.firstName, c.lastName].filter(Boolean).join(" ") || "\u2014", 24)} ${c.email}`).join("\n")
+      { webhooks: webhooks2 },
+      table(
+        webhooks2.map((w) => [o.dim(w.id.slice(-8)), w.enabled ? accentOut("active") : o.dim("paused"), w.url ?? o.dim("(pull)"), o.dim(w.events.join(", "))]),
+        { flex: 2, header: ["ID", "State", "URL", "Events"] }
+      ),
+      webhooks2.map((w) => `${w.id}	${w.url ?? ""}`).join("\n")
     );
   }
-  process.stderr.write("Usage: yungle ls transfers|collections|contacts\n");
-  return 2;
-}
-async function remove(positionals, flags, json) {
-  const [what, id] = positionals;
-  if (what !== "transfer" || !id) {
-    process.stderr.write("Usage: yungle rm transfer <id>\n");
-    return 2;
+  if (sub !== "listen") throw new CliError(`Unknown: yungle webhooks ${sub}.`, "yungle webhooks ls   or   yungle webhooks listen", "usage", 2);
+  const forwardTo = stringFlag(flags["forward-to"]);
+  const { id, secret } = await ensureListenEndpoint(api);
+  let cursor3 = await cursorAtNow(api, id);
+  if (!json) {
+    heading(`Listening for events${forwardTo ? ` ${sym.arrow} ${forwardTo}` : ""}. Ctrl-C to stop.`);
+    if (forwardTo) note(`Signing secret for this session: ${secret}`);
   }
-  const { transfer } = await client(flags).revokeTransfer(id);
-  return out(
-    json,
-    { id: transfer.id, status: transfer.status },
-    `Revoked. The link no longer works and the content is unrecoverable.`
-  );
+  for (; ; ) {
+    const page = await api.listWebhookEvents(id, { limit: 100, cursor: cursor3 });
+    for (const { deliveryId, ...event } of page.events) {
+      const body = JSON.stringify(event);
+      if (json) process.stdout.write(`${body}
+`);
+      else process.stdout.write(`  ${o.dim(event.createdAt.slice(11, 19))}  ${accentOut(event.type.padEnd(26))}${describeEvent(event)}
+`);
+      if (forwardTo) {
+        const res = await fetch(forwardTo, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT,
+            "Yungle-Event-Id": event.id,
+            "Yungle-Event-Type": event.type,
+            "Yungle-Delivery-Id": deliveryId,
+            "Yungle-Signature": signForForward(secret, body)
+          },
+          body
+        }).catch((err) => ({ ok: false, status: err.message }));
+        if (!json) process.stderr.write(`            ${e.dim(`${sym.arrow} ${forwardTo} ${"status" in res ? res.status : ""}`)}
+`);
+      }
+    }
+    cursor3 = page.nextCursor ?? cursor3;
+    if (!page.hasMore) await new Promise((r2) => setTimeout(r2, 2e3));
+  }
+}
+async function freshClient(flags, current) {
+  if (process.env.YUNGLE_API_KEY?.trim()) return current;
+  const resolved = await resolveKey();
+  if (!resolved || resolved.apiKey === cachedKey) return current;
+  cachedKey = resolved.apiKey;
+  return client(flags);
 }
 function client(flags) {
-  const apiKey = process.env.YUNGLE_API_KEY?.trim() ?? cachedKey;
+  const apiKey = process.env.YUNGLE_API_KEY?.trim() || cachedKey;
   if (!apiKey) throw new NotSignedIn();
-  return new YungleClient({ apiKey, baseUrl: stringFlag(flags.url) ?? cachedBaseUrl });
+  return new YungleClient({ apiKey, baseUrl: stringFlag(flags.url) ?? cachedBaseUrl, userAgent: USER_AGENT });
 }
-var NotSignedIn = class extends Error {
-  constructor() {
-    super("Not signed in. Run `yungle auth login`, or set YUNGLE_API_KEY.");
-    this.name = "NotSignedIn";
-  }
-};
 var cachedKey;
 var cachedBaseUrl;
 async function loadCredentials() {
@@ -795,69 +3451,9 @@ async function loadCredentials() {
   cachedKey = resolved?.apiKey;
   cachedBaseUrl = resolved?.baseUrl;
 }
-async function streamAll(files, targets, _api) {
-  const paired = pairWithTargets(files, targets.files);
-  const totalBytes = paired.reduce((n, { file }) => n + file.size, 0);
-  const sentPer = /* @__PURE__ */ new Map();
-  const finished = /* @__PURE__ */ new Set();
-  const started = Date.now();
-  let anyResumed = false;
-  const render = () => {
-    let sent = 0;
-    for (const value of sentPer.values()) sent += value;
-    const pct = totalBytes ? Math.floor(sent / totalBytes * 100) : 100;
-    const rate = sent / Math.max(1, (Date.now() - started) / 1e3);
-    progress(
-      `\r  ${String(pct).padStart(3)}%  ${pad(`${formatBytes(sent)} of ${formatBytes(totalBytes)}`, 22)}${pad(`${formatBytes(rate)}/s`, 12)}${finished.size}/${paired.length} files${anyResumed ? "  (resumed)" : ""}   `
-    );
-  };
-  await uploadAll(
-    paired.map(({ file, target }) => ({ path: file.path, target })),
-    targets.tusEndpoint,
-    (p) => {
-      if (p.resumed) anyResumed = true;
-      sentPer.set(p.id, p.sent);
-      if (p.sent >= p.total) finished.add(p.id);
-      render();
-    }
-  );
-  render();
-  progress("\n");
-}
-function progress(text) {
-  if (process.stderr.isTTY) process.stderr.write(text);
-}
-function pad(text, width) {
-  return text.length > width ? `${text.slice(0, width - 1)}\u2026` : text.padEnd(width);
-}
-function out(json, data, human, code = 0) {
-  process.stdout.write(json ? `${JSON.stringify(data, null, 2)}
-` : `${human}
-`);
-  return code;
-}
-function fail(err, json) {
-  if (err instanceof YungleApiError) {
-    if (json) {
-      process.stdout.write(`${JSON.stringify({ error: { code: err.code, message: err.message, details: err.details } }, null, 2)}
-`);
-    } else {
-      process.stderr.write(`${err.message}
-`);
-      if (err.code === "upgrade_required") {
-        process.stderr.write("See https://yungle.co/dashboard/settings/plan\n");
-      }
-    }
-    return 1;
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  if (json) process.stdout.write(`${JSON.stringify({ error: { code: "cli_error", message } }, null, 2)}
-`);
-  else process.stderr.write(`${message}
-`);
-  return 1;
-}
 export {
+  CLI_VERSION,
+  HELP,
   loadCredentials,
   main
 };