@vosjs/cli 0.50.4 → 0.52.0

package/dist/chunk-KSEU3YK5.js

@@ -0,0 +1,776 @@
+#!/usr/bin/env node
+
+// src/flagUse.ts
+var given = /* @__PURE__ */ new Set();
+var used = /* @__PURE__ */ new Set();
+function trackFlags(bag) {
+  return new Proxy(bag, {
+    get(target, key, receiver) {
+      if (typeof key === "string") used.add(key);
+      return Reflect.get(target, key, receiver);
+    },
+    has(target, key) {
+      if (typeof key === "string") used.add(key);
+      return Reflect.has(target, key);
+    },
+    // hasOwnProperty.call(flags, name) lands here.
+    getOwnPropertyDescriptor(target, key) {
+      if (typeof key === "string") used.add(key);
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    },
+    // A spread, Object.keys or JSON.stringify hands every flag onward; what
+    // happens to them after that cannot be seen, so they all count as read.
+    ownKeys(target) {
+      for (const key of Reflect.ownKeys(target))
+        if (typeof key === "string") used.add(key);
+      return Reflect.ownKeys(target);
+    }
+  });
+}
+function noteGivenFlag(name) {
+  given.add(name);
+}
+function unusedFlags() {
+  return [...given].filter((name) => !used.has(name) && name !== "help");
+}
+function helpFlagsFor(help, verb) {
+  const out = /* @__PURE__ */ new Set();
+  let inVerb = false;
+  for (const line of help.split("\n")) {
+    const head = /^\s{2}vos\s+(\S+)/.exec(line);
+    if (head) inVerb = head[1] === verb;
+    else if (!/^\s{3,}\S/.test(line)) inVerb = false;
+    if (!inVerb) continue;
+    for (const m of line.matchAll(/--([a-z][a-z0-9-]*)/g)) out.add(m[1]);
+  }
+  return [...out];
+}
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const keep = row[j];
+      row[j] = Math.min(
+        row[j] + 1,
+        row[j - 1] + 1,
+        prev + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+      prev = keep;
+    }
+  }
+  return row[b.length];
+}
+function nearestFlag(name, candidates) {
+  let best = null;
+  let bestScore = Infinity;
+  for (const c of candidates) {
+    if (c === name) continue;
+    const d = c.includes(name) || name.includes(c) ? 1 : editDistance(name, c);
+    if (d < bestScore) {
+      bestScore = d;
+      best = c;
+    }
+  }
+  return best !== null && bestScore <= Math.max(2, Math.floor(name.length / 3)) ? best : null;
+}
+function unusedFlagsMessage(verb, documented) {
+  const unused = unusedFlags();
+  if (!unused.length) return null;
+  const parts = unused.map((name) => {
+    const near = nearestFlag(name, documented);
+    return `--${name}${near ? ` (did you mean --${near}?)` : ""}`;
+  });
+  const list = documented.length ? ` It reads: ${documented.map((f) => `--${f}`).join(" ")}.` : "";
+  return `vos ${verb} RAN, and ignored ${parts.join(", ")}: ${unused.length > 1 ? "they are" : "it is"} not something this verb reads, so what it printed above was made without ${unused.length > 1 ? "them" : "it"}.${list}`;
+}
+
+// src/args.ts
+var UsageError = class extends Error {
+};
+function parseArgs(argv, booleanFlags) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq !== -1) {
+        flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+        continue;
+      }
+      const name = arg.slice(2);
+      if (booleanFlags.has(name)) {
+        flags[name] = true;
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next === void 0 || next.startsWith("--")) {
+        throw new UsageError(`--${name} expects a value`);
+      }
+      flags[name] = next;
+      i++;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  for (const name of Object.keys(flags)) noteGivenFlag(name);
+  return { positionals, flags: trackFlags(flags) };
+}
+function numFlag(flags, name, fallback) {
+  const v = flags[name];
+  if (v === void 0) return fallback;
+  const n = Number(v);
+  if (!Number.isFinite(n))
+    throw new UsageError(`--${name} expects a number, got "${String(v)}"`);
+  return n;
+}
+
+// src/loadConfig.ts
+import { readFile } from "fs/promises";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import {
+  CURRENT_CONFIG_VERSION,
+  migrateConfig,
+  vosConfigJsonSchema
+} from "@vosjs/core";
+function directoryKind(target) {
+  try {
+    if (!statSync(target).isDirectory()) return "none";
+  } catch {
+    return "none";
+  }
+  const docPath = join(target, "doc.json");
+  if (existsSync(docPath)) {
+    try {
+      const doc = JSON.parse(readFileSync(docPath, "utf8"));
+      if (typeof doc === "object" && doc !== null && "source" in doc)
+        return "take";
+    } catch {
+      return "take";
+    }
+  }
+  return existsSync(join(target, "config.json")) ? "program" : "none";
+}
+async function loadProgramDirectory(dir, warnings) {
+  const config = JSON.parse(
+    await readFile(join(dir, "config.json"), "utf8")
+  );
+  const docPath = join(dir, "doc.json");
+  if (!existsSync(docPath)) return config;
+  const doc = JSON.parse(await readFile(docPath, "utf8"));
+  if (typeof doc !== "object" || doc === null || "source" in doc) return config;
+  if (typeof config !== "object" || config === null) {
+    throw new UsageError(`${dir}/config.json does not contain a JSON object`);
+  }
+  const raw = doc;
+  const program = raw.program && typeof raw.program === "object" ? raw.program : {};
+  const { lowerProgramDoc } = await import("@vosjs/studio-core");
+  const composed = lowerProgramDoc(
+    { ...raw, program: { ...program, config } },
+    { bake: true }
+  ).config;
+  warnings.push(
+    "composed config.json with doc.json (a program document: its layers and tween edits ride the render)"
+  );
+  return composed;
+}
+async function readSourceText(source) {
+  if (/^https?:\/\//.test(source)) {
+    const res = await fetch(source);
+    if (!res.ok) throw new Error(`fetch ${source} \u2192 ${res.status}`);
+    return await res.text();
+  }
+  let isDir = false;
+  try {
+    isDir = statSync(source).isDirectory();
+  } catch {
+  }
+  if (isDir) {
+    throw new UsageError(
+      `${source} is a directory with no config.json and no doc.json \u2014 pass a config file, a URL, a program directory or a take`
+    );
+  }
+  return await readFile(source, "utf8");
+}
+async function loadVosConfig(source) {
+  const warnings = [];
+  let parsed;
+  const kind = /^https?:\/\//.test(source) ? "none" : directoryKind(source);
+  if (kind === "take") {
+    throw new UsageError(
+      `${source} is a take (its doc.json is a recording document). Render it through the take pipeline: vos render ${source} [out]; vos frames ${source} for stills.`
+    );
+  }
+  if (kind === "program") {
+    parsed = await loadProgramDirectory(source, warnings);
+    return finish(source, parsed, warnings);
+  }
+  const raw = await readSourceText(source);
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new UsageError(`${source} is not valid JSON: ${e.message}`);
+  }
+  return finish(source, parsed, warnings);
+}
+function finish(source, parsed, warnings) {
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new UsageError(`${source} does not contain a JSON object`);
+  }
+  let obj = parsed;
+  if (typeof obj.config === "object" && obj.config !== null && !("createTimeline" in obj)) {
+    obj = obj.config;
+    warnings.push("unwrapped { config } envelope");
+  }
+  const version = obj.version;
+  const migrated = migrateConfig(obj);
+  if (version === void 0) {
+    warnings.push(
+      `config declares no "version". Add "version": ${CURRENT_CONFIG_VERSION} before pushing it.`
+    );
+  } else if (version !== CURRENT_CONFIG_VERSION) {
+    warnings.push(
+      `migrated config v${String(version)} to v${CURRENT_CONFIG_VERSION}`
+    );
+  }
+  const check = vosConfigJsonSchema.safeParse(migrated);
+  if (!check.success) {
+    const issues = check.error.issues.slice(0, 5).map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new UsageError(`invalid vos config:
+${issues}`);
+  }
+  return { config: migrated, warnings };
+}
+function configDuration(config) {
+  const d = config.duration;
+  return typeof d === "number" && Number.isFinite(d) && d > 0 ? d : void 0;
+}
+
+// src/browser.ts
+import { chromium } from "playwright";
+var BrowserUnavailableError = class extends Error {
+  constructor(cause) {
+    super(
+      `Could not launch a Chromium-family browser (${cause}).
+Fixes, in order of preference:
+  1. Install Google Chrome (used automatically), or
+  2. npx playwright install chromium, or
+  3. Set VOS_BROWSER_PATH to a Chrome/Chromium executable.`
+    );
+  }
+};
+async function launchBrowser(args = []) {
+  const opts = args.length ? { args } : {};
+  const explicit = process.env.VOS_BROWSER_PATH;
+  if (explicit) {
+    return chromium.launch({ ...opts, executablePath: explicit }).catch((e) => {
+      throw new BrowserUnavailableError(
+        `VOS_BROWSER_PATH failed: ${e.message}`
+      );
+    });
+  }
+  try {
+    return await chromium.launch({ ...opts, channel: "chrome" });
+  } catch {
+    try {
+      return await chromium.launch(opts);
+    } catch (e) {
+      throw new BrowserUnavailableError(
+        e.message.split("\n")[0] ?? "unknown"
+      );
+    }
+  }
+}
+
+// src/plugin/container.ts
+var OCTET_STREAM = "application/octet-stream";
+var TYPES_BY_EXTENSION = {
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  avif: "image/avif",
+  webm: "video/webm",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4"
+};
+var EXTENSION_BY_TYPE = {
+  "image/jpeg": ".jpg",
+  "video/mp4": ".mp4",
+  "audio/mp4": ".m4a"
+};
+var TAKE_MEDIA_EXTENSIONS = [
+  ".webm",
+  ".mp4",
+  ".mov",
+  ".m4a",
+  ".mp3",
+  ".ogg",
+  ".wav"
+];
+var MEDIA_HEAD_BYTES = 16;
+var ISO_BRANDS = {
+  "qt  ": "video/quicktime",
+  "M4A ": "audio/mp4",
+  "M4B ": "audio/mp4",
+  avif: "image/avif",
+  avis: "image/avif"
+};
+var RIFF_FORMS = {
+  WEBP: "image/webp",
+  WAVE: "audio/wav",
+  "AVI ": "video/x-msvideo"
+};
+function sniffMediaType(head) {
+  const ascii = (at, len) => head.length >= at + len ? String.fromCharCode(...head.subarray(at, at + len)) : "";
+  const startsWith = (...bytes) => bytes.every((b, i) => head[i] === b);
+  if (startsWith(26, 69, 223, 163)) return "video/webm";
+  if (ascii(4, 4) === "ftyp") return ISO_BRANDS[ascii(8, 4)] ?? "video/mp4";
+  if (ascii(0, 4) === "RIFF") return RIFF_FORMS[ascii(8, 4)] ?? null;
+  if (startsWith(137, 80, 78, 71, 13, 10, 26, 10))
+    return "image/png";
+  if (startsWith(255, 216, 255)) return "image/jpeg";
+  if (ascii(0, 4) === "GIF8") return "image/gif";
+  if (ascii(0, 4) === "OggS") return "audio/ogg";
+  if (ascii(0, 3) === "ID3") return "audio/mpeg";
+  return null;
+}
+function bareType(value) {
+  const type = (value ?? "").split(";")[0].trim().toLowerCase();
+  return !type || type === OCTET_STREAM || type === "binary/octet-stream" ? "" : type;
+}
+function mediaContentType(file) {
+  const ext = (/\.([a-z0-9]+)$/i.exec(file)?.[1] ?? "").toLowerCase();
+  return TYPES_BY_EXTENSION[ext] ?? OCTET_STREAM;
+}
+function extensionFor(contentType) {
+  const type = (contentType ?? "").split(";")[0].trim().toLowerCase();
+  if (EXTENSION_BY_TYPE[type]) return EXTENSION_BY_TYPE[type];
+  const ext = Object.keys(TYPES_BY_EXTENSION).find(
+    (e) => TYPES_BY_EXTENSION[e] === type
+  );
+  return ext ? `.${ext}` : "";
+}
+function resolveMediaType(claims) {
+  const sniffed = claims.head?.length ? sniffMediaType(claims.head) : null;
+  if (sniffed) return { type: sniffed, from: "bytes" };
+  const declared = bareType(claims.declared);
+  if (declared) return { type: declared, from: "declared" };
+  const named = mediaContentType(claims.filename ?? "");
+  if (named !== OCTET_STREAM) return { type: named, from: "filename" };
+  return { type: OCTET_STREAM, from: "unknown" };
+}
+function nameForType(filename, type) {
+  const ext = extensionFor(type);
+  if (!ext) return filename;
+  const current = /\.[a-z0-9]+$/i.exec(filename)?.[0] ?? "";
+  if (current && mediaContentType(`x${current}`) === type) return filename;
+  return `${filename.slice(0, filename.length - current.length)}${ext}`;
+}
+function containerMismatch(filename, head) {
+  const actual = sniffMediaType(head);
+  if (!actual) return null;
+  const claimed = mediaContentType(filename);
+  if (claimed === actual) return null;
+  return `${filename} is ${actual}, not the ${claimed} its name claims \u2014 rename it to ${nameForType(filename, actual)}`;
+}
+
+// src/outputs.ts
+function extOf(path) {
+  return /\.([a-z0-9]+)$/i.exec(path ?? "")?.[1]?.toLowerCase() ?? "";
+}
+function videoFormat(flag, out) {
+  const named = extOf(out);
+  const fromName = named === "mp4" ? "mp4" : named === "webm" ? "webm" : null;
+  if (flag !== void 0) {
+    if (flag !== "webm" && flag !== "mp4")
+      throw new UsageError("--format must be webm or mp4");
+    if (fromName && fromName !== flag)
+      throw new UsageError(
+        `--format ${flag} contradicts the output name ${out}: name it .${flag}, or drop --format and the name decides`
+      );
+    return flag;
+  }
+  return fromName ?? "webm";
+}
+function stillFormat(out) {
+  const ext = extOf(out);
+  if (ext === "png") return "png";
+  if (ext === "jpg" || ext === "jpeg") return "jpeg";
+  if (ext === "webp" || ext === "") return "webp";
+  throw new UsageError(
+    `vos still writes .webp, .png or .jpg, not .${ext}: rename ${out}`
+  );
+}
+function parseTimes(raw, duration) {
+  const times = raw.split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+    const pct = /^(\d+(?:\.\d+)?)%$/.exec(s);
+    const t = pct ? Number(pct[1]) / 100 * duration : Number(s);
+    if (!Number.isFinite(t) || t < 0)
+      throw new UsageError(
+        `--times expects seconds or percentages (0,1.5,50%), got "${s}"`
+      );
+    return Math.min(t, Math.max(0, duration - 1 / 60));
+  });
+  if (!times.length) throw new UsageError("--times needs at least one time");
+  return times;
+}
+function stillOutFor(out, time, many) {
+  if (!many) return out;
+  const m = /^(.*?)(\.[a-z0-9]+)?$/i.exec(out);
+  return `${m?.[1] ?? out}-${time.toFixed(2)}s${m?.[2] ?? ""}`;
+}
+function setFlags(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--set" && argv[i + 1] !== void 0) out.push(argv[++i]);
+    else if (a.startsWith("--set=")) out.push(a.slice("--set=".length));
+  }
+  return out;
+}
+function applyDataSets(config, sets) {
+  if (!sets.length) return config;
+  const data = {
+    ...config.data ?? {}
+  };
+  for (const set of sets) {
+    const eq = set.indexOf("=");
+    const path = eq === -1 ? set : set.slice(0, eq);
+    const m = /^data\.([A-Za-z0-9_$-]+)$/.exec(path);
+    if (eq === -1 || !m)
+      throw new UsageError(
+        `--set on a program takes data.<key>=<value> (a knob's value), got "${set}"`
+      );
+    const raw = set.slice(eq + 1);
+    let value = raw;
+    try {
+      value = JSON.parse(raw);
+    } catch {
+    }
+    data[m[1]] = value;
+  }
+  return { ...config, data };
+}
+
+// src/plugin/args.ts
+function parseArgs2(argv, booleanFlags, multiFlags = /* @__PURE__ */ new Set()) {
+  const positionals = [];
+  const flags = {};
+  const multi = {};
+  const put = (name, value) => {
+    if (multiFlags.has(name)) (multi[name] ??= []).push(value);
+    else flags[name] = value;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq !== -1) {
+        put(arg.slice(2, eq), arg.slice(eq + 1));
+        continue;
+      }
+      const name = arg.slice(2);
+      if (booleanFlags.has(name)) {
+        flags[name] = true;
+        continue;
+      }
+      if (i + 1 >= argv.length || argv[i + 1].startsWith("--")) {
+        throw new UsageError(`--${name} expects a value`);
+      }
+      put(name, argv[i + 1]);
+      i++;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  for (const name of Object.keys(flags)) noteGivenFlag(name);
+  for (const name of Object.keys(multi)) noteGivenFlag(name);
+  return { positionals, flags: trackFlags(flags), multi: trackFlags(multi) };
+}
+function numFlag2(flags, name, fallback) {
+  const v = flags[name];
+  if (typeof v !== "string") return fallback;
+  const n = Number(v);
+  if (!Number.isFinite(n))
+    throw new UsageError(`--${name} expects a number, got "${v}"`);
+  return n;
+}
+function strFlag(flags, name) {
+  const v = flags[name];
+  return typeof v === "string" ? v : void 0;
+}
+function hasFlag(flags, name) {
+  return Object.prototype.hasOwnProperty.call(flags, name);
+}
+
+// src/plugin/platform.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/plugin/hostAgent.ts
+import { existsSync as existsSync2 } from "fs";
+var SLUG = /^[a-z0-9][a-z0-9.-]{0,39}$/;
+var MARKERS = [
+  ["cursor", (e) => !!e.CURSOR_TRACE_ID],
+  [
+    "cursor-cli",
+    (e) => !!e.CURSOR_AGENT || e.CURSOR_EXTENSION_HOST_ROLE === "agent-exec"
+  ],
+  ["gemini-cli", (e) => !!e.GEMINI_CLI],
+  ["codex", (e) => !!(e.CODEX_SANDBOX || e.CODEX_CI || e.CODEX_THREAD_ID)],
+  ["antigravity", (e) => !!e.ANTIGRAVITY_AGENT],
+  ["augment-cli", (e) => !!e.AUGMENT_AGENT],
+  ["opencode", (e) => !!e.OPENCODE_CLIENT],
+  [
+    "claude-code",
+    (e) => !!(e.CLAUDECODE || e.CLAUDE_CODE) && !e.CLAUDE_CODE_IS_COWORK
+  ],
+  ["claude-cowork", (e) => !!(e.CLAUDECODE || e.CLAUDE_CODE)],
+  ["replit", (e) => !!e.REPL_ID],
+  [
+    "github-copilot",
+    (e) => !!(e.COPILOT_MODEL || e.COPILOT_ALLOW_ALL || e.COPILOT_GITHUB_TOKEN)
+  ]
+];
+var DEVIN_LOCAL_PATH = "/opt/.devin";
+function slugFromAiAgent(value) {
+  const head = value.trim().toLowerCase().split("_")[0] ?? "";
+  if (head === "github-copilot-cli") return "github-copilot";
+  return SLUG.test(head) ? head : null;
+}
+function detectHostAgent(env = process.env, exists = existsSync2) {
+  if (env.AI_AGENT) {
+    const slug = slugFromAiAgent(env.AI_AGENT);
+    if (slug) return slug;
+  }
+  for (const [slug, test] of MARKERS) if (test(env)) return slug;
+  try {
+    if (exists(DEVIN_LOCAL_PATH)) return "devin";
+  } catch {
+  }
+  return null;
+}
+
+// src/plugin/platform.ts
+function platformOrigin(flags = {}) {
+  const legacyEnv = process.env.VOS_API_BASE?.trim();
+  const raw = flags.origin ?? flags.api ?? process.env.VOS_ORIGIN?.trim() ?? legacyEnv ?? "https://vos.so";
+  if (!flags.origin && !flags.api && !process.env.VOS_ORIGIN && legacyEnv) {
+    process.stderr.write(
+      "note: VOS_API_BASE is deprecated \u2014 set VOS_ORIGIN (an origin, no /api suffix)\n"
+    );
+  }
+  return raw.replace(/\/+$/, "").replace(/\/api$/, "");
+}
+function parseVosId(input) {
+  if (!/^https?:\/\//.test(input)) {
+    if (/^[A-Za-z0-9_-]+$/.test(input)) return input;
+    throw new UsageError(`"${input}" is not a vos id or URL`);
+  }
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new UsageError(`"${input}" is not a valid URL`);
+  }
+  const query = url.searchParams.get("vos");
+  if (query) return query;
+  const path = url.pathname.match(/\/vos\/([A-Za-z0-9_-]+)/);
+  if (path) return path[1];
+  throw new UsageError(
+    `could not find a vos id in ${input} \u2014 expected /vos/{id} or ?vos={id}`
+  );
+}
+function deriveSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/, "") || "remix";
+}
+var CREDENTIALS_PATH = join2(homedir(), ".config", "vos", "credentials");
+function resolveCredential(explicit) {
+  const flag = explicit?.trim();
+  if (flag) return flag;
+  const env = process.env.VOS_API_KEY?.trim();
+  if (env) return env;
+  try {
+    const first = readFileSync2(CREDENTIALS_PATH, "utf8").split("\n")[0].trim();
+    return first || null;
+  } catch {
+    return null;
+  }
+}
+function requireCredential(explicit) {
+  const key = resolveCredential(explicit);
+  if (!key) {
+    throw new Error(
+      "no credential found \u2014 pass --key, set VOS_API_KEY, or run `vos login` (mint a content key at https://vos.so/app/api; a vos_rg_ remix grant works too)"
+    );
+  }
+  return key;
+}
+function writeCredential(key) {
+  mkdirSync(join2(homedir(), ".config", "vos"), { recursive: true, mode: 448 });
+  writeFileSync(CREDENTIALS_PATH, `${key.trim()}
+`, { mode: 384 });
+  return CREDENTIALS_PATH;
+}
+function clientId(env = process.env, exists) {
+  const explicit = env.VOS_CLIENT?.trim();
+  if (explicit && explicit.length <= 60 && !/[\r\n]/.test(explicit))
+    return explicit;
+  const host = detectHostAgent(env, exists);
+  return host ? `${host} vos-cli` : "vos-cli";
+}
+async function apiJson(origin, path, init = {}) {
+  const headers = {
+    accept: "application/json",
+    ...init.headers
+  };
+  if (init.key) headers.authorization = `Bearer ${init.key}`;
+  if (init.body !== void 0) headers["content-type"] = "application/json";
+  const reqBody = init.raw !== void 0 ? init.raw : init.body === void 0 ? void 0 : JSON.stringify(init.body);
+  const res = await fetch(`${origin}${path}`, {
+    method: init.method ?? "GET",
+    headers,
+    body: reqBody
+  });
+  let body = {};
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { status: res.status, body };
+}
+function apiError(what, r) {
+  const detail = typeof r.body.error === "string" ? r.body.error : r.body.details !== void 0 ? JSON.stringify(r.body.details) : "";
+  const hint = r.status === 401 ? " (run `vos login`, or set VOS_API_KEY \u2014 mint a key at https://vos.so/app/api)" : "";
+  return `${what} \u2192 ${r.status}${detail ? `: ${detail}` : ""}${hint}`;
+}
+var SYNC_STATE_NAME = "vos.json";
+function readJsonFile(file) {
+  try {
+    return JSON.parse(readFileSync2(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readSyncState(dir) {
+  const own = readJsonFile(join2(dir, SYNC_STATE_NAME));
+  if (own && typeof own.vosId === "string") {
+    return {
+      vosId: own.vosId,
+      versionId: typeof own.versionId === "string" ? own.versionId : null,
+      ...typeof own.pushedAt === "string" ? { pushedAt: own.pushedAt } : {},
+      ...typeof own.title === "string" ? { title: own.title } : {},
+      ...typeof own.slug === "string" ? { slug: own.slug } : {},
+      ...typeof own.remixOfId === "string" ? { remixOfId: own.remixOfId } : {}
+    };
+  }
+  const push = readJsonFile(join2(dir, "push.json"));
+  if (push && typeof push.vosId === "string") {
+    return {
+      vosId: push.vosId,
+      versionId: typeof push.versionId === "string" ? push.versionId : null,
+      ...typeof push.pushedAt === "string" ? { pushedAt: push.pushedAt } : {}
+    };
+  }
+  const meta = readJsonFile(join2(dir, "meta.json"));
+  if (meta && typeof meta.id === "string") {
+    return {
+      vosId: meta.id,
+      versionId: typeof meta.currentVersionId === "string" ? meta.currentVersionId : null,
+      ...typeof meta.title === "string" ? { title: meta.title } : {},
+      ...typeof meta.slug === "string" ? { slug: meta.slug } : {},
+      ...typeof meta.remixOfId === "string" ? { remixOfId: meta.remixOfId } : {}
+    };
+  }
+  return null;
+}
+function writeSyncState(dir, patch) {
+  const merged = {
+    ...readSyncState(dir) ?? { versionId: null },
+    ...patch
+  };
+  writeFileSync(
+    join2(dir, SYNC_STATE_NAME),
+    `${JSON.stringify(merged, null, 2)}
+`
+  );
+  return merged;
+}
+function formatChanges(changes) {
+  const lines = [];
+  for (const ch of changes) {
+    const label = ch.label ? ` \xB7 ${ch.label}` : "";
+    const who = ch.origin === "studio" ? "human" : ch.origin ?? "unknown";
+    lines.push(
+      `v${String(ch.versionNumber ?? "?")} (${who}${label}): ${ch.summary ?? ""}`
+    );
+    if (ch.note) lines.push(`    note: ${ch.note}`);
+  }
+  return lines;
+}
+
+export {
+  helpFlagsFor,
+  unusedFlagsMessage,
+  UsageError,
+  parseArgs,
+  numFlag,
+  directoryKind,
+  loadProgramDirectory,
+  readSourceText,
+  loadVosConfig,
+  configDuration,
+  BrowserUnavailableError,
+  launchBrowser,
+  TAKE_MEDIA_EXTENSIONS,
+  MEDIA_HEAD_BYTES,
+  sniffMediaType,
+  extensionFor,
+  resolveMediaType,
+  nameForType,
+  containerMismatch,
+  videoFormat,
+  stillFormat,
+  parseTimes,
+  stillOutFor,
+  setFlags,
+  applyDataSets,
+  parseArgs2,
+  numFlag2,
+  strFlag,
+  hasFlag,
+  platformOrigin,
+  parseVosId,
+  deriveSlug,
+  CREDENTIALS_PATH,
+  resolveCredential,
+  requireCredential,
+  writeCredential,
+  clientId,
+  apiJson,
+  apiError,
+  SYNC_STATE_NAME,
+  readSyncState,
+  writeSyncState,
+  formatChanges
+};
+//# sourceMappingURL=chunk-KSEU3YK5.js.map