cutsio 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1375 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+import process2 from "node:process";
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// src/secrets.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var SERVICE = "cutsio-cli";
+var ACCOUNT = "api-key";
+function keychainAvailable() {
+  return process.platform === "darwin";
+}
+async function getStoredKey() {
+  if (!keychainAvailable()) return null;
+  try {
+    const { stdout: stdout3 } = await run("security", [
+      "find-generic-password",
+      "-a",
+      ACCOUNT,
+      "-s",
+      SERVICE,
+      "-w"
+    ]);
+    const value = stdout3.trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+async function setStoredKey(key) {
+  await run("security", [
+    "add-generic-password",
+    "-U",
+    "-a",
+    ACCOUNT,
+    "-s",
+    SERVICE,
+    "-w",
+    key
+  ]);
+}
+async function clearStoredKey() {
+  if (!keychainAvailable()) return;
+  try {
+    await run("security", ["delete-generic-password", "-a", ACCOUNT, "-s", SERVICE]);
+  } catch {
+  }
+}
+
+// src/config.ts
+var DEFAULT_API_URL = "https://studio.cutsio.com";
+function configDir() {
+  return join(homedir(), ".cutsio");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function keyStorageDescription() {
+  return keychainAvailable() ? "macOS Keychain" : `${configPath()} (mode 600)`;
+}
+function readConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.apiUrl !== "string") return null;
+    return {
+      apiUrl: parsed.apiUrl,
+      ...typeof parsed.apiKey === "string" && parsed.apiKey.length > 0 ? { apiKey: parsed.apiKey } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const payload = config.apiKey ? { apiUrl: config.apiUrl, apiKey: config.apiKey } : { apiUrl: config.apiUrl };
+  writeFileSync(path, JSON.stringify(payload, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+}
+function resolveApiUrl(flag) {
+  return flag || process.env.CUTSIO_API_URL || readConfig()?.apiUrl || DEFAULT_API_URL;
+}
+async function resolveApiKey() {
+  const fromEnv = process.env.CUTSIO_API_KEY;
+  if (fromEnv && fromEnv.length > 0) return fromEnv;
+  const stored = await getStoredKey();
+  if (stored) return stored;
+  const config = readConfig();
+  const legacy = config?.apiKey;
+  if (!legacy) return null;
+  if (keychainAvailable()) {
+    try {
+      await setStoredKey(legacy);
+      writeConfig({ apiUrl: config?.apiUrl ?? DEFAULT_API_URL });
+    } catch {
+    }
+  }
+  return legacy;
+}
+async function saveCredentials(apiUrl, apiKey) {
+  if (keychainAvailable()) {
+    await setStoredKey(apiKey);
+    writeConfig({ apiUrl });
+    return;
+  }
+  writeConfig({ apiUrl, apiKey });
+}
+async function clearCredentials() {
+  const stored = await getStoredKey();
+  const config = readConfig();
+  const hadFileKey = Boolean(config?.apiKey);
+  await clearStoredKey();
+  if (config) {
+    writeConfig({ apiUrl: config.apiUrl });
+  }
+  return Boolean(stored) || hadFileKey;
+}
+
+// src/core/client.ts
+var ApiError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+var CutsioClient = class {
+  base;
+  apiKey;
+  constructor(apiUrl, apiKey) {
+    this.base = apiUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+  async whoami() {
+    return await this.request("/api/desktop/whoami");
+  }
+  async fetchManifest() {
+    let orgId = "";
+    let folders = [];
+    let collections = [];
+    const videos = [];
+    let cursor = null;
+    for (; ; ) {
+      const params = new URLSearchParams({ limit: "100" });
+      if (cursor !== null) params.set("cursor", String(cursor));
+      const page = await this.request(
+        `/api/desktop/manifest?${params.toString()}`
+      );
+      orgId = page.orgId;
+      folders = page.folders;
+      collections = page.collections ?? [];
+      videos.push(...page.videos);
+      if (!page.hasMore || page.nextCursor === null) break;
+      cursor = page.nextCursor;
+    }
+    return { orgId, folders, collections, videos };
+  }
+  async prepare(videoIds) {
+    const data = await this.request("/api/desktop/prepare", {
+      method: "POST",
+      body: JSON.stringify({ videoIds })
+    });
+    return Array.isArray(data.results) ? data.results : [];
+  }
+  async request(path, init) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      ...init?.body ? { "Content-Type": "application/json" } : {},
+      ...init?.headers ?? {}
+    };
+    const response = await fetch(`${this.base}${path}`, { ...init, headers });
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      try {
+        const body = await response.json();
+        if (typeof body.error === "string") message = body.error;
+      } catch {
+      }
+      throw new ApiError(message, response.status);
+    }
+    return response.json();
+  }
+};
+
+// src/core/paths.ts
+function sanitizeSegment(value) {
+  const cleaned = value.replace(/[/\\?%*:|"<>]/g, "-").replace(/\s+/g, " ").replace(/^[.\s]+|[.\s]+$/g, "").slice(0, 80).trim();
+  return cleaned.length > 0 ? cleaned : "untitled";
+}
+function buildFolderPaths(folders) {
+  const byId = new Map(folders.map((folder) => [folder.id, folder]));
+  const memo = /* @__PURE__ */ new Map();
+  const resolve = (id, seen) => {
+    const cached = memo.get(id);
+    if (cached !== void 0) return cached;
+    const folder = byId.get(id);
+    if (!folder || seen.has(id)) return "";
+    seen.add(id);
+    const parent = folder.parent_id ? resolve(folder.parent_id, seen) : "";
+    const path = parent ? `${parent}/${sanitizeSegment(folder.name)}` : sanitizeSegment(folder.name);
+    memo.set(id, path);
+    return path;
+  };
+  for (const folder of folders) resolve(folder.id, /* @__PURE__ */ new Set());
+  return memo;
+}
+function videoRelativePath(video, folderPaths) {
+  const directory = video.folder_id ? folderPaths.get(video.folder_id) ?? "" : "";
+  const name = `${sanitizeSegment(video.title)} [${video.id.slice(0, 8)}].mp4`;
+  return directory ? `${directory}/${name}` : name;
+}
+
+// src/core/selection.ts
+function isEmptySelection(selection) {
+  return !selection.all && !selection.unfiled && selection.folderRefs.length === 0 && selection.collectionRefs.length === 0 && selection.videoIds.length === 0 && selection.searchTerms.length === 0;
+}
+function folderSubtreeIds(manifest) {
+  const children = /* @__PURE__ */ new Map();
+  for (const folder of manifest.folders) {
+    if (!folder.parent_id) continue;
+    const list = children.get(folder.parent_id) ?? [];
+    list.push(folder.id);
+    children.set(folder.parent_id, list);
+  }
+  const subtrees = /* @__PURE__ */ new Map();
+  for (const folder of manifest.folders) {
+    const ids = /* @__PURE__ */ new Set([folder.id]);
+    const stack = [folder.id];
+    for (; ; ) {
+      const id = stack.pop();
+      if (id === void 0) break;
+      for (const child of children.get(id) ?? []) {
+        if (ids.has(child)) continue;
+        ids.add(child);
+        stack.push(child);
+      }
+    }
+    subtrees.set(folder.id, ids);
+  }
+  return subtrees;
+}
+function folderVideoCounts(manifest) {
+  const subtrees = folderSubtreeIds(manifest);
+  const direct = /* @__PURE__ */ new Map();
+  const subtree = /* @__PURE__ */ new Map();
+  for (const video of manifest.videos) {
+    if (!video.folder_id) continue;
+    direct.set(video.folder_id, (direct.get(video.folder_id) ?? 0) + 1);
+  }
+  for (const [folderId, ids] of subtrees) {
+    let count = 0;
+    for (const video of manifest.videos) {
+      if (video.folder_id && ids.has(video.folder_id)) count += 1;
+    }
+    subtree.set(folderId, count);
+  }
+  return { direct, subtree };
+}
+function resolveSelection(manifest, selection) {
+  if (selection.all) return { videos: manifest.videos, errors: [] };
+  const errors = [];
+  const selected = /* @__PURE__ */ new Map();
+  const folderPaths = buildFolderPaths(manifest.folders);
+  const pathIndex = /* @__PURE__ */ new Map();
+  for (const [id, path] of folderPaths) pathIndex.set(path.toLowerCase(), id);
+  const nameIndex = /* @__PURE__ */ new Map();
+  for (const folder of manifest.folders) {
+    const key = folder.name.toLowerCase();
+    nameIndex.set(key, [...nameIndex.get(key) ?? [], folder.id]);
+  }
+  const resolveFolder = (ref) => {
+    if (folderPaths.has(ref)) return ref;
+    const byPath = pathIndex.get(ref.toLowerCase());
+    if (byPath) return byPath;
+    const byName = nameIndex.get(ref.toLowerCase());
+    if (byName && byName.length === 1) return byName[0] ?? null;
+    return null;
+  };
+  const subtrees = folderSubtreeIds(manifest);
+  const folderIds = /* @__PURE__ */ new Set();
+  for (const ref of selection.folderRefs) {
+    const id = resolveFolder(ref);
+    if (!id) {
+      const byName = nameIndex.get(ref.toLowerCase());
+      errors.push(
+        byName && byName.length > 1 ? `Folder name is ambiguous: ${ref} (use the path or id)` : `Folder not found: ${ref}`
+      );
+      continue;
+    }
+    for (const descendant of subtrees.get(id) ?? [id]) folderIds.add(descendant);
+  }
+  if (folderIds.size > 0) {
+    for (const video of manifest.videos) {
+      if (video.folder_id && folderIds.has(video.folder_id)) selected.set(video.id, video);
+    }
+  }
+  const collectionIds = /* @__PURE__ */ new Set();
+  for (const ref of selection.collectionRefs) {
+    const matches = manifest.collections.filter(
+      (collection) => collection.id === ref || collection.title.toLowerCase() === ref.toLowerCase()
+    );
+    if (matches.length === 0) {
+      errors.push(`Collection not found: ${ref}`);
+      continue;
+    }
+    for (const collection of matches) collectionIds.add(collection.id);
+  }
+  if (collectionIds.size > 0) {
+    for (const video of manifest.videos) {
+      if (video.collection_id && collectionIds.has(video.collection_id)) selected.set(video.id, video);
+    }
+  }
+  const byId = new Map(manifest.videos.map((video) => [video.id, video]));
+  for (const id of selection.videoIds) {
+    const video = byId.get(id);
+    if (!video) {
+      errors.push(`Video not found: ${id}`);
+      continue;
+    }
+    selected.set(video.id, video);
+  }
+  if (selection.unfiled) {
+    for (const video of manifest.videos) {
+      if (!video.folder_id) selected.set(video.id, video);
+    }
+  }
+  for (const term of selection.searchTerms) {
+    const needle = term.toLowerCase();
+    let matches = 0;
+    for (const video of manifest.videos) {
+      if (!video.title.toLowerCase().includes(needle)) continue;
+      selected.set(video.id, video);
+      matches += 1;
+    }
+    if (matches === 0) errors.push(`No video titles match: ${term}`);
+  }
+  return { videos: [...selected.values()], errors };
+}
+
+// src/commands/list.ts
+async function listCommand(flags) {
+  const apiKey = await resolveApiKey();
+  if (!apiKey) {
+    console.error("No API key. Run `cutsio login` or set CUTSIO_API_KEY.");
+    return 1;
+  }
+  const client = new CutsioClient(resolveApiUrl(flags.url), apiKey);
+  let manifest;
+  try {
+    manifest = await client.fetchManifest();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (flags.json === "true") {
+    console.log(JSON.stringify(manifest, null, 2));
+    return 0;
+  }
+  const search = (flags.search ?? "").trim().toLowerCase();
+  if (search) {
+    const matches = manifest.videos.filter((video) => video.title.toLowerCase().includes(search));
+    console.log(`Title matches (${matches.length}) for "${flags.search}":`);
+    if (matches.length === 0) console.log("  (none)");
+    for (const video of matches) {
+      console.log(`  [${video.id}]  ${video.status.padEnd(10)}  ${video.title}`);
+    }
+    return 0;
+  }
+  const folderPaths = buildFolderPaths(manifest.folders);
+  const { subtree } = folderVideoCounts(manifest);
+  console.log(`Collections (${manifest.collections.length}) \u2014 select with --collection <name|id>`);
+  if (manifest.collections.length === 0) console.log("  (none)");
+  for (const collection of manifest.collections) {
+    const count = manifest.videos.filter((video) => video.collection_id === collection.id).length;
+    console.log(`  ${pad(count)}  ${collection.title}  [${collection.id}]`);
+  }
+  console.log(`
+Folders (${manifest.folders.length}) \u2014 select with --folder <path|id>`);
+  if (manifest.folders.length === 0) console.log("  (none)");
+  const rows = [...folderPaths.entries()].sort((a, b) => a[1].localeCompare(b[1]));
+  for (const [id, path] of rows) {
+    console.log(`  ${pad(subtree.get(id) ?? 0)}  ${path}/  [${id}]`);
+  }
+  const unfiled = manifest.videos.filter((video) => !video.folder_id).length;
+  if (unfiled > 0) console.log(`  ${pad(unfiled)}  (no folder)`);
+  if (flags.videos === "true") {
+    console.log(`
+Videos (${manifest.videos.length}) \u2014 select with --video <id>`);
+    for (const video of manifest.videos) {
+      console.log(`  [${video.id}]  ${video.status.padEnd(10)}  ${video.title}`);
+    }
+  }
+  return 0;
+}
+function pad(count) {
+  return `${count} video${count === 1 ? " " : "s"}`.padStart(9);
+}
+
+// src/commands/login.ts
+import { stdin, stdout } from "node:process";
+var MAX_ATTEMPTS = 3;
+var KEY_PATTERN = /^ak_[A-Za-z0-9]{20,}$/;
+async function loginCommand(flags) {
+  const apiUrl = resolveApiUrl(flags.url);
+  const interactiveTty = Boolean(stdin.isTTY) && typeof stdin.setRawMode === "function";
+  console.log(`Signing in to ${apiUrl}`);
+  console.log("Create an organization API key in Cutsio (Account or Organization \u2192 API Keys).");
+  console.log("The secret is shown once, when you create the key.\n");
+  const pipedAnswers = interactiveTty ? null : await readPipedAnswers();
+  let pipedIndex = 0;
+  let fromFlag = flags.key;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    let raw;
+    if (fromFlag !== void 0) {
+      raw = fromFlag;
+      fromFlag = void 0;
+    } else if (pipedAnswers) {
+      const next = pipedAnswers[pipedIndex];
+      pipedIndex += 1;
+      if (next === void 0) break;
+      raw = next;
+    } else {
+      raw = await promptSecret("Paste API key: ");
+    }
+    const apiKey = normalizeKey(raw);
+    if (!apiKey) {
+      console.error("No API key entered.\n");
+      continue;
+    }
+    if (!KEY_PATTERN.test(apiKey)) {
+      console.error('That does not look like a Cutsio API key (expected something starting with "ak_").\n');
+      continue;
+    }
+    try {
+      const who = await new CutsioClient(apiUrl, apiKey).whoami();
+      if (!who.orgId) {
+        console.error("That key is not attached to an organization. Create an organization API key.\n");
+        continue;
+      }
+      await saveCredentials(apiUrl, apiKey);
+      console.log(`
+Saved. Organization ${who.orgId}${who.name ? ` (key "${who.name}")` : ""}.`);
+      console.log(`Key stored in ${keyStorageDescription()}.
+`);
+      console.log("Next:");
+      console.log("  cutsio list");
+      console.log("  cutsio sync --out ~/Cutsio --interactive");
+      return 0;
+    } catch (error) {
+      console.error(`${explain(error, apiUrl)}
+`);
+    }
+  }
+  console.error("Could not authenticate. Nothing was saved.");
+  return 1;
+}
+async function readPipedAnswers() {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8").split(/\r?\n/);
+}
+function normalizeKey(raw) {
+  let value = raw.trim();
+  const quoted = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'");
+  if (quoted && value.length > 1) {
+    value = value.slice(1, -1).trim();
+  }
+  return value.replace(/^bearer\s+/i, "").trim();
+}
+function explain(error, apiUrl) {
+  if (error instanceof ApiError) {
+    if (error.status === 401) {
+      return [
+        "That key was rejected.",
+        "  - If you copied it from the key list, that is the key ID, not the secret.",
+        "    The secret is only shown once at creation \u2014 create a new key.",
+        `  - If it was created in a different environment than ${apiUrl}, it will not exist here.`
+      ].join("\n");
+    }
+    if (error.status === 403) {
+      return `That key authenticated but has no organization. ${error.message}`;
+    }
+    return `The server rejected the key (HTTP ${error.status}): ${error.message}`;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return `Could not reach ${apiUrl}: ${message}`;
+}
+async function promptSecret(question) {
+  stdout.write(question);
+  stdin.setRawMode?.(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  return new Promise((resolve) => {
+    let value = "";
+    const finish = () => {
+      stdin.setRawMode?.(false);
+      stdin.pause();
+      stdin.off("data", onData);
+      stdout.write("\n");
+      resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\r" || char === "\n" || char === "") {
+          finish();
+          return;
+        }
+        if (char === "") {
+          stdin.setRawMode?.(false);
+          stdout.write("\n");
+          process.exit(130);
+        }
+        if (char === "\x7F" || char === "\b") {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            stdout.write("\b \b");
+          }
+          continue;
+        }
+        if (char < " ") continue;
+        value += char;
+        stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/commands/logout.ts
+async function logoutCommand() {
+  const hadCredentials = await clearCredentials();
+  if (!hadCredentials) {
+    console.log("No saved credentials.");
+  } else {
+    console.log(`Signed out. The API key was removed from ${keyStorageDescription()}.`);
+  }
+  if (process.env.CUTSIO_API_KEY) {
+    console.log("CUTSIO_API_KEY is still set in this shell \u2014 unset it to finish signing out.");
+  }
+  return 0;
+}
+
+// src/core/sync.ts
+import { existsSync as existsSync4, statSync as statSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/core/download.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync, statSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function partPathFor(destPath) {
+  return `${destPath}.part`;
+}
+async function downloadResumable(url, destPath, onProgress) {
+  mkdirSync2(dirname2(destPath), { recursive: true });
+  const part = partPathFor(destPath);
+  const resumedFrom = existsSync2(part) ? statSync(part).size : 0;
+  const total = await remoteSize(url);
+  let timer = null;
+  if (onProgress) {
+    onProgress(resumedFrom, total);
+    timer = setInterval(() => {
+      try {
+        onProgress(statSync(part).size, total);
+      } catch {
+      }
+    }, 200);
+  }
+  let code;
+  let stderr;
+  try {
+    ({ code, stderr } = await runCurl([
+      "-sS",
+      "--fail",
+      "--location",
+      "--retry",
+      "5",
+      "--retry-delay",
+      "2",
+      "--retry-all-errors",
+      "--connect-timeout",
+      "30",
+      "-C",
+      "-",
+      "-o",
+      part,
+      url
+    ]));
+  } finally {
+    if (timer) clearInterval(timer);
+  }
+  if (code === 0) {
+    const bytes = statSync(part).size;
+    onProgress?.(bytes, total ?? bytes);
+    renameSync(part, destPath);
+    return { ok: true, bytes: statSync(destPath).size, resumedFrom };
+  }
+  if (total !== null && existsSync2(part) && statSync(part).size === total) {
+    onProgress?.(total, total);
+    renameSync(part, destPath);
+    return { ok: true, bytes: total, resumedFrom };
+  }
+  const lastLine = stderr.trim().split("\n").filter(Boolean).at(-1);
+  return { ok: false, error: `curl exited ${code}${lastLine ? `: ${lastLine}` : ""}` };
+}
+function runCurl(args) {
+  return new Promise((resolve) => {
+    const child = spawn("curl", args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => resolve({ code: -1, stderr: error.message }));
+    child.on("close", (code) => resolve({ code: code ?? -1, stderr }));
+  });
+}
+async function remoteSize(url) {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    if (!response.ok) return null;
+    const header = response.headers.get("content-length");
+    const value = header ? Number(header) : Number.NaN;
+    return Number.isFinite(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/state.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+var STATE_FILE = ".cutsio-state.json";
+var StateOrgMismatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StateOrgMismatchError";
+  }
+};
+function emptyState(orgId) {
+  return { schema: 1, orgId, updatedAt: Date.now(), videos: {} };
+}
+function loadState(path, orgId) {
+  if (!existsSync3(path)) return emptyState(orgId);
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (parsed.schema !== 1 || typeof parsed.videos !== "object" || parsed.videos === null) {
+      return emptyState(orgId);
+    }
+    if (parsed.orgId && parsed.orgId !== orgId) {
+      throw new StateOrgMismatchError(
+        `This directory is already syncing ${parsed.orgId}. Use a different --out directory for ${orgId}.`
+      );
+    }
+    return { schema: 1, orgId, updatedAt: Date.now(), videos: parsed.videos };
+  } catch (error) {
+    if (error instanceof StateOrgMismatchError) throw error;
+    return emptyState(orgId);
+  }
+}
+function saveState(path, state) {
+  mkdirSync3(dirname3(path), { recursive: true });
+  state.updatedAt = Date.now();
+  const temp = `${path}.tmp`;
+  writeFileSync2(temp, JSON.stringify(state, null, 2));
+  renameSync2(temp, path);
+}
+
+// src/core/sync.ts
+var PREPARE_BATCH_SIZE = 50;
+var INITIAL_PREPARE_DELAY_MS = 3e3;
+var MAX_PREPARE_DELAY_MS = 3e4;
+async function sync(client, options) {
+  const { onEvent, outDir } = options;
+  const manifest = options.manifest ?? await client.fetchManifest();
+  const resolved = resolveSelection(manifest, options.selection);
+  if (resolved.errors.length > 0) {
+    throw new Error(`Selection problems:
+  ${resolved.errors.join("\n  ")}`);
+  }
+  if (resolved.videos.length === 0) {
+    throw new Error("Selection matched no videos.");
+  }
+  const folderPaths = buildFolderPaths(manifest.folders);
+  const statePath = join2(outDir, STATE_FILE);
+  const state = loadState(statePath, manifest.orgId);
+  onEvent({
+    type: "manifest",
+    orgId: manifest.orgId,
+    folders: manifest.folders.length,
+    videos: manifest.videos.length
+  });
+  const pending = [];
+  let unchanged = 0;
+  let skipped = 0;
+  for (const video of resolved.videos) {
+    if (video.status !== "ready") {
+      skipped += 1;
+      onEvent({ type: "file-skipped", id: video.id, title: video.title, reason: `status: ${video.status}` });
+      continue;
+    }
+    if (video.moderation_status === "failed" || video.moderation_status === "errored") {
+      skipped += 1;
+      onEvent({ type: "file-skipped", id: video.id, title: video.title, reason: "restricted" });
+      continue;
+    }
+    const relPath = videoRelativePath(video, folderPaths);
+    const absPath = join2(outDir, relPath);
+    const stored = state.videos[video.id];
+    const isCurrent = stored !== void 0 && stored.version === video.version && stored.path === relPath && existsSync4(absPath) && (stored.sizeBytes === null || statSync2(absPath).size === stored.sizeBytes);
+    if (isCurrent) {
+      unchanged += 1;
+      continue;
+    }
+    pending.push({ video, absPath, relPath, resuming: existsSync4(partPathFor(absPath)) });
+  }
+  const selected = options.limit && options.limit > 0 ? pending.slice(0, options.limit) : pending;
+  onEvent({ type: "planned", total: resolved.videos.length, pending: selected.length, unchanged });
+  if (options.dryRun) {
+    for (const item of selected) {
+      onEvent({
+        type: "file-start",
+        id: item.video.id,
+        title: item.video.title,
+        path: item.relPath,
+        resuming: item.resuming
+      });
+    }
+    return { downloaded: 0, unchanged, skipped, failed: 0 };
+  }
+  let downloaded = 0;
+  let failed = 0;
+  let prepareDelayMs = INITIAL_PREPARE_DELAY_MS;
+  const deadline = Date.now() + options.maxWaitSeconds * 1e3;
+  const queue = new Map(selected.map((item) => [item.video.id, item]));
+  while (queue.size > 0) {
+    const ready = [];
+    const ids = [...queue.keys()];
+    for (let index = 0; index < ids.length; index += PREPARE_BATCH_SIZE) {
+      const batch = ids.slice(index, index + PREPARE_BATCH_SIZE);
+      const results = await client.prepare(batch);
+      for (const result of results) {
+        const item = queue.get(result.id);
+        if (!item) continue;
+        switch (result.status) {
+          case "ready":
+            if (result.url) {
+              ready.push({ id: result.id, url: result.url });
+            } else {
+              queue.delete(result.id);
+              failed += 1;
+              onEvent({ type: "file-failed", id: result.id, title: item.video.title, error: "no download URL returned" });
+            }
+            break;
+          case "preparing":
+            break;
+          case "not_found":
+          case "not_ready":
+            queue.delete(result.id);
+            skipped += 1;
+            onEvent({ type: "file-skipped", id: result.id, title: item.video.title, reason: result.status });
+            break;
+          case "forbidden":
+            queue.delete(result.id);
+            skipped += 1;
+            onEvent({ type: "file-skipped", id: result.id, title: item.video.title, reason: "restricted" });
+            break;
+          default:
+            queue.delete(result.id);
+            failed += 1;
+            onEvent({ type: "file-failed", id: result.id, title: item.video.title, error: `prepare: ${result.status}` });
+            break;
+        }
+      }
+    }
+    if (ready.length > 0) {
+      prepareDelayMs = INITIAL_PREPARE_DELAY_MS;
+      onEvent({
+        type: "status",
+        preparing: Math.max(0, queue.size - ready.length),
+        downloading: ready.length,
+        queued: queue.size
+      });
+      await runPool(ready, options.concurrency, async ({ id, url }) => {
+        const item = queue.get(id);
+        if (!item) return;
+        onEvent({
+          type: "file-start",
+          id,
+          title: item.video.title,
+          path: item.relPath,
+          resuming: item.resuming
+        });
+        const report = (bytes, total) => onEvent({ type: "file-progress", id, bytes, total });
+        let result = await downloadResumable(url, item.absPath, report);
+        if (!result.ok) {
+          const [refreshed] = await client.prepare([id]);
+          if (refreshed?.status === "ready" && refreshed.url) {
+            result = await downloadResumable(refreshed.url, item.absPath, report);
+          }
+        }
+        if (result.ok) {
+          state.videos[id] = {
+            version: item.video.version,
+            sizeBytes: result.bytes,
+            path: item.relPath
+          };
+          saveState(statePath, state);
+          queue.delete(id);
+          downloaded += 1;
+          onEvent({ type: "file-done", id, title: item.video.title, path: item.relPath, bytes: result.bytes });
+        } else {
+          queue.delete(id);
+          failed += 1;
+          onEvent({ type: "file-failed", id, title: item.video.title, error: result.error });
+        }
+      });
+    }
+    if (queue.size === 0) break;
+    onEvent({
+      type: "status",
+      preparing: queue.size,
+      downloading: 0,
+      queued: queue.size
+    });
+    if (Date.now() > deadline) {
+      for (const item of queue.values()) {
+        failed += 1;
+        onEvent({
+          type: "file-failed",
+          id: item.video.id,
+          title: item.video.title,
+          error: "timed out waiting for the master"
+        });
+      }
+      break;
+    }
+    await sleep(prepareDelayMs);
+    prepareDelayMs = Math.min(prepareDelayMs * 2, MAX_PREPARE_DELAY_MS);
+  }
+  return { downloaded, unchanged, skipped, failed };
+}
+async function runPool(items, concurrency, worker) {
+  let index = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      for (; ; ) {
+        const current = index;
+        index += 1;
+        const item = items[current];
+        if (item === void 0) return;
+        await worker(item);
+      }
+    })
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/ui/format.ts
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+
+// src/ui/theme.ts
+var colorEnabled = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+function paint(code) {
+  return colorEnabled ? (text) => `\x1B[${code}m${text}\x1B[0m` : (text) => text;
+}
+var color = {
+  dim: paint(2),
+  bold: paint(1),
+  red: paint(31),
+  green: paint(32),
+  yellow: paint(33),
+  blue: paint(34),
+  magenta: paint(35),
+  cyan: paint(36)
+};
+var isInteractive = colorEnabled;
+var animationsEnabled = colorEnabled && process.env.CUTSIO_NO_ANIM !== "1";
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/ui/progress.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var BAR_WIDTH = 22;
+var ProgressView = class {
+  active = /* @__PURE__ */ new Map();
+  interactive = isInteractive;
+  statusLine = null;
+  renderedLines = 0;
+  frame = 0;
+  timer = null;
+  dirty = false;
+  constructor() {
+    if (!this.interactive) return;
+    this.timer = setInterval(() => {
+      if (this.active.size === 0) return;
+      this.frame += 1;
+      this.render();
+    }, 120);
+    this.timer.unref();
+  }
+  status(text) {
+    if (!this.interactive) return;
+    this.statusLine = text;
+    this.dirty = true;
+  }
+  /** Print a line above the live area without tearing it. */
+  log(message) {
+    if (!this.interactive) {
+      console.log(message);
+      return;
+    }
+    this.clear();
+    process.stdout.write(`${message}
+`);
+    this.render();
+  }
+  error(message) {
+    if (!this.interactive) {
+      console.error(message);
+      return;
+    }
+    this.clear();
+    process.stderr.write(`${message}
+`);
+    this.render();
+  }
+  start(id, label) {
+    if (!this.interactive) {
+      console.log(`  fetch   ${label}`);
+      return;
+    }
+    const now = Date.now();
+    this.active.set(id, {
+      label,
+      bytes: 0,
+      total: null,
+      lastBytes: 0,
+      lastAt: now,
+      speed: 0
+    });
+    this.dirty = true;
+    this.render();
+  }
+  progress(id, bytes, total) {
+    if (!this.interactive) return;
+    const item = this.active.get(id);
+    if (!item) return;
+    const now = Date.now();
+    const elapsed = (now - item.lastAt) / 1e3;
+    if (elapsed >= 0.3) {
+      const delta = bytes - item.lastBytes;
+      if (delta >= 0) item.speed = delta / elapsed;
+      item.lastBytes = bytes;
+      item.lastAt = now;
+    }
+    item.bytes = bytes;
+    if (total !== null) item.total = total;
+    this.dirty = true;
+  }
+  finish(id, ok, text) {
+    if (!this.interactive) {
+      if (ok) console.log(`  done    ${text}`);
+      else console.error(`  FAILED  ${text}`);
+      return;
+    }
+    this.clear();
+    const line = ok ? `  ${color.green("\u2713")} ${text}` : `  ${color.red("\u2717")} ${text}`;
+    (ok ? process.stdout : process.stderr).write(`${line}
+`);
+    this.active.delete(id);
+    this.render();
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (!this.interactive) return;
+    this.clear();
+    this.active.clear();
+    this.statusLine = null;
+  }
+  clear() {
+    if (this.renderedLines === 0) return;
+    process.stdout.write(`\x1B[${this.renderedLines}A\x1B[J`);
+    this.renderedLines = 0;
+  }
+  render() {
+    if (!this.interactive) return;
+    if (this.active.size === 0 && !this.statusLine) {
+      this.clear();
+      return;
+    }
+    const lines = [];
+    if (this.statusLine) {
+      const spinner = FRAMES[this.frame % FRAMES.length] ?? FRAMES[0];
+      lines.push(`  ${color.cyan(spinner ?? "")} ${color.dim(this.statusLine)}`);
+    }
+    for (const item of this.active.values()) {
+      lines.push(`    ${color.bold(item.label)}`);
+      lines.push(`    ${this.bar(item)}`);
+    }
+    this.clear();
+    process.stdout.write(`${lines.join("\n")}
+`);
+    this.renderedLines = lines.length;
+    this.dirty = false;
+  }
+  bar(item) {
+    const ratio = item.total && item.total > 0 ? Math.min(1, item.bytes / item.total) : null;
+    const filled = ratio === null ? 0 : Math.round(ratio * BAR_WIDTH);
+    const track = color.cyan("\u2588".repeat(filled)) + color.dim("\u2591".repeat(BAR_WIDTH - filled));
+    const percent = ratio === null ? "  ? " : `${Math.floor(ratio * 100)}%`.padStart(4);
+    const size = item.total ? `${formatBytes(item.bytes)} / ${formatBytes(item.total)}` : formatBytes(item.bytes);
+    const speed = item.speed > 0 ? `${formatBytes(item.speed)}/s` : "";
+    return `${track} ${percent}  ${size}  ${color.dim(speed)}`.trimEnd();
+  }
+};
+
+// src/commands/selection-prompt.ts
+import { stdin as stdin2, stdout as stdout2 } from "node:process";
+import { createInterface } from "node:readline/promises";
+function countLabel(count) {
+  return `${count} video${count === 1 ? "" : "s"}`;
+}
+async function promptSelection(manifest) {
+  const { subtree } = folderVideoCounts(manifest);
+  const entries = [
+    ...manifest.collections.map((collection) => ({
+      kind: "collection",
+      ref: collection.title,
+      label: `collection ${collection.title} \u2014 ${countLabel(
+        manifest.videos.filter((video) => video.collection_id === collection.id).length
+      )}`
+    })),
+    ...[...buildFolderPaths(manifest.folders).entries()].sort((a, b) => a[1].localeCompare(b[1])).map(([id, path]) => ({
+      kind: "folder",
+      ref: path,
+      label: `folder ${path}/ \u2014 ${countLabel(subtree.get(id) ?? 0)}`
+    }))
+  ];
+  const unfiledCount = manifest.videos.filter((video) => !video.folder_id).length;
+  if (unfiledCount > 0) {
+    entries.push({
+      kind: "unfiled",
+      ref: "",
+      label: `unfiled (no folder) \u2014 ${countLabel(unfiledCount)}`
+    });
+  }
+  if (entries.length === 0) {
+    console.error("Nothing to select: this workspace has no folders or collections.");
+    return null;
+  }
+  console.log("Select what to sync:");
+  entries.forEach((entry, index) => {
+    console.log(`  ${String(index + 1).padStart(3)}) ${entry.label}`);
+  });
+  const rl = createInterface({ input: stdin2, output: stdout2 });
+  try {
+    for (; ; ) {
+      const answer = (await rl.question('Numbers separated by commas, "all", or blank to cancel: ')).trim();
+      if (answer === "") return null;
+      if (answer.toLowerCase() === "all") {
+        return { all: true, unfiled: false, folderRefs: [], collectionRefs: [], videoIds: [], searchTerms: [] };
+      }
+      const indexes = answer.split(/[,\s]+/).filter(Boolean).map(Number);
+      const invalid = indexes.some(
+        (value) => !Number.isInteger(value) || value < 1 || value > entries.length
+      );
+      if (invalid || indexes.length === 0) {
+        console.log(`Enter numbers between 1 and ${entries.length}.`);
+        continue;
+      }
+      const picked = indexes.map((index) => entries[index - 1]).filter((entry) => entry !== void 0);
+      return {
+        all: false,
+        unfiled: picked.some((entry) => entry.kind === "unfiled"),
+        folderRefs: picked.filter((entry) => entry.kind === "folder").map((entry) => entry.ref),
+        collectionRefs: picked.filter((entry) => entry.kind === "collection").map((entry) => entry.ref),
+        videoIds: [],
+        searchTerms: []
+      };
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/sync.ts
+async function syncCommand(flags) {
+  const apiKey = await resolveApiKey();
+  if (!apiKey) {
+    console.error("No API key. Run `cutsio login` or set CUTSIO_API_KEY.");
+    return 1;
+  }
+  const client = new CutsioClient(resolveApiUrl(flags.url), apiKey);
+  const view = new ProgressView();
+  const onEvent = (event) => {
+    switch (event.type) {
+      case "manifest":
+        view.log(
+          `${color.dim("workspace")} ${event.orgId}  ${color.dim("\xB7")}  ${event.videos} videos  ${color.dim("\xB7")}  ${event.folders} folders`
+        );
+        break;
+      case "planned":
+        view.log(
+          `${color.dim("selected")} ${event.total}  ${color.dim("\xB7")}  pending ${event.pending}  ${color.dim("\xB7")}  unchanged ${event.unchanged}`
+        );
+        break;
+      case "status":
+        view.status(
+          `${event.downloading} downloading \xB7 ${event.preparing} preparing \xB7 ${event.queued} remaining`
+        );
+        break;
+      case "file-start":
+        view.start(event.id, `${event.resuming ? "resuming " : ""}${event.path}`);
+        break;
+      case "file-progress":
+        view.progress(event.id, event.bytes, event.total);
+        break;
+      case "file-done":
+        view.finish(event.id, true, `${event.path} (${formatBytes(event.bytes)})`);
+        break;
+      case "file-skipped":
+        view.log(`  ${color.yellow("skip")}    ${event.title} \u2014 ${event.reason}`);
+        break;
+      case "file-failed":
+        view.finish(event.id, false, `${event.title} \u2014 ${event.error}`);
+        break;
+      case "warning":
+        view.log(`  ${color.yellow("warning")} ${event.message}`);
+        break;
+    }
+  };
+  let selection = {
+    all: flags.all === "true",
+    folderRefs: splitList(flags.folder),
+    collectionRefs: splitList(flags.collection),
+    videoIds: splitList(flags.video),
+    searchTerms: splitList(flags.search),
+    unfiled: flags.unfiled === "true"
+  };
+  let manifest;
+  try {
+    if (flags.interactive === "true") {
+      view.stop();
+      manifest = await client.fetchManifest();
+      const prompted = await promptSelection(manifest);
+      if (!prompted) {
+        console.log("Cancelled. Nothing downloaded.");
+        return 0;
+      }
+      selection = mergeSelections(selection, prompted);
+    }
+    if (isEmptySelection(selection)) {
+      console.error("Refusing to sync the whole workspace. Choose one of:\n");
+      console.error("  --all                        every video in the workspace");
+      console.error("  --folder <path|id,...>       a folder and everything under it");
+      console.error("  --collection <name|id,...>   a collection");
+      console.error("  --video <id,...>             specific videos");
+      console.error("  --search <term,...>          video titles containing a term");
+      console.error("  --unfiled                    videos that are in no folder");
+      console.error("  --interactive                pick from a menu\n");
+      console.error("`cutsio list` prints names, paths, and ids.");
+      return 1;
+    }
+    const summary = await sync(client, {
+      outDir: flags.out ?? "./cutsio",
+      concurrency: positiveInt(flags.concurrency, 3),
+      dryRun: flags["dry-run"] === "true",
+      maxWaitSeconds: positiveInt(flags["max-wait"], 600),
+      limit: positiveInt(flags.limit, 0),
+      selection,
+      manifest,
+      onEvent
+    });
+    view.stop();
+    const failing = summary.failed > 0;
+    const summaryLine = `${summary.downloaded} downloaded \xB7 ${summary.unchanged} unchanged \xB7 ${summary.skipped} skipped \xB7 ${summary.failed} failed`;
+    console.log(`
+${failing ? color.red(summaryLine) : color.green(summaryLine)}`);
+    return failing ? 1 : 0;
+  } catch (error) {
+    view.stop();
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+function splitList(value) {
+  if (!value) return [];
+  return [...new Set(value.split(",").map((entry) => entry.trim()).filter(Boolean))];
+}
+function mergeSelections(a, b) {
+  return {
+    all: a.all || b.all,
+    unfiled: a.unfiled || b.unfiled,
+    folderRefs: [.../* @__PURE__ */ new Set([...a.folderRefs, ...b.folderRefs])],
+    collectionRefs: [.../* @__PURE__ */ new Set([...a.collectionRefs, ...b.collectionRefs])],
+    videoIds: [.../* @__PURE__ */ new Set([...a.videoIds, ...b.videoIds])],
+    searchTerms: [.../* @__PURE__ */ new Set([...a.searchTerms, ...b.searchTerms])]
+  };
+}
+function positiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+// src/commands/whoami.ts
+async function whoamiCommand(flags) {
+  const apiKey = await resolveApiKey();
+  if (!apiKey) {
+    console.error("No API key. Run `cutsio login` or set CUTSIO_API_KEY.");
+    return 1;
+  }
+  const client = new CutsioClient(resolveApiUrl(flags.url), apiKey);
+  try {
+    console.log(JSON.stringify(await client.whoami(), null, 2));
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+
+// src/ui/banner.ts
+var WORDMARK = [
+  " \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551",
+  "\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551   \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551",
+  "\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  " \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D    \u255A\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D "
+];
+var SHADES = [96, 96, 36, 36, 34, 34];
+function shade(line, index) {
+  if (!animationsEnabled) return line;
+  const code = SHADES[index] ?? 36;
+  return `\x1B[${code}m${line}\x1B[0m`;
+}
+async function revealBanner() {
+  process.stdout.write("\n");
+  for (let index = 0; index < WORDMARK.length; index += 1) {
+    process.stdout.write(`${shade(WORDMARK[index] ?? "", index)}
+`);
+    if (animationsEnabled) await sleep2(38);
+  }
+  process.stdout.write(`${color.dim("  mezzanine sync for your Mac")}
+
+`);
+  if (animationsEnabled) await sleep2(60);
+}
+
+// src/index.ts
+function parseFlags(args) {
+  const flags = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg || !arg.startsWith("--")) continue;
+    const body = arg.slice(2);
+    const separator = body.indexOf("=");
+    const key = separator === -1 ? body : body.slice(0, separator);
+    const inline = separator === -1 ? void 0 : body.slice(separator + 1);
+    if (!key) continue;
+    if (inline !== void 0) {
+      flags[key] = inline;
+      continue;
+    }
+    const next = args[index + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags[key] = next;
+      index += 1;
+    } else {
+      flags[key] = "true";
+    }
+  }
+  return flags;
+}
+function printHelp() {
+  console.log(`cutsio \u2014 sync Cutsio mezzanine masters to a local folder
+
+Usage:
+  cutsio login [--url URL] [--key KEY]
+  cutsio logout
+  cutsio whoami [--url URL]
+  cutsio list [--videos] [--search TERM] [--json] [--url URL]
+  cutsio sync [--all | --folder REFS | --collection REFS | --video IDS | --search TERMS | --unfiled | --interactive]
+              [--out DIR] [--concurrency N] [--max-wait SECONDS] [--limit N] [--dry-run] [--url URL]
+
+Selection:
+  REFS and IDS are comma-separated. Folders accept a path (e.g. test/sub1a) or id;
+  collections accept a title or id. A folder selection includes its subfolders.
+  --search matches video titles anywhere in the workspace; --unfiled selects
+  videos that are in no folder.
+
+Environment:
+  CUTSIO_API_URL   API base URL (default ${DEFAULT_API_URL})
+  CUTSIO_API_KEY   Organization API key
+  NO_COLOR         Disable color
+  CUTSIO_NO_ANIM=1 Disable the banner and live progress`);
+}
+async function maybeWelcome() {
+  if (!animationsEnabled) return;
+  const marker = join3(configDir(), ".welcomed");
+  if (existsSync5(marker)) return;
+  await revealBanner();
+  try {
+    mkdirSync4(configDir(), { recursive: true, mode: 448 });
+    writeFileSync3(marker, "");
+  } catch {
+  }
+}
+async function main() {
+  const [, , command, ...rest] = process2.argv;
+  const flags = parseFlags(rest);
+  switch (command) {
+    case "login":
+    case "whoami":
+    case "list":
+    case "sync":
+      await maybeWelcome();
+      break;
+    default:
+      break;
+  }
+  switch (command) {
+    case "login":
+      return loginCommand(flags);
+    case "logout":
+      return logoutCommand();
+    case "whoami":
+      return whoamiCommand(flags);
+    case "list":
+      return listCommand(flags);
+    case "sync":
+      return syncCommand(flags);
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      return 0;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      return 1;
+  }
+}
+main().then((code) => {
+  process2.exitCode = code;
+});