@easybits.cloud/cli 0.15.5 → 0.17.0

package/dist/index.js

@@ -4,6 +4,8 @@
 import { parseArgs } from "util";
 
 // src/commands/account.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { basename } from "path";
 import { resolveBaseUrl as resolveBaseUrl4 } from "@easybits.cloud/sdk";
 
 // src/args.ts
@@ -277,10 +279,33 @@ var HEADERS_ES = {
   "URL / COMMAND": "URL / COMANDO",
   VERSION: "VERSI\xD3N",
   COLUMN: "COLUMNA",
+  EVENTS: "EVENTOS",
+  FAILS: "FALLAS",
+  SCOPES: "PERMISOS",
+  ROOT: "RA\xCDZ",
+  PREFIX: "PREFIJO",
   PERMANENT: "PERMANENTES",
   EXPIRING: "CADUCAN",
   EXTERNAL: "DE FUERA",
-  EMPTY: "VAC\xCDAS"
+  EMPTY: "VAC\xCDAS",
+  VALUE: "VALOR",
+  DAY: "D\xCDA",
+  CONSISTENCY: "CONSISTENCIA",
+  RESERVED: "RESERVADA",
+  MEMORY: "MEMORIA",
+  DISK: "DISCO",
+  "LAST USED": "\xDALTIMO USO",
+  EXIT: "C\xD3DIGO",
+  STARTED: "INICI\xD3",
+  OUTPUT: "SALIDA",
+  COMMAND: "COMANDO",
+  DATE: "FECHA",
+  AUTHOR: "AUTOR",
+  PAGES: "P\xC1GINAS",
+  SCENES: "ESCENAS",
+  DURATION: "DURACI\xD3N",
+  NARRATION: "NARRACI\xD3N",
+  PROMPT: "PROMPT"
 };
 function table(rows, cols, empty = t("Nothing here yet.", "Todav\xEDa no hay nada.")) {
   if (lang() === "es") cols = cols.map(([k, l]) => [k, HEADERS_ES[l] ?? l]);
@@ -533,6 +558,113 @@ async function api(ctx, method, path, body, opts = {}) {
 }
 var encodePath = (p) => p.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
 
+// src/prompt.ts
+import { createInterface } from "readline/promises";
+var YES_OPTION = {
+  yes: { type: "boolean", short: "y", description: "Skip the confirmation (required without a terminal or with --json)" }
+};
+function sameCommand(argv2 = process.argv.slice(2)) {
+  const quoted = argv2.map((a) => /^[\w@%+=:,./-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`);
+  return `easybits ${quoted.join(" ")}`;
+}
+function applyCommand(argv2, opts) {
+  const rest = argv2.filter((a) => a !== "--dry-run");
+  const hasYes = rest.some((a) => a === "--yes" || a === "-y");
+  return `${sameCommand(rest)}${opts.needsYes && opts.headless && !hasYes ? " --yes" : ""}`;
+}
+function applyHint(ctx, opts = {}) {
+  const cmd = applyCommand(process.argv.slice(2), { headless: !interactive(ctx), needsYes: opts.needsYes });
+  return t(`To apply: ${cmd}`, `Para aplicarlo: ${cmd}`);
+}
+async function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return (await rl.question(question)).trim();
+  } catch {
+    process.stderr.write("\n");
+    return "";
+  } finally {
+    rl.close();
+  }
+}
+function requireYesIfHeadless(ctx) {
+  if (bool(ctx, "yes") || interactive(ctx)) return;
+  throw new CliError(t("--yes required when not running interactively.", "Sin terminal hace falta --yes."), EXIT.USAGE, `${t("Run", "Corre")}: ${sameCommand()} --yes`, "usage");
+}
+async function confirm(ctx, action, opts = {}) {
+  if (bool(ctx, "yes")) return;
+  requireYesIfHeadless(ctx);
+  if (opts.typeName) {
+    process.stderr.write(`${action}
+${t("This cannot be undone.", "No se puede deshacer.")}
+`);
+    const answer2 = await ask(t(`Type "${opts.typeName}" to confirm: `, `Teclea "${opts.typeName}" para confirmar: `));
+    if (answer2 !== opts.typeName) throw new CliError(t("Aborted: the name did not match.", "Cancelado: el nombre no coincide."), EXIT.USAGE, void 0, "aborted");
+    return;
+  }
+  const answer = await ask(`${action} ${t("[y/N]", "[s/N]")} `);
+  if (!/^(y(es)?|s[ií]?)$/i.test(answer)) throw new CliError(t("Aborted.", "Cancelado."), EXIT.USAGE, void 0, "aborted");
+}
+
+// src/sitefiles.ts
+import { readdirSync, statSync } from "fs";
+import { extname, join as join2, relative, sep } from "path";
+var MIME = {
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  json: "application/json",
+  map: "application/json",
+  webmanifest: "application/manifest+json",
+  xml: "application/xml",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  pdf: "application/pdf",
+  zip: "application/zip",
+  wasm: "application/wasm"
+};
+function mimeOf(path) {
+  return MIME[extname(path).slice(1).toLowerCase()] ?? "application/octet-stream";
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+function walkSite(dir) {
+  const out = [];
+  const visit = (d) => {
+    for (const e of readdirSync(d, { withFileTypes: true })) {
+      if (e.name.startsWith(".") || SKIP_DIRS.has(e.name)) continue;
+      const full = join2(d, e.name);
+      if (e.isDirectory()) visit(full);
+      else if (e.isFile()) out.push({ path: relative(dir, full).split(sep).join("/"), local: full, size: statSync(full).size });
+    }
+  };
+  visit(dir);
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+function sitePath(p) {
+  const clean = p.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!clean || clean.split("/").some((s) => s === ".." || s === "")) return null;
+  return clean;
+}
+
 // src/commands/account.ts
 var login = {
   name: "login",
@@ -625,8 +757,8 @@ Webhooks: ${u.counts.webhooks}`
 var websites = {
   name: "websites",
   group: "Storage",
-  summary: "Static websites: list, create, change slug",
-  synopsis: "websites <ls|create|slug>",
+  summary: "Static websites: list, create, upload, deploy a folder, delete",
+  synopsis: "websites",
   subs: {
     ls: {
       aliases: ["list"],
@@ -670,10 +802,136 @@ var websites = {
         const { website } = await api(ctx, "PATCH", `/websites/${websiteId}`, { slug });
         emit(ctx, website, () => console.log(t(`Slug changed \u2192 ${website.url}`, `Slug cambiado \u2192 ${website.url}`)));
       }
+    },
+    get: {
+      aliases: ["show"],
+      summary: "Show one website (by slug or id)",
+      usage: "easybits websites get <website>",
+      examples: ["easybits websites get mi-tienda", "easybits websites get mi-tienda --json"],
+      async run(ctx) {
+        const w = await api(ctx, "GET", `/websites/${await resolveWebsiteId(ctx, need(ctx, 0, "website", this.usage))}`);
+        emit(ctx, w, () => {
+          console.log(`ID:        ${w.id}`);
+          console.log(`${t("Name:     ", "Nombre:   ")} ${w.name}`);
+          console.log(`Slug:      ${w.slug}`);
+          console.log(`${t("Status:   ", "Estado:   ")} ${w.status}`);
+          console.log(`${t("Files:    ", "Archivos: ")} ${w.fileCount ?? 0} (${fmtBytes(w.totalSize ?? 0)})`);
+          console.log(`URL:       ${w.url}`);
+          console.log(`${t("Created:  ", "Creado:   ")} ${fmtDate(w.createdAt)}`);
+        });
+      }
+    },
+    files: {
+      summary: "List a website's files (paths inside the site)",
+      usage: "easybits websites files [ls] <website>",
+      examples: ["easybits websites files ls mi-tienda", "easybits websites files mi-tienda --json"],
+      async run(ctx) {
+        if (ctx.args[0] === "ls" || ctx.args[0] === "list") ctx.args.shift();
+        const id = await resolveWebsiteId(ctx, need(ctx, 0, "website", this.usage));
+        const w = await api(ctx, "GET", `/websites/${id}`);
+        const items = [];
+        for (let cursor; ; ) {
+          const page = await api(ctx, "GET", `/websites/${id}/files?limit=100${cursor ? `&cursor=${cursor}` : ""}`);
+          items.push(...page.items);
+          if (!page.hasMore || !page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+        const rows = items.map((f) => ({ ...f, path: w.prefix && f.name.startsWith(w.prefix) ? f.name.slice(w.prefix.length) : f.name })).sort((a, b) => a.path.localeCompare(b.path));
+        emit(
+          ctx,
+          rows,
+          () => table(
+            rows.map((f) => ({ ...f, size: fmtBytes(f.size), createdAt: fmtDate(f.createdAt) })),
+            [["path", "PATH"], ["size", "SIZE"], ["contentType", "TYPE"], ["createdAt", "CREATED"]],
+            t(`No files yet. Upload a folder: easybits websites deploy ${w.slug} ./dist`, `Todav\xEDa no hay archivos. Sube una carpeta: easybits websites deploy ${w.slug} ./dist`)
+          )
+        );
+      }
+    },
+    upload: {
+      summary: "Upload one file to a website (public; replaces the same path)",
+      usage: "easybits websites upload <website> <local-file> [--path <path-in-site>]",
+      options: { path: { type: "string", value: "path", description: "Path inside the site (default: the file name), e.g. img/hero.jpg" } },
+      examples: ["easybits websites upload mi-tienda ./index.html", "easybits websites upload mi-tienda ./hero.jpg --path img/hero.jpg"],
+      async run(ctx) {
+        const ref = need(ctx, 0, "website", this.usage);
+        const local = need(ctx, 1, "local-file", this.usage);
+        if (!existsSync2(local) || !statSync2(local).isFile()) throw usageError(t(`File not found: ${local}`, `No existe el archivo: ${local}`), this.usage);
+        const path = sitePath(str(ctx, "path") ?? basename(local));
+        if (!path) throw usageError(t("--path must be a relative path inside the site (no ..).", "--path debe ser una ruta relativa dentro del sitio (sin ..)."), this.usage);
+        const size = statSync2(local).size;
+        if (size === 0) throw usageError(t(`${local} is empty.`, `${local} est\xE1 vac\xEDo.`), this.usage);
+        const id = await resolveWebsiteId(ctx, ref);
+        const r = await putSiteFile(ctx, id, path, local, size);
+        emit(ctx, r, () => console.log(t(`Uploaded ${path} (${fmtBytes(size)}) \u2192 ${r.url}`, `Subido ${path} (${fmtBytes(size)}) \u2192 ${r.url}`)));
+      }
+    },
+    deploy: {
+      summary: "Upload a whole folder (e.g. your build) keeping its paths; same paths are replaced",
+      usage: "easybits websites deploy <website> <dir> [--dry-run]",
+      options: { "dry-run": { type: "boolean", description: "List what would be uploaded; upload nothing" } },
+      examples: ["easybits websites deploy mi-tienda ./dist", "easybits websites deploy mi-tienda ./dist --dry-run"],
+      async run(ctx) {
+        const ref = need(ctx, 0, "website", this.usage);
+        const dir = need(ctx, 1, "dir", this.usage);
+        if (!existsSync2(dir) || !statSync2(dir).isDirectory()) throw usageError(t(`Not a folder: ${dir}`, `No es una carpeta: ${dir}`), this.usage);
+        const all = walkSite(dir);
+        const files3 = all.filter((f) => f.size > 0);
+        const empty = all.filter((f) => f.size === 0).map((f) => f.path);
+        if (!files3.length) throw usageError(t(`Nothing to upload in ${dir} (hidden files and node_modules are skipped).`, `Nada que subir en ${dir} (se saltan los ocultos y node_modules).`), this.usage);
+        if (!files3.some((f) => f.path === "index.html")) console.error(t("Note: no index.html at the top of the folder; /s/<slug>/ will not have a home page.", "Ojo: no hay index.html en la ra\xEDz de la carpeta; /s/<slug>/ no tendr\xE1 p\xE1gina de inicio."));
+        const id = await resolveWebsiteId(ctx, ref);
+        if (bool(ctx, "dry-run")) {
+          emit(ctx, { websiteId: id, files: files3.map(({ path, size }) => ({ path, size })), skippedEmpty: empty }, () => {
+            for (const f of files3) console.log(`  ${f.path}  ${fmtBytes(f.size)}`);
+            console.log(t(`${files3.length} files, ${fmtBytes(files3.reduce((s, f) => s + f.size, 0))}. Nothing uploaded (--dry-run).`, `${files3.length} archivos, ${fmtBytes(files3.reduce((s, f) => s + f.size, 0))}. No se subi\xF3 nada (--dry-run).`));
+          });
+          return;
+        }
+        const done = [];
+        let next = 0;
+        const worker = async () => {
+          while (next < files3.length) {
+            const f = files3[next++];
+            done.push(await putSiteFile(ctx, id, f.path, f.local, f.size));
+            if (!ctx.json) process.stderr.write(`  ${f.path}
+`);
+          }
+        };
+        await Promise.all(Array.from({ length: Math.min(4, files3.length) }, worker));
+        const w = await api(ctx, "GET", `/websites/${id}`);
+        emit(ctx, { websiteId: id, url: w.url, uploaded: done.sort((a, b) => a.path.localeCompare(b.path)), skippedEmpty: empty }, () => {
+          if (empty.length) console.error(t(`Skipped empty files: ${empty.join(", ")}`, `Se saltaron archivos vac\xEDos: ${empty.join(", ")}`));
+          console.log(t(`Deployed ${done.length} files \u2192 ${w.url}`, `Publicados ${done.length} archivos \u2192 ${w.url}`));
+        });
+      }
+    },
+    rm: {
+      aliases: ["delete", "remove"],
+      summary: "Delete a website and its files (asks you to type the slug)",
+      usage: "easybits websites rm <website> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits websites rm mi-tienda", "easybits websites rm mi-tienda --yes"],
+      async run(ctx) {
+        const ref = need(ctx, 0, "website", this.usage);
+        requireYesIfHeadless(ctx);
+        const id = await resolveWebsiteId(ctx, ref);
+        const w = await api(ctx, "GET", `/websites/${id}`);
+        await confirm(ctx, t(`Delete website ${w.slug} (${w.fileCount ?? 0} files) at ${w.url}?`, `\xBFBorrar el sitio ${w.slug} (${w.fileCount ?? 0} archivos) en ${w.url}?`), { typeName: w.slug });
+        const r = await api(ctx, "DELETE", `/websites/${id}`);
+        emit(ctx, { ...r, id, slug: w.slug }, () => console.log(t(`Deleted ${w.slug}`, `Borrado ${w.slug}`)));
+      }
     }
   },
   defaultSub: "ls"
 };
+async function putSiteFile(ctx, websiteId, path, local, size) {
+  const contentType = mimeOf(path);
+  const r = await api(ctx, "POST", `/websites/${websiteId}/files`, { fileName: path, contentType, size });
+  const res = await fetch(r.putUrl, { method: "PUT", body: readFileSync3(local), headers: { "Content-Type": contentType } });
+  if (!res.ok) throw new CliError(t(`Upload of ${path} failed: storage answered ${res.status}`, `Fall\xF3 la subida de ${path}: el almacenamiento contest\xF3 ${res.status}`), EXIT.API, void 0, "upload_failed", res.status);
+  return { path, fileId: r.file.id, url: r.file.url, size, contentType };
+}
 function matchWebsite(ref, items) {
   if (/^[0-9a-f]{24}$/i.test(ref)) return ref;
   const r = ref.trim().toLowerCase();
@@ -772,59 +1030,9 @@ var whoami = {
 };
 
 // src/commands/files.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "fs";
-import { basename, extname } from "path";
-
-// src/prompt.ts
-import { createInterface } from "readline/promises";
-var YES_OPTION = {
-  yes: { type: "boolean", short: "y", description: "Skip the confirmation (required without a terminal or with --json)" }
-};
-function sameCommand(argv2 = process.argv.slice(2)) {
-  const quoted = argv2.map((a) => /^[\w@%+=:,./-]+$/.test(a) ? a : `'${a.replace(/'/g, `'\\''`)}'`);
-  return `easybits ${quoted.join(" ")}`;
-}
-function applyCommand(argv2, opts) {
-  const rest = argv2.filter((a) => a !== "--dry-run");
-  const hasYes = rest.some((a) => a === "--yes" || a === "-y");
-  return `${sameCommand(rest)}${opts.needsYes && opts.headless && !hasYes ? " --yes" : ""}`;
-}
-function applyHint(ctx, opts = {}) {
-  const cmd = applyCommand(process.argv.slice(2), { headless: !interactive(ctx), needsYes: opts.needsYes });
-  return t(`To apply: ${cmd}`, `Para aplicarlo: ${cmd}`);
-}
-async function ask(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    return (await rl.question(question)).trim();
-  } catch {
-    process.stderr.write("\n");
-    return "";
-  } finally {
-    rl.close();
-  }
-}
-function requireYesIfHeadless(ctx) {
-  if (bool(ctx, "yes") || interactive(ctx)) return;
-  throw new CliError(t("--yes required when not running interactively.", "Sin terminal hace falta --yes."), EXIT.USAGE, `${t("Run", "Corre")}: ${sameCommand()} --yes`, "usage");
-}
-async function confirm(ctx, action, opts = {}) {
-  if (bool(ctx, "yes")) return;
-  requireYesIfHeadless(ctx);
-  if (opts.typeName) {
-    process.stderr.write(`${action}
-${t("This cannot be undone.", "No se puede deshacer.")}
-`);
-    const answer2 = await ask(t(`Type "${opts.typeName}" to confirm: `, `Teclea "${opts.typeName}" para confirmar: `));
-    if (answer2 !== opts.typeName) throw new CliError(t("Aborted: the name did not match.", "Cancelado: el nombre no coincide."), EXIT.USAGE, void 0, "aborted");
-    return;
-  }
-  const answer = await ask(`${action} ${t("[y/N]", "[s/N]")} `);
-  if (!/^(y(es)?|s[ií]?)$/i.test(answer)) throw new CliError(t("Aborted.", "Cancelado."), EXIT.USAGE, void 0, "aborted");
-}
-
-// src/commands/files.ts
-var MIME = {
+import { existsSync as existsSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { basename as basename2, extname as extname2 } from "path";
+var MIME2 = {
   pdf: "application/pdf",
   png: "image/png",
   jpg: "image/jpeg",
@@ -877,15 +1085,15 @@ var files = {
       examples: ["easybits files upload ./report.pdf", "easybits files upload ./logo.png --public --json"],
       async run(ctx) {
         const path = need(ctx, 0, "path", this.usage);
-        if (!existsSync2(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), this.usage);
-        const size = statSync(path).size;
-        const contentType = MIME[extname(path).slice(1).toLowerCase()] || "application/octet-stream";
+        if (!existsSync3(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), this.usage);
+        const size = statSync3(path).size;
+        const contentType = MIME2[extname2(path).slice(1).toLowerCase()] || "application/octet-stream";
         const eb = await getClient(ctx);
         const access = bool(ctx, "public") ? "public" : void 0;
-        const data = await eb.uploadFile({ fileName: basename(path), contentType, size, access });
+        const data = await eb.uploadFile({ fileName: basename2(path), contentType, size, access });
         const res = await fetch(data.putUrl, {
           method: "PUT",
-          body: readFileSync3(path),
+          body: readFileSync4(path),
           headers: { "Content-Type": contentType }
         });
         if (!res.ok) throw new CliError(t(`Upload failed: storage answered ${res.status}`, `Fall\xF3 la subida: el almacenamiento contest\xF3 ${res.status}`), 1, void 0, "upload_failed", res.status);
@@ -915,7 +1123,7 @@ var files = {
 };
 
 // src/commands/init.ts
-import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 var init = {
   name: "init",
   group: "Hosting",
@@ -923,16 +1131,16 @@ var init = {
   synopsis: "init",
   leaf: {
     summary: "Write the GitHub Actions workflow that deploys this repo on every push to main",
-    usage: "easybits init [--app-dir /srv/app] [--port 3000]",
+    usage: "easybits init [--app-dir /app] [--port 3000]",
     options: {
-      "app-dir": { type: "string", value: "dir", description: "Where the app lives in the machine (default /srv/app)" },
+      "app-dir": { type: "string", value: "dir", description: "Where the app lives in the machine (default /app)" },
       port: { type: "string", value: "port", description: "Port your app listens on (default 3000)" }
     },
-    examples: ["easybits init", "easybits init --app-dir /srv/app --port 8080"],
+    examples: ["easybits init", "easybits init --port 8080"],
     async run(ctx) {
-      const appDir = str(ctx, "app-dir") ?? "/srv/app";
+      const appDir = str(ctx, "app-dir") ?? "/app";
       const port = str(ctx, "port") ?? "3000";
-      if (!existsSync3("package.json")) {
+      if (!existsSync4("package.json")) {
         throw usageError(t("No package.json here. Run this at the root of your app's repo.", "Aqu\xED no hay package.json. C\xF3rrelo en la ra\xEDz del repo de tu app."), this.usage);
       }
       const workflow = `# Despliegue a EasyBits en cada push a main.
@@ -1138,8 +1346,8 @@ Desde ah\xED, cada push a main despliega.`)));
 
 // src/commands/ssh.ts
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync2 } from "fs";
 import { execFileSync } from "child_process";
 var SSH_CONFIG_SNIPPET = `Host *.ghosty
     ProxyCommand easybits ssh-proxy %h
@@ -1154,17 +1362,17 @@ var sshKey = {
     usage: "easybits ssh-key",
     examples: ["easybits ssh-key"],
     async run(ctx) {
-      const dir = join2(homedir2(), ".ssh");
-      const key = join2(dir, "easybits_ed25519");
+      const dir = join3(homedir2(), ".ssh");
+      const key = join3(dir, "easybits_ed25519");
       const pub = `${key}.pub`;
-      if (!existsSync4(pub)) {
+      if (!existsSync5(pub)) {
         mkdirSync2(dir, { recursive: true, mode: 448 });
         execFileSync("ssh-keygen", ["-t", "ed25519", "-N", "", "-f", key, "-C", "easybits"], {
           stdio: ["ignore", "ignore", "inherit"]
         });
         console.error(t(`easybits: key created at ${key}`, `easybits: llave creada en ${key}`));
       }
-      const publicKey = readFileSync4(pub, "utf8").trim();
+      const publicKey = readFileSync5(pub, "utf8").trim();
       if (ctx.json) process.stdout.write(JSON.stringify({ publicKey, path: pub }, null, 2) + "\n");
       else process.stdout.write(publicKey + "\n");
     }
@@ -1216,7 +1424,234 @@ var sshProxy = {
 };
 
 // src/commands/sandboxes.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+
+// src/commands/domains.ts
+import { EasybitsError as EasybitsError3 } from "@easybits.cloud/sdk";
+function matchDomain(ref, items) {
+  if (/^[0-9a-f]{24}$/i.test(ref)) return ref;
+  const r = ref.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+  return items.find((d) => d.domain === r)?.id ?? null;
+}
+async function listDomains(ctx) {
+  return (await api(ctx, "GET", "/domains")).domains;
+}
+async function resolveDomain(ctx, ref) {
+  if (/^[0-9a-f]{24}$/i.test(ref)) return { id: ref };
+  const items = await listDomains(ctx);
+  const id = matchDomain(ref, items);
+  if (id) return { id, row: items.find((d) => d.id === id) };
+  throw new CliError(
+    t(`No domain "${ref}" in your account.`, `No hay dominio "${ref}" en tu cuenta.`),
+    EXIT.API,
+    `${t("List them with", "Enl\xEDstalos con")}: easybits domains ls`,
+    "not_found",
+    404
+  );
+}
+function dnsLines(records, apexNames) {
+  return records.map((r) => {
+    const opt = apexNames.has(r.name) ? t("   (only to serve a site at the root)", "   (s\xF3lo para servir un sitio en la ra\xEDz)") : "";
+    return `  ${r.type.padEnd(6)}${r.name.padEnd(40)}${r.values.join(" ")}${opt}`;
+  });
+}
+function printDns(d) {
+  if (!d.dns?.length) return;
+  const apex = /* @__PURE__ */ new Set([d.domain, `www.${d.domain}`]);
+  console.log(t("Create these DNS records at your DNS provider:", "Crea estos registros DNS en tu proveedor de DNS:"));
+  for (const l of dnsLines(d.dns, apex)) console.log(l);
+}
+var domains = {
+  name: "domains",
+  aliases: ["domain"],
+  group: "Hosting",
+  summary: "Your own domains for your websites (sandbox ports: sandboxes domains)",
+  synopsis: "domains",
+  subs: {
+    ls: {
+      aliases: ["list"],
+      summary: "List the custom domains of your account",
+      usage: "easybits domains ls",
+      examples: ["easybits domains ls", "easybits domains ls --json"],
+      async run(ctx) {
+        const items = await listDomains(ctx);
+        emit(
+          ctx,
+          items,
+          () => table(
+            items.map((d) => ({
+              ...d,
+              status: d.verified ? t("verified", "verificado") : t("pending", "pendiente"),
+              root: d.apexWebsite?.slug ?? "-",
+              dnsBy: d.dnsProvider ?? t("manual", "a mano"),
+              createdAt: fmtDate(d.createdAt)
+            })),
+            [["id", "ID"], ["domain", "DOMAIN"], ["status", "STATUS"], ["root", "ROOT"], ["dnsBy", "DNS"], ["createdAt", "CREATED"]],
+            t("No custom domains. Add one: easybits domains add example.com", "Sin dominios propios. Agrega uno: easybits domains add midominio.com")
+          )
+        );
+      }
+    },
+    add: {
+      summary: "Register a domain; prints the DNS records to create",
+      usage: "easybits domains add <domain>",
+      examples: ["easybits domains add example.com", "easybits domains add example.com --json | jq .dns"],
+      async run(ctx) {
+        const name = need(ctx, 0, "domain", this.usage);
+        const { domain } = await api(ctx, "POST", "/domains", { domain: name });
+        emit(ctx, domain, () => {
+          console.log(t(`Added ${domain.domain} (${domain.id})`, `Agregado ${domain.domain} (${domain.id})`));
+          printDns(domain);
+          console.log(
+            t(
+              `Then run: easybits domains verify ${domain.domain}   (DNS in Mailmask? easybits domains dns-auto ${domain.domain})`,
+              `Luego corre: easybits domains verify ${domain.domain}   (\xBFDNS en Mailmask? easybits domains dns-auto ${domain.domain})`
+            )
+          );
+        });
+      }
+    },
+    verify: {
+      summary: "Check the TXT record and issue the certificate",
+      usage: "easybits domains verify <domain>",
+      examples: ["easybits domains verify example.com"],
+      async run(ctx) {
+        const { id } = await resolveDomain(ctx, need(ctx, 0, "domain", this.usage));
+        const { domain } = await api(ctx, "POST", `/domains/${id}/verify`);
+        emit(ctx, domain, () => console.log(t(`${domain.domain}: verified. Your sites answer at <slug>.${domain.domain}`, `${domain.domain}: verificado. Tus sitios responden en <slug>.${domain.domain}`)));
+      }
+    },
+    "dns-auto": {
+      summary: "Write the DNS records into your Mailmask zone and verify (--undo restores)",
+      usage: "easybits domains dns-auto <domain> [--undo]",
+      options: { undo: { type: "boolean", description: "Restore the records EasyBits wrote (keeps the ones you changed)" } },
+      examples: ["easybits domains dns-auto example.com", "easybits domains dns-auto example.com --undo"],
+      async run(ctx) {
+        const { id } = await resolveDomain(ctx, need(ctx, 0, "domain", this.usage));
+        const undo = bool(ctx, "undo");
+        try {
+          const r = await api(ctx, undo ? "DELETE" : "POST", `/domains/${id}/dns-auto`);
+          emit(ctx, r, () => {
+            if (undo) {
+              console.log(r.nothing ? t("Nothing to undo.", "Nada que deshacer.") : t("Records restored.", "Registros restaurados."));
+              if (r.skipped?.length) console.log(t(`Left alone (you changed them): ${r.skipped.join(", ")}`, `Sin tocar (los cambiaste t\xFA): ${r.skipped.join(", ")}`));
+            } else {
+              console.log(t(`Wrote ${r.records?.join(", ")} in zone ${r.zone}`, `Escrib\xED ${r.records?.join(", ")} en la zona ${r.zone}`));
+              console.log(r.verified ? t("Verified.", "Verificado.") : t("Not verified yet (DNS still propagating): run easybits domains verify in a minute.", "Todav\xEDa no verifica (el DNS sigue propagando): corre easybits domains verify en un minuto."));
+            }
+          });
+        } catch (e) {
+          const body = e instanceof EasybitsError3 && e.status === 409 ? String(e.body ?? "") : "";
+          const m = /"connectUrl"\s*:\s*"([^"]+)"/.exec(body);
+          if (m) {
+            throw new CliError(
+              t("Mailmask is not connected to your account.", "Mailmask no est\xE1 conectado a tu cuenta."),
+              EXIT.API,
+              t(`Open this once in your browser to connect it, then run the command again:
+  ${m[1]}`, `Abre esto una vez en tu navegador para conectarlo y vuelve a correr el comando:
+  ${m[1]}`),
+              "mailmask_not_connected",
+              409
+            );
+          }
+          throw e;
+        }
+      }
+    },
+    apex: {
+      aliases: ["assign"],
+      summary: "Serve one of your websites at the root domain and www (--clear removes it)",
+      usage: "easybits domains apex <domain> <website|--clear>",
+      options: { clear: { type: "boolean", description: "Stop serving a website at the root" } },
+      examples: ["easybits domains apex example.com mi-tienda", "easybits domains apex example.com --clear"],
+      async run(ctx) {
+        const ref = need(ctx, 0, "domain", this.usage);
+        const clear = bool(ctx, "clear");
+        if (!clear && !ctx.args[1]) throw usageError(t("Missing <website> (or pass --clear).", "Falta <website> (o pasa --clear)."), this.usage);
+        if (clear && ctx.args[1]) throw usageError(t("Pass a <website> or --clear, not both.", "Pasa un <website> o --clear, no ambos."), this.usage);
+        const { id } = await resolveDomain(ctx, ref);
+        const websiteId = clear ? null : await resolveWebsiteId(ctx, ctx.args[1]);
+        const { domain } = await api(ctx, "POST", `/domains/${id}/apex`, { websiteId });
+        emit(
+          ctx,
+          domain,
+          () => console.log(
+            domain.apexWebsite ? t(`${domain.domain} and www.${domain.domain} \u2192 ${domain.apexWebsite.slug}`, `${domain.domain} y www.${domain.domain} \u2192 ${domain.apexWebsite.slug}`) : t(`${domain.domain}: no website at the root.`, `${domain.domain}: sin sitio en la ra\xEDz.`)
+          )
+        );
+      }
+    },
+    rm: {
+      aliases: ["remove", "delete"],
+      summary: "Remove a domain: unlinks its websites and deletes its certificates",
+      usage: "easybits domains rm <domain> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits domains rm example.com", "easybits domains rm example.com --yes"],
+      async run(ctx) {
+        const ref = need(ctx, 0, "domain", this.usage);
+        requireYesIfHeadless(ctx);
+        const { id, row } = await resolveDomain(ctx, ref);
+        const name = row?.domain ?? ref;
+        await confirm(ctx, t(`Remove ${name}? Its websites stop answering on it right away.`, `\xBFQuitar ${name}? Sus sitios dejan de responder en \xE9l de inmediato.`));
+        const r = await api(ctx, "DELETE", "/domains", { domainId: id });
+        emit(ctx, { ...r, domainId: id, domain: name }, () => console.log(t(`Removed ${name}`, `Quitado ${name}`)));
+      }
+    }
+  }
+};
+var SANDBOX_DOMAINS_USAGE = "easybits sandboxes domains <ls|add|verify|rm> <sandbox> [domain] [--port <port>] [--yes]";
+var sandboxDomains = {
+  summary: "Custom domains with auto TLS on a sandbox or machine port",
+  usage: SANDBOX_DOMAINS_USAGE,
+  options: {
+    port: { type: "string", value: "port", description: "add: port inside the sandbox (required)" },
+    ...YES_OPTION
+  },
+  examples: [
+    "easybits sandboxes domains ls sb_abc123",
+    "easybits sb domains add sb_abc123 shop.example.com --port 3000",
+    "easybits sb domains verify sb_abc123 shop.example.com",
+    "easybits sb domains rm sb_abc123 shop.example.com --yes"
+  ],
+  async run(ctx) {
+    const action = need(ctx, 0, "ls|add|verify|rm", SANDBOX_DOMAINS_USAGE);
+    const id = need(ctx, 1, "sandbox", SANDBOX_DOMAINS_USAGE);
+    if (action === "ls" || action === "list") {
+      const sb = await (await getClient(ctx)).sandboxes.get(id);
+      const items = await sb.listDomains();
+      emit(ctx, items, () => table(items, [["domain", "DOMAIN"], ["port", "PORT"]], t("No custom domains.", "Sin dominios propios.")));
+      return;
+    }
+    const domain = need(ctx, 2, "domain", SANDBOX_DOMAINS_USAGE);
+    if (action === "add") {
+      const port = int(ctx, "port", SANDBOX_DOMAINS_USAGE);
+      if (port == null) throw usageError(t("Missing --port.", "Falta --port."), SANDBOX_DOMAINS_USAGE);
+      const r = await (await (await getClient(ctx)).sandboxes.get(id)).addDomain(domain, port);
+      emit(ctx, r, () => {
+        console.log(t(`Attached ${r.domain} \u2192 port ${r.port}`, `Ligado ${r.domain} \u2192 puerto ${r.port}`));
+        console.log(t(`Create this DNS record: ${JSON.stringify(r.dns)}`, `Crea este registro DNS: ${JSON.stringify(r.dns)}`));
+        console.log(t(`Then run: easybits sandboxes domains verify ${id} ${r.domain}`, `Luego corre: easybits sandboxes domains verify ${id} ${r.domain}`));
+      });
+    } else if (action === "verify") {
+      const r = await (await (await getClient(ctx)).sandboxes.get(id)).verifyDomain(domain);
+      emit(ctx, r, () => {
+        console.log(`${r.domain}: ${r.ready ? t("ready", "listo") : t("not ready yet", "todav\xEDa no est\xE1 listo")}`);
+        console.log(t(`DNS resolved: ${r.dns.resolved}  HTTPS ok: ${r.https.ok}`, `DNS resuelve: ${r.dns.resolved}  HTTPS ok: ${r.https.ok}`));
+        if (r.hint) console.log(r.hint);
+      });
+      if (!r.ready) process.exitCode = 1;
+    } else if (action === "rm" || action === "remove" || action === "delete") {
+      requireYesIfHeadless(ctx);
+      await confirm(ctx, t(`Detach ${domain} from ${id}? It stops serving right away.`, `\xBFDesligar ${domain} de ${id}? Deja de servir de inmediato.`));
+      const r = await (await (await getClient(ctx)).sandboxes.get(id)).removeDomain(domain);
+      emit(ctx, r, () => console.log(t(`Removed ${domain}`, `Quitado ${domain}`)));
+    } else {
+      throw usageError(t(`Unknown domains action "${action}".`, `Acci\xF3n de domains desconocida "${action}".`), SANDBOX_DOMAINS_USAGE);
+    }
+  }
+};
+
+// src/commands/sandboxes.ts
 function sandboxRecord(s) {
   return {
     sandboxId: s.sandboxId,
@@ -1258,7 +1693,60 @@ function checkNotTruncated(size, path) {
     "truncated"
   );
 }
-var FILES_USAGE = "easybits sandboxes files <ls|read|write> <sandbox> <path> [local-file]";
+var BG_USAGE = "easybits sandboxes bg <start|ls|status|kill> <sandbox> [exec-id] [--cwd <dir>] [--dotenv <path>] [--grace <s>] [-- <command...>]";
+var GIT_OPS = ["clone", "status", "commit", "push", "pull", "checkout", "log"];
+var GIT_USAGE = `easybits sandboxes git <${GIT_OPS.join("|")}> <sandbox> --dir <dir> [flags]`;
+function gitParams(op, f) {
+  if (!GIT_OPS.includes(op)) throw usageError(t(`Unknown git operation "${op}".`, `Operaci\xF3n de git desconocida "${op}".`), GIT_USAGE);
+  if (!f.dir) throw usageError(t("Missing --dir (the repo folder inside the sandbox).", "Falta --dir (la carpeta del repo dentro del sandbox)."), GIT_USAGE);
+  if (f.token && !f.token.startsWith("$secret:")) {
+    process.stderr.write(t("Warning: a literal token in argv shows up in ps and shell history; prefer --git-token '$secret:NAME'.\n", "Aviso: un token literal en argv se ve en ps y el historial; mejor --git-token '$secret:NOMBRE'.\n"));
+  }
+  const clean = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0 && v !== false && !(Array.isArray(v) && !v.length)));
+  const auth = { token: f.token, username: f.username };
+  switch (op) {
+    case "clone":
+      if (!f.repo) throw usageError(t("clone needs --repo <url>.", "clone necesita --repo <url>."), GIT_USAGE);
+      return clean({ repo: f.repo, dir: f.dir, branch: f.branch, depth: f.depth, commit: f.sha, ...auth });
+    case "status":
+      return { dir: f.dir };
+    case "commit":
+      if (!f.message) throw usageError(t("commit needs -m <message>.", "commit necesita -m <mensaje>."), GIT_USAGE);
+      return clean({ dir: f.dir, message: f.message, addAll: f.all, paths: f.paths, authorName: f.authorName, authorEmail: f.authorEmail });
+    case "push":
+      return clean({ dir: f.dir, remote: f.remote, branch: f.branch, setUpstream: f.setUpstream, force: f.force, ...auth });
+    case "pull":
+      return clean({ dir: f.dir, rebase: f.rebase, ...auth });
+    case "checkout":
+      if (!f.branch) throw usageError(t("checkout needs --branch <name>.", "checkout necesita --branch <nombre>."), GIT_USAGE);
+      return clean({ dir: f.dir, branch: f.branch, create: f.create, from: f.from });
+    default:
+      return clean({ dir: f.dir, limit: f.limit, path: f.paths?.[0] });
+  }
+}
+function printGit(op, r) {
+  if (op === "clone") console.log(t(`Cloned ${r.remote} \u2192 ${r.dir} (${r.detached ? "detached" : r.branch} @ ${String(r.head).slice(0, 7)})`, `Clonado ${r.remote} \u2192 ${r.dir} (${r.detached ? "desprendido" : r.branch} @ ${String(r.head).slice(0, 7)})`));
+  else if (op === "status") {
+    console.log(`${r.branch}${r.upstream ? ` \u2192 ${r.upstream}` : ""}${r.ahead || r.behind ? `  +${r.ahead} -${r.behind}` : ""}${r.clean ? t("  (clean)", "  (limpio)") : ""}`);
+    for (const [k, label] of [["staged", "staged"], ["modified", "modified"], ["untracked", "untracked"], ["conflicted", "conflicted"]]) {
+      if (r[k]?.length) console.log(`  ${label}: ${r[k].join(", ")}`);
+    }
+  } else if (op === "commit") console.log(r.nothingToCommit ? t("Nothing to commit.", "Nada que commitear.") : `${t("Committed", "Commit")} ${String(r.sha).slice(0, 7)}`);
+  else if (op === "push") console.log(r.pushed ? t(`Pushed ${r.branch} to ${r.remote}`, `Subido ${r.branch} a ${r.remote}`) : r.output);
+  else if (op === "pull") {
+    console.log(r.updated ? t(`Updated to ${String(r.head).slice(0, 7)}`, `Actualizado a ${String(r.head).slice(0, 7)}`) : t("Already up to date.", "Ya estaba al d\xEDa."));
+    if (r.conflicts?.length) console.log(t(`Conflicts: ${r.conflicts.join(", ")}`, `Conflictos: ${r.conflicts.join(", ")}`));
+  } else if (op === "checkout") console.log(t(`On ${r.branch}${r.created ? " (new)" : ""}`, `En ${r.branch}${r.created ? " (nueva)" : ""}`));
+  else
+    table(
+      r.items.map((e) => ({ ...e, sha: String(e.sha).slice(0, 7), date: fmtDate(e.date) })),
+      [["sha", "SHA"], ["date", "DATE"], ["author", "AUTHOR"], ["message", "MESSAGE"]]
+    );
+}
+async function sandboxAt(ctx, i, usage2) {
+  return (await getClient(ctx)).sandboxes.get(need(ctx, i, "sandbox", usage2));
+}
+var FILES_USAGE = "easybits sandboxes files <ls|read|write|rm|mv|mkdir> <sandbox> <path> [local-file|new-path]";
 var sandboxes = {
   name: "sandboxes",
   aliases: ["sandbox", "sb"],
@@ -1389,21 +1877,27 @@ var sandboxes = {
       }
     },
     files: {
-      summary: "List, read or write files inside a sandbox",
+      summary: "List, read, write, delete, move files and make folders inside a sandbox",
       usage: FILES_USAGE,
       options: {
         content: { type: "string", value: "text", description: "write: inline content instead of a local file" },
-        out: { type: "string", value: "file", description: "read: save to a local file (binary-safe)" }
+        out: { type: "string", value: "file", description: "read: save to a local file (binary-safe)" },
+        recursive: { type: "boolean", short: "r", description: "rm: a folder and everything in it" },
+        ...YES_OPTION
       },
       examples: [
         "easybits sandboxes files ls sb_abc123 /data/work",
         "easybits sb files read sb_abc123 /etc/os-release",
         "easybits sb files read sb_abc123 /data/out.png --out out.png",
         "easybits sb files write sb_abc123 /data/work/app.js ./app.js",
-        "echo hello | easybits sb files write sb_abc123 /tmp/hello.txt"
+        "echo hello | easybits sb files write sb_abc123 /tmp/hello.txt",
+        "easybits sb files mkdir sb_abc123 /data/work/out",
+        "easybits sb files mv sb_abc123 /data/work/a.txt /data/work/out/a.txt",
+        "easybits sb files rm sb_abc123 /data/work/tmp -r --yes"
       ],
       async run(ctx) {
-        const action = need(ctx, 0, "ls|read|write", FILES_USAGE);
+        const action = need(ctx, 0, "ls|read|write|rm|mv|mkdir", FILES_USAGE);
+        if (action === "rm" || action === "delete") requireYesIfHeadless(ctx);
         const id = need(ctx, 1, "sandbox", FILES_USAGE);
         const path = need(ctx, 2, "path", FILES_USAGE);
         const eb = await getClient(ctx);
@@ -1437,17 +1931,30 @@ var sandboxes = {
           let buf;
           if (inline != null) buf = Buffer.from(inline, "utf8");
           else if (local) {
-            if (!existsSync5(local)) throw usageError(t(`File not found: ${local}`, `No existe el archivo: ${local}`), FILES_USAGE);
-            buf = readFileSync5(local);
+            if (!existsSync6(local)) throw usageError(t(`File not found: ${local}`, `No existe el archivo: ${local}`), FILES_USAGE);
+            buf = readFileSync6(local);
           } else if (!process.stdin.isTTY) buf = await readStdin();
           else throw usageError(t("Give a local file, --content, or pipe data on stdin.", "Pasa un archivo local, --content, o datos por stdin."), FILES_USAGE);
           const r = await sb.files.write(path, buf.toString("base64"), { encoding: "base64" });
           emit(ctx, { path, ...r }, () => console.log(t(`Wrote ${fmtBytes(r.bytes)} to ${path}`, `Escrib\xED ${fmtBytes(r.bytes)} en ${path}`)));
+        } else if (action === "rm" || action === "delete") {
+          const recursive = bool(ctx, "recursive");
+          await confirm(ctx, t(`Delete ${path}${recursive ? " and everything in it" : ""} in ${id}?`, `\xBFBorrar ${path}${recursive ? " y todo lo que tiene" : ""} en ${id}?`));
+          const r = await sb.files.delete(path, recursive ? { recursive } : void 0);
+          emit(ctx, { path, ...r }, () => console.log(t(`Deleted ${path}`, `Borrado ${path}`)));
+        } else if (action === "mv" || action === "move") {
+          const to = need(ctx, 3, "new-path", FILES_USAGE);
+          const r = await sb.files.move(path, to);
+          emit(ctx, { from: path, to, ...r }, () => console.log(`${path} \u2192 ${to}`));
+        } else if (action === "mkdir") {
+          const r = await sb.files.mkdir(path);
+          emit(ctx, { path, ...r }, () => console.log(t(`Created ${path}`, `Creada ${path}`)));
         } else {
           throw usageError(t(`Unknown files action "${action}".`, `Acci\xF3n de files desconocida "${action}".`), FILES_USAGE);
         }
       }
     },
+    domains: sandboxDomains,
     suspend: {
       summary: "Suspend to disk (frees CPU; TTL paused)",
       usage: "easybits sandboxes suspend <sandbox>",
@@ -1490,6 +1997,129 @@ var sandboxes = {
         emit(ctx, { ...r, sandboxId: ctx.args[0] }, () => console.log(t(`Destroyed ${ctx.args[0]}`, `Destruido ${ctx.args[0]}`)));
       }
     },
+    bg: {
+      summary: "Long-running processes: start one in the background, list, poll its output, kill it",
+      usage: BG_USAGE,
+      options: {
+        cwd: { type: "string", value: "dir", description: "Working directory" },
+        env: { type: "string", multiple: true, value: "K=V", description: "Environment variable, non-secret (repeatable)" },
+        ...ENV_FILE_OPTION,
+        grace: { type: "string", value: "seconds", description: "kill: seconds between SIGTERM and SIGKILL (default 5)" }
+      },
+      examples: [
+        "easybits sb bg start sb_abc123 --cwd /data/work -- npm run dev",
+        "easybits sb bg ls sb_abc123",
+        "easybits sb bg status sb_abc123 exec_123      # status, exit code, stdout/stderr",
+        "easybits sb bg kill sb_abc123 exec_123"
+      ],
+      async run(ctx) {
+        const action = need(ctx, 0, "start|ls|status|kill", BG_USAGE);
+        need(ctx, 1, "sandbox", BG_USAGE);
+        if (action === "start") {
+          const command = ctx.args.slice(2).join(" ");
+          if (!command) throw usageError(t("Missing <command> after --.", "Falta <command> despu\xE9s de --."), BG_USAGE);
+          const env = await envFrom(ctx, BG_USAGE);
+          const sb = await sandboxAt(ctx, 1, BG_USAGE);
+          const r = await sb.execBackground(command, { cwd: str(ctx, "cwd"), env: Object.keys(env).length ? env : void 0 });
+          emit(ctx, r, () => {
+            console.log(t(`Started ${r.execId} (${r.status})`, `Arranc\xF3 ${r.execId} (${r.status})`));
+            console.log(t(`Poll it: easybits sb bg status ${ctx.args[1]} ${r.execId}`, `Rev\xEDsalo: easybits sb bg status ${ctx.args[1]} ${r.execId}`));
+          });
+        } else if (action === "ls" || action === "list") {
+          const r = await (await sandboxAt(ctx, 1, BG_USAGE)).bgList();
+          emit(
+            ctx,
+            r,
+            () => table(
+              r.processes.map((p) => ({ ...p, startedAt: fmtDate(p.startedAt), exit: p.exitCode ?? "-", output: fmtBytes(p.stdoutBytes + p.stderrBytes) })),
+              [["execId", "ID"], ["status", "STATUS"], ["exit", "EXIT"], ["startedAt", "STARTED"], ["output", "OUTPUT"], ["command", "COMMAND"]],
+              t("No background processes.", "Sin procesos en segundo plano.")
+            )
+          );
+        } else if (action === "status") {
+          const execId = need(ctx, 2, "exec-id", BG_USAGE);
+          const r = await (await sandboxAt(ctx, 1, BG_USAGE)).bgStatus(execId);
+          if (ctx.json) return emit(ctx, r, () => {
+          });
+          console.error(`${execId}: ${r.status}${r.exitCode != null ? ` (exit ${r.exitCode})` : ""}${r.logsExpired ? t(" \u2014 logs expired", " \u2014 logs vencidos") : ""}`);
+          if (r.stdout) process.stdout.write(r.stdout);
+          if (r.stderr) process.stderr.write(r.stderr);
+        } else if (action === "kill") {
+          const execId = need(ctx, 2, "exec-id", BG_USAGE);
+          const grace = int(ctx, "grace", BG_USAGE);
+          const r = await (await sandboxAt(ctx, 1, BG_USAGE)).bgKill(execId, grace != null ? { graceSeconds: grace } : void 0);
+          emit(
+            ctx,
+            { execId, ...r },
+            () => console.log(r.alreadyExited ? t(`${execId} had already exited.`, `${execId} ya hab\xEDa terminado.`) : t(`Killed ${execId} (${r.signal ?? "SIGTERM"})`, `Detenido ${execId} (${r.signal ?? "SIGTERM"})`))
+          );
+        } else {
+          throw usageError(t(`Unknown bg action "${action}".`, `Acci\xF3n de bg desconocida "${action}".`), BG_USAGE);
+        }
+      }
+    },
+    git: {
+      summary: "Git inside a sandbox: clone, status, commit, push, pull, checkout, log",
+      usage: GIT_USAGE,
+      options: {
+        dir: { type: "string", value: "dir", description: "Repo folder inside the sandbox (required)" },
+        repo: { type: "string", value: "url", description: "clone: repo URL (clean; the token goes in --git-token)" },
+        branch: { type: "string", value: "name", description: "clone/push/checkout: branch" },
+        depth: { type: "string", value: "n", description: "clone: shallow depth (default 1)" },
+        sha: { type: "string", value: "sha", description: "clone: a specific commit (full clone, detached HEAD)" },
+        "git-token": { type: "string", value: "$secret:NAME", description: "Token for a private repo; best as $secret:NAME from your vault" },
+        "git-user": { type: "string", value: "name", description: "Username for the token (default: x-access-token)" },
+        message: { type: "string", short: "m", value: "text", description: "commit: message" },
+        all: { type: "boolean", description: "commit: stage everything first (git add -A)" },
+        path: { type: "string", multiple: true, value: "path", description: "commit: only these paths (repeatable); log: only this path" },
+        "author-name": { type: "string", value: "name", description: "commit: author name" },
+        "author-email": { type: "string", value: "email", description: "commit: author email" },
+        remote: { type: "string", value: "name", description: "push: remote (default origin)" },
+        "set-upstream": { type: "boolean", description: "push: set the upstream branch" },
+        force: { type: "boolean", description: "push: --force-with-lease (fails if the remote moved)" },
+        rebase: { type: "boolean", description: "pull: rebase instead of merge" },
+        create: { type: "boolean", description: "checkout: create the branch (-B, safe to repeat)" },
+        from: { type: "string", value: "ref", description: "checkout --create: start point" },
+        limit: { type: "string", value: "n", description: "log: how many" }
+      },
+      examples: [
+        "easybits sb git clone sb_abc123 --repo https://github.com/you/app.git --dir /data/work/app --git-token '$secret:GITHUB_TOKEN'",
+        "easybits sb git status sb_abc123 --dir /data/work/app",
+        'easybits sb git commit sb_abc123 --dir /data/work/app --all -m "fix: checkout"',
+        "easybits sb git push sb_abc123 --dir /data/work/app --git-token '$secret:GITHUB_TOKEN'",
+        "easybits sb git checkout sb_abc123 --dir /data/work/app --branch feature/x --create",
+        "easybits sb git log sb_abc123 --dir /data/work/app --limit 5"
+      ],
+      async run(ctx) {
+        const op = need(ctx, 0, GIT_OPS.join("|"), GIT_USAGE);
+        need(ctx, 1, "sandbox", GIT_USAGE);
+        const params = gitParams(op, {
+          dir: str(ctx, "dir"),
+          repo: str(ctx, "repo"),
+          branch: str(ctx, "branch"),
+          depth: int(ctx, "depth", GIT_USAGE),
+          sha: str(ctx, "sha"),
+          token: str(ctx, "git-token"),
+          username: str(ctx, "git-user"),
+          message: str(ctx, "message"),
+          all: bool(ctx, "all"),
+          paths: list(ctx, "path"),
+          authorName: str(ctx, "author-name"),
+          authorEmail: str(ctx, "author-email"),
+          remote: str(ctx, "remote"),
+          setUpstream: bool(ctx, "set-upstream"),
+          force: bool(ctx, "force"),
+          rebase: bool(ctx, "rebase"),
+          create: bool(ctx, "create"),
+          from: str(ctx, "from"),
+          limit: int(ctx, "limit", GIT_USAGE)
+        });
+        const { git } = await sandboxAt(ctx, 1, GIT_USAGE);
+        const r = op === "status" ? await git.status(params.dir) : await git[op](params);
+        emit(ctx, r, () => printGit(op, r));
+        if (op === "pull" && r.conflicts?.length) process.exitCode = 1;
+      }
+    },
     snapshot: {
       summary: "Capture a copy-on-write snapshot without stopping the box",
       usage: "easybits sandboxes snapshot <sandbox> [--name <name>]",
@@ -1504,14 +2134,18 @@ var sandboxes = {
 };
 
 // src/commands/machines.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
-import { basename as basename2 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { basename as basename3 } from "path";
 
 // src/refs.ts
 var ID_FORMAT = {
   agent: /^[0-9a-f]{24}$/i,
   db: /^[0-9a-f]{24}$/i,
-  sandbox: /^sb_[0-9a-z-]+$/i
+  sandbox: /^sb_[0-9a-z-]+$/i,
+  site: /^[0-9a-f]{24}$/i,
+  fleet: /^[0-9a-f]{24}$/i,
+  document: /^[0-9a-f]{24}$/i,
+  video: /^[0-9a-f]{24}$/i
 };
 var looksLikeId = (kind, ref) => ID_FORMAT[kind].test(ref);
 var REF_ARGS = {
@@ -1531,6 +2165,9 @@ var REF_ARGS = {
   "sandboxes exec": { index: 0, kind: "sandbox" },
   "sandboxes logs": { index: 0, kind: "sandbox" },
   "sandboxes files": { index: 1, kind: "sandbox" },
+  "sandboxes domains": { index: 1, kind: "sandbox" },
+  "sandboxes bg": { index: 1, kind: "sandbox" },
+  "sandboxes git": { index: 1, kind: "sandbox" },
   "sandboxes suspend": { index: 0, kind: "sandbox" },
   "sandboxes resume": { index: 0, kind: "sandbox" },
   "sandboxes destroy": { index: 0, kind: "sandbox" },
@@ -1540,15 +2177,35 @@ var REF_ARGS = {
   "machines logs": { index: 0, kind: "sandbox" },
   "machines rollback": { index: 0, kind: "sandbox" },
   "machines secrets": { index: 1, kind: "sandbox" },
-  "domains ls": { index: 0, kind: "sandbox" },
-  "domains add": { index: 0, kind: "sandbox" },
-  "domains verify": { index: 0, kind: "sandbox" },
-  "domains rm": { index: 0, kind: "sandbox" },
+  "machines get": { index: 0, kind: "sandbox" },
+  "machines restart": { index: 0, kind: "sandbox" },
+  "machines redeploy": { index: 0, kind: "sandbox" },
+  "machines backups": { index: 0, kind: "sandbox" },
+  "machines backup": { index: 0, kind: "sandbox" },
+  "machines runspec": { index: 1, kind: "sandbox" },
+  "machines rm": { index: 0, kind: "sandbox" },
   "db rm": { index: 0, kind: "db" },
   "db rename": { index: 0, kind: "db" },
   "db tables": { index: 0, kind: "db" },
   "db query": { index: 0, kind: "db" },
-  "db photos": { index: 1, kind: "db" }
+  "db photos": { index: 1, kind: "db" },
+  "sites theme": { index: 1, kind: "site" },
+  "fleet get": { index: 0, kind: "fleet" },
+  "fleet capabilities": { index: 0, kind: "fleet" },
+  "fleet configure": { index: 0, kind: "fleet" },
+  "fleet message": { index: 0, kind: "fleet" },
+  "documents get": { index: 0, kind: "document" },
+  "documents pages": { index: 1, kind: "document" },
+  "documents add-page": { index: 0, kind: "document" },
+  "documents rm-page": { index: 0, kind: "document" },
+  "documents reorder": { index: 0, kind: "document" },
+  "documents deploy": { index: 0, kind: "document" },
+  "documents export": { index: 1, kind: "document" },
+  "documents rm": { index: 0, kind: "document" },
+  "video projects": { index: 1, kind: "video" },
+  "video scenes": { index: 1, kind: "video" },
+  "video music": { index: 1, kind: "video" },
+  "video render": { index: 0, kind: "video" }
 };
 function matchRef(kind, ref, items) {
   if (looksLikeId(kind, ref)) return { ok: true, id: ref };
@@ -1565,28 +2222,37 @@ function matchRef(kind, ref, items) {
 var LS_HINT = {
   agent: "easybits agents ls",
   sandbox: "easybits sandboxes ls",
-  db: "easybits db ls"
+  db: "easybits db ls",
+  site: "easybits sites ls",
+  fleet: "easybits fleet ls",
+  document: "easybits documents ls",
+  video: "easybits video projects ls"
 };
-var NOUN = () => ({ agent: t("agent", "agente"), sandbox: t("sandbox or machine", "sandbox o m\xE1quina"), db: t("database", "base de datos") });
-var NOUNS = () => ({ agent: t("agents", "agentes"), sandbox: t("sandboxes", "sandboxes"), db: t("databases", "bases de datos") });
+var NOUN = () => ({ agent: t("agent", "agente"), sandbox: t("sandbox or machine", "sandbox o m\xE1quina"), db: t("database", "base de datos"), site: t("site", "sitio"), fleet: t("fleet agent", "agente de flota"), document: t("document", "documento"), video: t("video project", "proyecto de video") });
+var NOUNS = () => ({ agent: t("agents", "agentes"), sandbox: t("sandboxes", "sandboxes"), db: t("databases", "bases de datos"), site: t("sites", "sitios"), fleet: t("fleet agents", "agentes de flota"), document: t("documents", "documentos"), video: t("video projects", "proyectos de video") });
 var cache = /* @__PURE__ */ new Map();
-function listRefs(ctx, kind) {
-  let p = cache.get(kind);
+function listRefs(ctx, kind, ref) {
+  const key = kind === "document" ? `document:${ref}` : kind;
+  let p = cache.get(key);
   if (!p) {
     p = (async () => {
       const eb = await getClient(ctx);
       if (kind === "agent") return (await eb.listAgents()).map((a) => ({ id: a.agentId, name: a.name, status: a.status }));
+      if (kind === "fleet") return (await api(ctx, "GET", "/fleet-agents")).pools.map((p2) => ({ id: p2.id, name: p2.name }));
+      if (kind === "document") return (await api(ctx, "GET", `/documents?limit=100&search=${encodeURIComponent(ref ?? "")}`)).items.map((d) => ({ id: d.id, name: d.name }));
+      if (kind === "video") return (await api(ctx, "GET", "/video-projects?limit=100")).items.map((v) => ({ id: v.id, name: v.name, status: v.status }));
+      if (kind === "site") return (await api(ctx, "GET", "/sites")).items.map((s) => ({ id: s.id, name: s.name }));
       if (kind === "db") return (await eb.listDatabases()).items.map((d) => ({ id: d.id, name: d.name }));
       return (await eb.sandboxes.list()).map((s) => ({ id: s.sandboxId, name: s.name, status: s.status }));
     })();
-    p.catch(() => cache.delete(kind));
-    cache.set(kind, p);
+    p.catch(() => cache.delete(key));
+    cache.set(key, p);
   }
   return p;
 }
 async function resolveRef(ctx, kind, ref) {
   if (looksLikeId(kind, ref)) return ref;
-  const r = matchRef(kind, ref, await listRefs(ctx, kind));
+  const r = matchRef(kind, ref, await listRefs(ctx, kind, ref));
   if (r.ok) return r.id;
   if (r.reason === "not_found") {
     throw new CliError(t(`No ${NOUN()[kind]} with id or name "${ref}".`, `No hay ${NOUN()[kind]} con id o nombre "${ref}".`), EXIT.API, `${t("List them with", "Enl\xEDstalos con")}: ${LS_HINT[kind]}`, "not_found", 404);
@@ -1610,6 +2276,59 @@ async function resolveRefs(ctx, key) {
 
 // src/commands/machines.ts
 var SECRETS_USAGE = "easybits machines secrets <ls|set|unset> <machine> [--dotenv <path> | NAME]";
+var RUNSPEC_USAGE = "easybits machines runspec <get|set> <machine> [--file <file.json|->] [--app-dir <dir>] [--build <cmd>] [--start <cmd>] [--unit <name>] [--port <port>] [--prebuilt on|off] [--data <path>]... [--exclude <path>]... [--env K=V]...";
+function printMachine(m) {
+  console.log(`ID:        ${m.sandboxId}`);
+  if (m.name) console.log(`${t("Name:     ", "Nombre:   ")} ${m.name}`);
+  console.log(`${t("Status:   ", "Estado:   ")} ${m.status}${m.runtimeStatus ? ` (${m.runtimeStatus})` : ""}`);
+  console.log(`Tier:      ${m.tier} \xB7 ${m.vcpus} vCPU ${m.cpuMode} \xB7 ${fmtBytes(m.memoryMb * 1024 * 1024)} RAM \xB7 ${fmtBytes(m.diskMb * 1024 * 1024)}${m.diskAddonsGB ? ` + ${m.diskAddonsGB} GB` : ""}`);
+  console.log(`${t("Price:    ", "Precio:   ")} $${m.monthlyMxn} MXN/${t("month", "mes")}`);
+  console.log(`${t("Sleeps:   ", "Duerme:   ")} ${m.sleep ? t("yes, without visits", "s\xED, sin visitas") : t("no, always on", "no, siempre prendida")}`);
+  console.log(`${t("Created:  ", "Creada:   ")} ${fmtDate(m.createdAt)}`);
+  if (m.shared) console.log(t("Shared with you by its owner.", "Su due\xF1o la comparti\xF3 contigo."));
+  if (m.deletionScheduledAt) console.log(t(`Scheduled for deletion: ${fmtDate(m.deletionScheduledAt)}`, `Programada para borrarse: ${fmtDate(m.deletionScheduledAt)}`));
+}
+function printRunspec(r) {
+  for (const [k, v] of Object.entries(r)) {
+    if (v == null) continue;
+    const shown = Array.isArray(v) ? v.join(", ") : typeof v === "object" ? Object.keys(v).join(", ") : String(v);
+    console.log(`${k.padEnd(16)}${shown}`);
+  }
+}
+async function runspecFrom(ctx) {
+  let spec = {};
+  const file = str(ctx, "file");
+  if (file) {
+    const text = file === "-" ? (await readStdin()).toString("utf8") : existsSync7(file) ? readFileSync7(file, "utf8") : null;
+    if (text == null) throw usageError(t(`File not found: ${file}`, `No existe el archivo: ${file}`), RUNSPEC_USAGE);
+    try {
+      const parsed = JSON.parse(text);
+      spec = parsed && typeof parsed === "object" && "runspec" in parsed ? parsed.runspec ?? {} : parsed;
+    } catch {
+      throw usageError(t(`${file === "-" ? "stdin" : file} is not valid JSON.`, `${file === "-" ? "stdin" : file} no es JSON v\xE1lido.`), RUNSPEC_USAGE);
+    }
+  }
+  const set2 = (k, v) => {
+    if (v !== void 0) spec[k] = v;
+  };
+  set2("appDir", str(ctx, "app-dir"));
+  set2("buildCommand", str(ctx, "build"));
+  set2("startCommand", str(ctx, "start"));
+  set2("unit", str(ctx, "unit"));
+  set2("port", int(ctx, "port", RUNSPEC_USAGE));
+  const prebuilt = str(ctx, "prebuilt");
+  if (prebuilt != null) {
+    if (prebuilt !== "on" && prebuilt !== "off") throw usageError(t("--prebuilt is on or off.", "--prebuilt es on u off."), RUNSPEC_USAGE);
+    spec.prebuilt = prebuilt === "on";
+  }
+  const data = list(ctx, "data");
+  if (data.length) spec.dataPaths = data;
+  const excludes = list(ctx, "exclude");
+  if (excludes.length) spec.excludes = excludes;
+  const env = pairs(list(ctx, "env"), RUNSPEC_USAGE);
+  if (Object.keys(env).length) spec.env = env;
+  return spec;
+}
 var machines = {
   name: "machines",
   aliases: ["machine"],
@@ -1673,16 +2392,19 @@ var machines = {
         }
         if (repo && archiveUrl) throw usageError(t("--repo and --archive are exclusive.", "--repo y --archive se excluyen."), this.usage);
         if (machineRef && str(ctx, "tier")) {
-          throw usageError(t("--tier is only for a new machine (resize = redeploy_machine).", "--tier s\xF3lo aplica a una m\xE1quina nueva (cambiar tama\xF1o = redeploy_machine)."), this.usage);
+          throw usageError(
+            t("--tier is only for a new machine. To resize: easybits machines redeploy <machine> --tier <tier> --replace", "--tier s\xF3lo aplica a una m\xE1quina nueva. Para cambiar tama\xF1o: easybits machines redeploy <m\xE1quina> --tier <tier> --replace"),
+            this.usage
+          );
         }
         const eb = await getClient(ctx);
         const sandboxId = machineRef ? await resolveRef(ctx, "sandbox", machineRef) : void 0;
         if (archiveUrl && !/^https?:\/\//.test(archiveUrl)) {
-          if (!existsSync6(archiveUrl)) throw usageError(t(`File not found: ${archiveUrl}`, `No existe el archivo: ${archiveUrl}`), this.usage);
-          const size = statSync2(archiveUrl).size;
+          if (!existsSync7(archiveUrl)) throw usageError(t(`File not found: ${archiveUrl}`, `No existe el archivo: ${archiveUrl}`), this.usage);
+          const size = statSync4(archiveUrl).size;
           const contentType = archiveUrl.endsWith(".zip") ? "application/zip" : "application/gzip";
-          const up = await eb.uploadFile({ fileName: basename2(archiveUrl), contentType, size, access: "public" });
-          const res = await fetch(up.putUrl, { method: "PUT", body: readFileSync6(archiveUrl), headers: { "Content-Type": contentType } });
+          const up = await eb.uploadFile({ fileName: basename3(archiveUrl), contentType, size, access: "public" });
+          const res = await fetch(up.putUrl, { method: "PUT", body: readFileSync7(archiveUrl), headers: { "Content-Type": contentType } });
           if (!res.ok) throw new CliError(t(`Upload failed: storage answered ${res.status}`, `Fall\xF3 la subida: el almacenamiento contest\xF3 ${res.status}`), 1, void 0, "upload_failed", res.status);
           archiveUrl = up.file.url;
           if (!archiveUrl) throw new CliError(t("The upload returned no public URL.", "La subida no devolvi\xF3 una URL p\xFAblica."), 1, void 0, "upload_failed");
@@ -1794,6 +2516,184 @@ var machines = {
         if (r.exitCode !== 0) process.exitCode = 1;
       }
     },
+    get: {
+      summary: "Show a machine: tier, size, price, status and whether it sleeps",
+      usage: "easybits machines get <machine>",
+      examples: ["easybits machines get shop", "easybits machines get shop --json"],
+      async run(ctx) {
+        const id = need(ctx, 0, "machine", this.usage);
+        const m = await api(ctx, "GET", `/machines/${encodeURIComponent(id)}`);
+        emit(ctx, m, () => printMachine(m));
+      }
+    },
+    restart: {
+      summary: "Restart the app's process with the current secrets and runspec (seconds, no build)",
+      usage: "easybits machines restart <machine>",
+      examples: ["easybits machines restart shop", "easybits machines secrets set shop --dotenv .env && easybits machines restart shop"],
+      async run(ctx) {
+        const id = need(ctx, 0, "machine", this.usage);
+        const r = await api(ctx, "POST", `/machines/${encodeURIComponent(id)}/restart`);
+        emit(ctx, r, () => {
+          console.log(r.exitCode === 0 ? t(`Restarted ${id}`, `Reiniciada ${id}`) : t(`Restart failed (exit ${r.exitCode})`, `Fall\xF3 el reinicio (salida ${r.exitCode})`));
+          if (r.exitCode !== 0 && r.startOutput) console.log(r.startOutput.slice(-2e3));
+        });
+        if (r.exitCode !== 0) process.exitCode = 1;
+      }
+    },
+    redeploy: {
+      summary: "Build a NEW machine from a release: recover a lost one, or change its tier (resize)",
+      usage: "easybits machines redeploy <machine> [--release <id>] [--tier <tier>] [--name <name>] [--cpu-mode shared|reserved] [--replace] [--yes]",
+      options: {
+        release: { type: "string", value: "id", description: "Release to build from (default: the machine's newest)" },
+        tier: { type: "string", value: "tier", description: "Size of the new machine (default: same as the release's)" },
+        name: { type: "string", value: "name", description: "Label for the new machine" },
+        "cpu-mode": { type: "string", value: "mode", description: "shared (default) or reserved" },
+        replace: { type: "boolean", description: "Release the old machine once the new one runs (otherwise you pay for both)" },
+        ...YES_OPTION
+      },
+      examples: [
+        "easybits machines redeploy shop --tier focus --replace   # resize",
+        "easybits machines redeploy sb_abc123 --release rel_789   # recover from a release"
+      ],
+      async run(ctx) {
+        const id = need(ctx, 0, "machine", this.usage);
+        const replace = bool(ctx, "replace");
+        if (replace) requireYesIfHeadless(ctx);
+        const eb = await getClient(ctx);
+        let releaseId = str(ctx, "release");
+        if (!releaseId) {
+          const { items } = await eb.machines.releases(id, { limit: 1 });
+          releaseId = items[0]?.releaseId;
+          if (!releaseId) throw new CliError(t(`${id} has no releases to build from.`, `${id} no tiene releases de d\xF3nde construir.`), 1, t("Publish one first: easybits machines deploy <machine>", "Publica uno antes: easybits machines deploy <m\xE1quina>"), "no_release");
+        }
+        const cpuMode = str(ctx, "cpu-mode");
+        if (cpuMode && cpuMode !== "shared" && cpuMode !== "reserved") throw usageError(t("--cpu-mode is shared or reserved.", "--cpu-mode es shared o reserved."), this.usage);
+        if (replace) {
+          await confirm(
+            ctx,
+            t(`Build a new machine from ${releaseId} and RELEASE ${id} once it runs? The new one starts with no data (${id}'s data stays in its backups).`, `\xBFConstruir una m\xE1quina nueva desde ${releaseId} y LIBERAR ${id} cuando corra? La nueva nace sin datos (los de ${id} quedan en sus respaldos).`),
+            { typeName: id }
+          );
+        }
+        const r = await eb.machines.redeploy(releaseId, {
+          tier: str(ctx, "tier"),
+          name: str(ctx, "name"),
+          cpuMode,
+          replaceSandboxId: replace ? id : void 0
+        });
+        emit(ctx, r, () => {
+          console.log(t(`New machine ${r.sandboxId} from ${r.releaseId} (exit ${r.exitCode})`, `M\xE1quina nueva ${r.sandboxId} desde ${r.releaseId} (salida ${r.exitCode})`));
+          if (r.replaced) console.log(t(`Released ${r.replaced}.`, `Liberada ${r.replaced}.`));
+          console.log(t("It starts with no data: restore a backup if the app keeps any.", "Nace sin datos: restaura un respaldo si la app guarda alguno."));
+        });
+        if (r.exitCode !== 0) process.exitCode = 1;
+      }
+    },
+    backups: {
+      summary: "List the daily data backups, newest first (kept 7 days)",
+      usage: "easybits machines backups <machine> [--limit <n>]",
+      options: { limit: { type: "string", value: "n", description: "How many" } },
+      examples: ["easybits machines backups shop", "easybits machines backups shop --json"],
+      async run(ctx) {
+        const id = need(ctx, 0, "machine", this.usage);
+        const eb = await getClient(ctx);
+        const r = await eb.machines.backups(id, { limit: int(ctx, "limit", this.usage) });
+        emit(
+          ctx,
+          r,
+          () => table(
+            r.items.map((b) => ({ ...b, size: fmtBytes(b.bytes), createdAt: fmtDate(b.createdAt), expiresAt: fmtDate(b.expiresAt) })),
+            [["id", "ID"], ["stamp", "DAY"], ["status", "STATUS"], ["size", "SIZE"], ["consistency", "CONSISTENCY"], ["expiresAt", "EXPIRES"]],
+            t("No backups yet. Declare what to copy (runspec dataPaths), then: easybits machines backup <machine>", "Todav\xEDa no hay respaldos. Declara qu\xE9 copiar (dataPaths del runspec) y luego: easybits machines backup <m\xE1quina>")
+          )
+        );
+      }
+    },
+    backup: {
+      summary: "Take a data backup now instead of waiting for tonight's",
+      usage: "easybits machines backup <machine>",
+      examples: ["easybits machines backup shop"],
+      async run(ctx) {
+        const id = need(ctx, 0, "machine", this.usage);
+        const eb = await getClient(ctx);
+        const b = await eb.machines.backup(id);
+        emit(ctx, b, () => console.log(t(`Backup ${b.id} (${b.status}, ${fmtBytes(b.bytes)}, ${b.consistency})`, `Respaldo ${b.id} (${b.status}, ${fmtBytes(b.bytes)}, ${b.consistency})`)));
+      }
+    },
+    runspec: {
+      summary: "How the app is built, started and backed up (set merges with what is there)",
+      usage: RUNSPEC_USAGE,
+      options: {
+        file: { type: "string", value: "file.json|-", description: "Runspec as JSON (- reads stdin); flags win over it" },
+        "app-dir": { type: "string", value: "dir", description: "Where the app lives in the machine" },
+        build: { type: "string", value: "cmd", description: "Build command" },
+        start: { type: "string", value: "cmd", description: "Start command (used when there is no systemd unit)" },
+        unit: { type: "string", value: "name", description: "systemd unit to restart (preferred over --start)" },
+        port: { type: "string", value: "port", description: "Port the app listens on" },
+        prebuilt: { type: "string", value: "on|off", description: "on: releases ship the build and a deploy only starts it" },
+        data: { type: "string", multiple: true, value: "path", description: "Path the nightly backup copies (repeatable). Without it nothing is backed up" },
+        exclude: { type: "string", multiple: true, value: "path", description: "Path kept out of the release (repeatable)" },
+        env: { type: "string", multiple: true, value: "K=V", description: "Environment variable, non-secret (repeatable)" }
+      },
+      examples: [
+        "easybits machines runspec get shop",
+        "easybits machines runspec set shop --data /app/data --data /app/uploads",
+        "easybits machines runspec set shop --start 'node server.js' --port 8080 --prebuilt on",
+        "easybits machines runspec get shop --json | jq .runspec > rs.json   # edit, then:",
+        "easybits machines runspec set shop --file rs.json"
+      ],
+      async run(ctx) {
+        const action = need(ctx, 0, "get|set", RUNSPEC_USAGE);
+        const id = need(ctx, 1, "machine", RUNSPEC_USAGE);
+        const eb = await getClient(ctx);
+        if (action === "get") {
+          const r2 = await eb.machines.runspec(id);
+          emit(ctx, r2, () => r2.runspec ? printRunspec(r2.runspec) : console.log(t("No runspec yet: a machine made with launch has one.", "Todav\xEDa sin runspec: una m\xE1quina hecha con launch ya lo trae.")));
+          return;
+        }
+        if (action !== "set") throw usageError(t(`Unknown runspec action "${action}".`, `Acci\xF3n de runspec desconocida "${action}".`), RUNSPEC_USAGE);
+        const spec = await runspecFrom(ctx);
+        if (!Object.keys(spec).length) throw usageError(t("Nothing to set: pass --file or a flag (--data, --start, --port\u2026).", "Nada que cambiar: pasa --file o una bandera (--data, --start, --port\u2026)."), RUNSPEC_USAGE);
+        const r = await eb.machines.setRunspec(id, spec);
+        emit(ctx, r, () => {
+          console.log(t("Runspec saved. It applies on the next deploy or restart.", "Runspec guardado. Aplica en el siguiente deploy o reinicio."));
+          printRunspec(r);
+        });
+      }
+    },
+    rm: {
+      aliases: ["destroy", "delete"],
+      summary: "Release a machine: stops billing, takes a last backup and destroys it",
+      usage: "easybits machines rm <machine> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits machines rm shop", "easybits machines rm sb_abc123 --yes --json"],
+      async run(ctx) {
+        const id = need(ctx, 0, "machine", this.usage);
+        requireYesIfHeadless(ctx);
+        await confirm(ctx, t(`Release machine ${id}? Billing stops and the box is destroyed (a last backup is kept).`, `\xBFLiberar la m\xE1quina ${id}? Se deja de cobrar y la caja se destruye (queda un \xFAltimo respaldo).`), { typeName: id });
+        const r = await api(ctx, "DELETE", `/machines/${encodeURIComponent(id)}`);
+        emit(ctx, { ...r, sandboxId: id }, () => {
+          console.log(t(`Released ${id}.`, `Liberada ${id}.`));
+          console.log(r.backupId ? t(`Last backup: ${r.backupId}`, `\xDAltimo respaldo: ${r.backupId}`) : t("No final backup (nothing declared in dataPaths, or it failed).", "Sin respaldo final (nada declarado en dataPaths, o fall\xF3)."));
+        });
+      }
+    },
+    tiers: {
+      summary: "The hosting catalog: sizes and monthly prices in MXN",
+      usage: "easybits machines tiers",
+      examples: ["easybits machines tiers", "easybits machines tiers --json"],
+      async run(ctx) {
+        const eb = await getClient(ctx);
+        const r = await eb.machines.tiers();
+        emit(ctx, r, () => {
+          table(
+            r.tiers.map((x) => ({ ...x, memory: fmtBytes(x.memoryMb * 1024 * 1024), disk: fmtBytes(x.diskMb * 1024 * 1024), reserved: x.priceReserved ?? "-" })),
+            [["key", "TIER"], ["vcpus", "VCPUS"], ["memory", "MEMORY"], ["disk", "DISK"], ["priceShared", "MXN/MONTH"], ["reserved", "RESERVED"], ["minPlan", "PLAN"]]
+          );
+          console.log(t(`Extra disk: ${r.diskAddon.gb} GB for $${r.diskAddon.price} MXN/month each.`, `Disco extra: ${r.diskAddon.gb} GB por $${r.diskAddon.price} MXN/mes cada uno.`));
+        });
+      }
+    },
     secrets: {
       summary: "App env vars stored encrypted in your vault",
       usage: SECRETS_USAGE,
@@ -1832,85 +2732,165 @@ var machines = {
   }
 };
 
-// src/commands/domains.ts
-async function sandbox2(ctx, usage2) {
-  const id = need(ctx, 0, "sandbox", usage2);
-  return (await getClient(ctx)).sandboxes.get(id);
+// src/commands/sites.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { resolveBaseUrl as resolveBaseUrl5 } from "@easybits.cloud/sdk";
+var SITE_STACKS = ["tanstack", "next", "react-router", "remix", "nuxt", "sveltekit", "astro", "elysia"];
+var SITE_TEMPLATES = ["consultorio", "despacho", "portafolio", "lanzamiento"];
+var TEMPLATE_STACKS = ["tanstack", "react-router"];
+function siteRows(items) {
+  return items.map((s) => ({
+    ...s,
+    kind: s.kind === "webapp" ? `webapp${s.stack ? ` (${s.stack})` : ""}` : "static",
+    url: s.url ?? (s.archivedAt ? t("(archived)", "(archivada)") : t("(not published)", "(sin publicar)")),
+    createdAt: fmtDate(s.createdAt)
+  }));
 }
-var domains = {
-  name: "domains",
-  aliases: ["domain"],
+function createBody(o, usage2) {
+  const kind = o.kind ?? "webapp";
+  if (kind !== "static" && kind !== "webapp") throw usageError(t(`--kind is static or webapp, not "${kind}".`, `--kind es static o webapp, no "${kind}".`), usage2);
+  if (kind === "static" && (o.stack || o.template)) {
+    throw usageError(t("--stack and --template are only for --kind webapp.", "--stack y --template s\xF3lo aplican a --kind webapp."), usage2);
+  }
+  if (o.stack && !SITE_STACKS.includes(o.stack)) {
+    throw usageError(t(`Unknown stack "${o.stack}". One of: ${SITE_STACKS.join(", ")}.`, `Stack desconocido "${o.stack}". Uno de: ${SITE_STACKS.join(", ")}.`), usage2);
+  }
+  if (o.template) {
+    if (!SITE_TEMPLATES.includes(o.template)) {
+      throw usageError(t(`Unknown template "${o.template}". One of: ${SITE_TEMPLATES.join(", ")}.`, `Plantilla desconocida "${o.template}". Una de: ${SITE_TEMPLATES.join(", ")}.`), usage2);
+    }
+    if (!TEMPLATE_STACKS.includes(o.stack ?? "tanstack")) {
+      throw usageError(t(`--template only works with stack ${TEMPLATE_STACKS.join(" or ")}.`, `--template s\xF3lo funciona con el stack ${TEMPLATE_STACKS.join(" o ")}.`), usage2);
+    }
+  }
+  if (!o.prompt && !o.name) throw usageError(t("Give --prompt (what to build) or --name.", "Pasa --prompt (qu\xE9 construir) o --name."), usage2);
+  const body = { kind };
+  for (const k of ["prompt", "name", "stack", "template"]) if (o[k]) body[k] = o[k];
+  return body;
+}
+var THEME_USAGE = "easybits sites theme <get|set> <site> [--theme <id> | --colors <file.json|->]";
+async function readColors(path) {
+  let text;
+  if (path === "-") text = (await readStdin()).toString("utf8");
+  else {
+    if (!existsSync8(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), THEME_USAGE);
+    text = readFileSync8(path, "utf8");
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw usageError(t(`${path === "-" ? "stdin" : path} is not valid JSON.`, `${path === "-" ? "stdin" : path} no es JSON v\xE1lido.`), THEME_USAGE);
+  }
+}
+function printColors(colors) {
+  table(Object.entries(colors ?? {}).map(([token, value]) => ({ token, value })), [["token", "TOKEN"], ["value", "VALUE"]]);
+}
+var sites = {
+  name: "sites",
+  aliases: ["site"],
   group: "Hosting",
-  summary: "Custom domains with auto TLS on a sandbox or machine",
-  synopsis: "domains",
+  summary: "Your site-builder sites (/dash/sitios): static and web apps",
+  synopsis: "sites <ls|create|theme>",
   subs: {
     ls: {
       aliases: ["list"],
-      summary: "List domains attached to a sandbox",
-      usage: "easybits domains ls <sandbox>",
-      examples: ["easybits domains ls sb_abc123"],
+      summary: "List your sites with their kind, engine and public URL",
+      usage: "easybits sites ls",
+      examples: ["easybits sites ls", "easybits sites ls --json"],
       async run(ctx) {
-        const items = await (await sandbox2(ctx, this.usage)).listDomains();
-        emit(ctx, items, () => table(items, [["domain", "DOMAIN"], ["port", "PORT"]], t("No custom domains.", "Sin dominios propios.")));
+        const { items } = await api(ctx, "GET", "/sites");
+        emit(
+          ctx,
+          items,
+          () => table(
+            siteRows(items),
+            [["id", "ID"], ["name", "NAME"], ["kind", "KIND"], ["engine", "ENGINE"], ["url", "URL"]],
+            t('No sites yet. Create one: easybits sites create --prompt "\u2026"', 'Todav\xEDa no hay sitios. Crea uno: easybits sites create --prompt "\u2026"')
+          )
+        );
       }
     },
-    add: {
-      summary: "Attach a domain to a port; prints the DNS record to create",
-      usage: "easybits domains add <sandbox> <domain> --port <port>",
-      options: { port: { type: "string", value: "port", description: "Port inside the sandbox (required)" } },
-      examples: ["easybits domains add sb_abc123 shop.example.com --port 3000"],
+    create: {
+      aliases: ["new"],
+      summary: "Create a site from a prompt; its builder agent picks it up in the editor",
+      usage: "easybits sites create (--prompt <text> | --name <name>) [--kind webapp|static] [--stack <stack>] [--template <key>]",
+      options: {
+        prompt: { type: "string", value: "text", description: "What to build; also names the site if --name is missing" },
+        name: { type: "string", value: "name", description: "Site name" },
+        kind: { type: "string", value: "kind", description: "webapp (default: its own machine, published later) or static (CDN website)" },
+        stack: { type: "string", value: "stack", description: "Web app stack: tanstack (default), next, react-router, remix, nuxt, sveltekit, astro, elysia" },
+        template: { type: "string", value: "key", description: "Starting template (tanstack/react-router): consultorio, despacho, portafolio, lanzamiento" }
+      },
+      examples: [
+        'easybits sites create --prompt "Landing for my dental clinic in Puebla"',
+        'easybits sites create --prompt "Task tracker with login" --stack next --json',
+        'easybits sites create --name "Promo" --kind static'
+      ],
       async run(ctx) {
-        const domain = need(ctx, 1, "domain", this.usage);
-        const port = int(ctx, "port", this.usage);
-        if (port == null) throw usageError(t("Missing --port.", "Falta --port."), this.usage);
-        const r = await (await sandbox2(ctx, this.usage)).addDomain(domain, port);
-        emit(ctx, r, () => {
-          console.log(t(`Attached ${r.domain} \u2192 port ${r.port}`, `Ligado ${r.domain} \u2192 puerto ${r.port}`));
-          console.log(t(`Create this DNS record: ${JSON.stringify(r.dns)}`, `Crea este registro DNS: ${JSON.stringify(r.dns)}`));
-          console.log(t(`Then run: easybits domains verify ${ctx.args[0]} ${r.domain}`, `Luego corre: easybits domains verify ${ctx.args[0]} ${r.domain}`));
+        const body = createBody(
+          { prompt: str(ctx, "prompt"), name: str(ctx, "name"), kind: str(ctx, "kind"), stack: str(ctx, "stack"), template: str(ctx, "template") },
+          this.usage
+        );
+        const site = await api(ctx, "POST", "/sites", body);
+        const base = (await resolveBaseUrl5()).replace(/\/$/, "");
+        const editorUrl2 = site.editorUrl.startsWith("http") ? site.editorUrl : `${base}${site.editorUrl}`;
+        const out = { ...site, editorUrl: editorUrl2 };
+        emit(ctx, out, () => {
+          console.log(t(`Created ${site.name} (${site.id}) \u2014 ${site.kind}${site.stack ? ` ${site.stack}` : ""}`, `Creado ${site.name} (${site.id}) \u2014 ${site.kind}${site.stack ? ` ${site.stack}` : ""}`));
+          console.log(`${t("Editor", "Editor")}:  ${editorUrl2}`);
+          if (site.previewUrl) console.log(`${t("Preview", "Vista previa")}: ${site.previewUrl}`);
+          console.log(site.url ? `URL: ${site.url}` : t("Not published yet: publish it from the editor.", "Todav\xEDa sin publicar: publ\xEDcalo desde el editor."));
         });
       }
     },
-    verify: {
-      summary: "Check DNS + HTTPS for a domain",
-      usage: "easybits domains verify <sandbox> <domain>",
-      examples: ["easybits domains verify sb_abc123 shop.example.com"],
+    theme: {
+      summary: "Read or change a site's color theme without a model turn (the \xABTema\xBB button)",
+      usage: THEME_USAGE,
+      options: {
+        theme: { type: "string", value: "id", description: "Palette id: minimal, calido, oceano, noche, dracula, nord, tokyo-night, github-light\u2026" },
+        colors: { type: "string", value: "file.json|-", description: "JSON with every token as #rrggbb (- reads stdin)" }
+      },
+      examples: [
+        "easybits sites theme get my-shop",
+        "easybits sites theme set my-shop --theme dracula",
+        "easybits sites theme get my-shop --json > theme.json   # edit, then:",
+        "jq .colors theme.json | easybits sites theme set my-shop --colors -"
+      ],
       async run(ctx) {
-        const domain = need(ctx, 1, "domain", this.usage);
-        const r = await (await sandbox2(ctx, this.usage)).verifyDomain(domain);
+        const action = need(ctx, 0, "get|set", THEME_USAGE);
+        const id = need(ctx, 1, "site", THEME_USAGE);
+        const path = `/sites/${encodeURIComponent(id)}/theme`;
+        if (action === "get") {
+          const r2 = await api(ctx, "GET", path);
+          emit(ctx, r2, () => {
+            if (!r2.supported) console.log(t("This site predates themes (literal colors): ask its builder agent to move it to tokens.", "Este sitio es anterior a los temas (colores literales): p\xEDdele a su agente que lo pase a tokens."));
+            else printColors(r2.colors);
+          });
+          return;
+        }
+        if (action !== "set") throw usageError(t(`Unknown theme action "${action}".`, `Acci\xF3n de theme desconocida "${action}".`), THEME_USAGE);
+        const themeId = str(ctx, "theme");
+        const file = str(ctx, "colors");
+        if (!themeId === !file) throw usageError(t("Give --theme <id> or --colors <file.json|->, one of them.", "Pasa --theme <id> o --colors <archivo.json|->, uno de los dos."), THEME_USAGE);
+        const body = themeId ? { themeId } : { colors: await readColors(file) };
+        const r = await api(ctx, "POST", path, body);
         emit(ctx, r, () => {
-          console.log(`${r.domain}: ${r.ready ? t("ready", "listo") : t("not ready yet", "todav\xEDa no est\xE1 listo")}`);
-          console.log(t(`DNS resolved: ${r.dns.resolved}  HTTPS ok: ${r.https.ok}`, `DNS resuelve: ${r.dns.resolved}  HTTPS ok: ${r.https.ok}`));
-          if (r.hint) console.log(r.hint);
+          console.log(t("Theme changed. The preview updates by itself.", "Tema cambiado. La vista previa se actualiza sola."));
+          printColors(r.colors);
         });
-        if (!r.ready) process.exitCode = 1;
-      }
-    },
-    rm: {
-      aliases: ["remove", "delete"],
-      summary: "Detach a domain",
-      usage: "easybits domains rm <sandbox> <domain> [--yes]",
-      options: { ...YES_OPTION },
-      examples: ["easybits domains rm sb_abc123 shop.example.com", "easybits domains rm sb_abc123 shop.example.com --yes"],
-      async run(ctx) {
-        need(ctx, 0, "sandbox", this.usage);
-        const domain = need(ctx, 1, "domain", this.usage);
-        requireYesIfHeadless(ctx);
-        await confirm(ctx, t(`Detach ${domain} from ${ctx.args[0]}? It stops serving right away.`, `\xBFDesligar ${domain} de ${ctx.args[0]}? Deja de servir de inmediato.`));
-        const r = await (await sandbox2(ctx, this.usage)).removeDomain(domain);
-        emit(ctx, r, () => console.log(t(`Removed ${domain}`, `Quitado ${domain}`)));
       }
     }
-  }
+  },
+  defaultSub: "ls"
 };
 
 // src/commands/db.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
 
 // src/photos.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync7, readdirSync, statSync as statSync3 } from "fs";
-import { extname as extname2, join as join3 } from "path";
+import { readFileSync as readFileSync9, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
+import { extname as extname3, join as join4 } from "path";
 var PHOTO_MAX_BYTES = 10 * 1024 * 1024;
 var WHATSAPP_MAX_BYTES = 5 * 1024 * 1024;
 function imageTypeOf(b) {
@@ -1926,10 +2906,10 @@ function imageTypeOf(b) {
 function photoFiles(dir) {
   const photos = [];
   const rejected = [];
-  for (const name of readdirSync(dir).sort()) {
+  for (const name of readdirSync2(dir).sort()) {
     if (name.startsWith(".")) continue;
-    const path = join3(dir, name);
-    const st = statSync3(path);
+    const path = join4(dir, name);
+    const st = statSync5(path);
     if (!st.isFile()) continue;
     if (st.size === 0) {
       rejected.push({ file: name, reason: "empty" });
@@ -1939,13 +2919,13 @@ function photoFiles(dir) {
       rejected.push({ file: name, reason: "too_large" });
       continue;
     }
-    const bytes = readFileSync7(path);
+    const bytes = readFileSync9(path);
     const type = imageTypeOf(bytes);
     if (!type) {
       rejected.push({ file: name, reason: "not_an_image" });
       continue;
     }
-    const key = name.slice(0, name.length - extname2(name).length);
+    const key = name.slice(0, name.length - extname3(name).length);
     photos.push({ key, file: name, path, ...type, bytes: st.size, sha: createHash2("sha256").update(bytes).digest("hex") });
   }
   return { photos, rejected };
@@ -2000,8 +2980,8 @@ function parseLinkStats(columns, row) {
 }
 
 // src/commands/agents-config.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync as readdirSync2, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename3, dirname, join as join4, relative, resolve } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, readdirSync as readdirSync3, statSync as statSync6, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename4, dirname, join as join5, relative as relative2, resolve } from "path";
 var WORK_DIR = "/data/work";
 var MACHINE_TEMPLATES = /* @__PURE__ */ new Set(["ghosty-lite", "goose"]);
 var SKILLS_DIR = "/data/agent/skills";
@@ -2080,8 +3060,8 @@ function readLocalText(path, usage2) {
     if (process.stdin.isTTY) throw usageError(t("Expected the content on stdin.", "Se esperaba el contenido por stdin."), usage2);
     return readStdin().then((b) => b.toString("utf8"));
   }
-  if (!existsSync7(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
-  return readFileSync8(path, "utf8");
+  if (!existsSync9(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
+  return readFileSync10(path, "utf8");
 }
 function parseMcpFile(text, usage2) {
   let j;
@@ -2297,8 +3277,8 @@ var files2 = {
       if (!rest.length) throw usageError(t("Give one or more local files.", "Pasa uno o m\xE1s archivos locales."), FILES_USAGE2);
       const to = (str(ctx, "to") ?? "").replace(/^\/+|\/+$/g, "");
       const plan = rest.map((local) => {
-        if (!existsSync7(local) || !statSync4(local).isFile()) throw usageError(t(`File not found: ${local}`, `No existe el archivo: ${local}`), FILES_USAGE2);
-        return { local, path: to ? `${to}/${basename3(local)}` : basename3(local), bytes: statSync4(local).size };
+        if (!existsSync9(local) || !statSync6(local).isFile()) throw usageError(t(`File not found: ${local}`, `No existe el archivo: ${local}`), FILES_USAGE2);
+        return { local, path: to ? `${to}/${basename4(local)}` : basename4(local), bytes: statSync6(local).size };
       });
       if (bool(ctx, "dry-run")) {
         emit(ctx, { agentId: id, dryRun: true, upload: plan }, () => {
@@ -2310,7 +3290,7 @@ var files2 = {
       }
       const done = [];
       for (const p of plan) {
-        const r = await api(ctx, "PUT", `/agents/${id}/files/${encodePath(p.path)}`, readFileSync8(p.local), { raw: true });
+        const r = await api(ctx, "PUT", `/agents/${id}/files/${encodePath(p.path)}`, readFileSync10(p.local), { raw: true });
         done.push({ local: p.local, ...r });
         if (!ctx.json) console.log(`${t("Uploaded", "Subido")} ${p.local} \u2192 ${WORK_DIR}/${p.path} (${fmtBytes(p.bytes)})`);
       }
@@ -2337,11 +3317,11 @@ var SKILLS_USAGE = "easybits agents skills <ls|get|add|rm> <agent> [slug...] [--
 function readSkillDir(dir) {
   const assets = [];
   const visit = (d) => {
-    for (const e of readdirSync2(d, { withFileTypes: true })) {
+    for (const e of readdirSync3(d, { withFileTypes: true })) {
       if (e.name.startsWith(".") || e.name === "node_modules") continue;
-      const p = join4(d, e.name);
+      const p = join5(d, e.name);
       if (e.isDirectory()) visit(p);
-      else if (e.isFile() && relative(dir, p) !== "SKILL.md") assets.push({ name: relative(dir, p).split("\\").join("/"), contentBase64: readFileSync8(p).toString("base64") });
+      else if (e.isFile() && relative2(dir, p) !== "SKILL.md") assets.push({ name: relative2(dir, p).split("\\").join("/"), contentBase64: readFileSync10(p).toString("base64") });
     }
   };
   visit(dir);
@@ -2394,22 +3374,22 @@ var skills = {
       }
       const s = await readSkill(box, entry);
       mkdirSync3(out, { recursive: true });
-      writeFileSync4(join4(out, "SKILL.md"), s.markdown);
+      writeFileSync4(join5(out, "SKILL.md"), s.markdown);
       for (const a of s.assets) {
-        mkdirSync3(dirname(join4(out, a.name)), { recursive: true });
-        writeFileSync4(join4(out, a.name), Buffer.from(a.contentBase64, "base64"));
+        mkdirSync3(dirname(join5(out, a.name)), { recursive: true });
+        writeFileSync4(join5(out, a.name), Buffer.from(a.contentBase64, "base64"));
       }
       emit(ctx, { slug, out: resolve(out), files: entry.files }, () => console.log(t(`Saved ${entry.files.length} file(s) to ${resolve(out)}`, `Guard\xE9 ${entry.files.length} archivo(s) en ${resolve(out)}`)));
     } else if (action === "add" || action === "put") {
       const file = str(ctx, "file");
       const dir = str(ctx, "dir");
       if (!!file === !!dir) throw usageError(t("Pass --file SKILL.md or --dir <folder>.", "Pasa --file SKILL.md o --dir <carpeta>."), SKILLS_USAGE);
-      const mdPath = file ?? join4(dir, "SKILL.md");
-      if (!existsSync7(mdPath)) throw usageError(t(`File not found: ${mdPath}`, `No existe el archivo: ${mdPath}`), SKILLS_USAGE);
-      const markdown = readFileSync8(mdPath, "utf8");
+      const mdPath = file ?? join5(dir, "SKILL.md");
+      if (!existsSync9(mdPath)) throw usageError(t(`File not found: ${mdPath}`, `No existe el archivo: ${mdPath}`), SKILLS_USAGE);
+      const markdown = readFileSync10(mdPath, "utf8");
       const fm = skillFrontmatter(markdown);
       if (fm.error) throw usageError(`${mdPath}: ${fm.error}`, SKILLS_USAGE);
-      const slug = str(ctx, "slug") ?? (fm.name && SLUG_RE.test(fm.name) ? fm.name : basename3(resolve(dir ?? dirname(mdPath))).toLowerCase());
+      const slug = str(ctx, "slug") ?? (fm.name && SLUG_RE.test(fm.name) ? fm.name : basename4(resolve(dir ?? dirname(mdPath))).toLowerCase());
       if (!SLUG_RE.test(slug)) throw usageError(t(`Invalid slug "${slug}" ([a-z0-9-], max 64). Pass --slug.`, `Slug inv\xE1lido "${slug}" ([a-z0-9-], m\xE1x 64). Pasa --slug.`), SKILLS_USAGE);
       const assets = dir ? readSkillDir(dir) : [];
       const plan = { agentId: id, slug, files: ["SKILL.md", ...assets.map((a) => a.name)], restart: bool(ctx, "restart") };
@@ -2673,10 +3653,10 @@ var exportAgent = {
   }
 };
 function readExport(path, usage2) {
-  if (!existsSync7(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
+  if (!existsSync9(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
   let x;
   try {
-    x = JSON.parse(readFileSync8(path, "utf8"));
+    x = JSON.parse(readFileSync10(path, "utf8"));
   } catch (e) {
     throw usageError(t(`${path} is not JSON: ${e.message}`, `${path} no es JSON: ${e.message}`), usage2);
   }
@@ -2978,7 +3958,7 @@ var db = {
         const keyCol = str(ctx, "key-column");
         const dir = str(ctx, "dir");
         if (!tableName || !keyCol || !dir) throw usageError(t("Missing --table, --key-column or --dir.", "Faltan --table, --key-column o --dir."), this.usage);
-        if (!existsSync8(dir) || !statSync5(dir).isDirectory()) throw usageError(t(`Not a folder: ${dir}`, `No es una carpeta: ${dir}`), this.usage);
+        if (!existsSync10(dir) || !statSync7(dir).isDirectory()) throw usageError(t(`Not a folder: ${dir}`, `No es una carpeta: ${dir}`), this.usage);
         const { photos, rejected } = photoFiles(dir);
         const eb = await getClient(ctx);
         const hit = await findDb(ctx, ref);
@@ -2992,8 +3972,8 @@ var db = {
         if (!cols.includes(column)) throw usageError(t(`No column "${column}" in ${tableName} (${cols.join(", ")}).`, `No hay columna "${column}" en ${tableName} (${cols.join(", ")}).`), this.usage);
         const current2 = /* @__PURE__ */ new Map();
         for (let i = 0; i < photos.length; i += 100) {
-          const keys = photos.slice(i, i + 100).map((p) => p.key);
-          const r = await q(`SELECT ${ident2(keyCol)}, ${ident2(column)} FROM ${ident2(tableName)} WHERE ${ident2(keyCol)} IN (${keys.map(() => "?").join(",")})`, keys);
+          const keys2 = photos.slice(i, i + 100).map((p) => p.key);
+          const r = await q(`SELECT ${ident2(keyCol)}, ${ident2(column)} FROM ${ident2(tableName)} WHERE ${ident2(keyCol)} IN (${keys2.map(() => "?").join(",")})`, keys2);
           for (const row of r.rows) current2.set(String(row[0]), row[1]);
         }
         const plan = planPhotos(photos, current2, bool(ctx, "replace"));
@@ -3024,7 +4004,7 @@ var db = {
             let url = urls.get(photo.sha);
             if (!url) {
               const up = await eb.uploadFile({ fileName: `${photo.sha.slice(0, 32)}.${photo.ext}`, contentType: photo.mime, size: photo.bytes, access: "public" });
-              const res = await fetch(up.putUrl, { method: "PUT", body: readFileSync9(photo.path), headers: { "Content-Type": photo.mime } });
+              const res = await fetch(up.putUrl, { method: "PUT", body: readFileSync11(photo.path), headers: { "Content-Type": photo.mime } });
               if (!res.ok) throw new Error(t(`storage answered ${res.status}`, `el almacenamiento contest\xF3 ${res.status}`));
               url = up.file.url;
               if (!url) throw new Error(t("the API returned no public link", "la API no devolvi\xF3 liga p\xFAblica"));
@@ -3086,48 +4066,48 @@ var db = {
 };
 
 // src/commands/agents.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12, statSync as statSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14, statSync as statSync9 } from "fs";
 
 // src/commands/spec.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync11, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync13, statSync as statSync8, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname2, join as join6, resolve as resolve2 } from "path";
+import { dirname as dirname2, join as join7, resolve as resolve2 } from "path";
 
 // src/specfile.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10, readdirSync as readdirSync3 } from "fs";
-import { join as join5, relative as relative2 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join6, relative as relative3 } from "path";
 function walkLocal(root) {
   const out = [];
   const visit = (d) => {
-    for (const e of readdirSync3(d, { withFileTypes: true })) {
+    for (const e of readdirSync4(d, { withFileTypes: true })) {
       if (e.name.startsWith(".") || e.name === "node_modules") continue;
-      const p = join5(d, e.name);
+      const p = join6(d, e.name);
       if (e.isDirectory()) visit(p);
-      else if (e.isFile()) out.push(relative2(root, p).split("\\").join("/"));
+      else if (e.isFile()) out.push(relative3(root, p).split("\\").join("/"));
     }
   };
-  if (existsSync9(root)) visit(root);
+  if (existsSync11(root)) visit(root);
   return out;
 }
 function readUploads(dir) {
   const skills2 = {};
-  const skillsRoot = join5(dir, "skills");
-  if (existsSync9(skillsRoot)) {
-    for (const e of readdirSync3(skillsRoot, { withFileTypes: true })) {
+  const skillsRoot = join6(dir, "skills");
+  if (existsSync11(skillsRoot)) {
+    for (const e of readdirSync4(skillsRoot, { withFileTypes: true })) {
       if (!e.isDirectory() || e.name.startsWith(".")) continue;
-      skills2[e.name] = walkLocal(join5(skillsRoot, e.name)).map((path) => ({ path, contentBase64: readFileSync10(join5(skillsRoot, e.name, path)).toString("base64") }));
+      skills2[e.name] = walkLocal(join6(skillsRoot, e.name)).map((path) => ({ path, contentBase64: readFileSync12(join6(skillsRoot, e.name, path)).toString("base64") }));
     }
   }
-  const filesRoot = join5(dir, "files");
-  const files3 = Object.fromEntries(walkLocal(filesRoot).map((p) => [p, readFileSync10(join5(filesRoot, p)).toString("base64")]));
+  const filesRoot = join6(dir, "files");
+  const files3 = Object.fromEntries(walkLocal(filesRoot).map((p) => [p, readFileSync12(join6(filesRoot, p)).toString("base64")]));
   return { ...Object.keys(skills2).length ? { skills: skills2 } : {}, ...Object.keys(files3).length ? { files: files3 } : {} };
 }
 function secretsFor(text, env = process.env) {
   const names = [...new Set([...text.matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g)].map((m) => m[1]))];
-  const secrets = {};
+  const secrets2 = {};
   const missing = [];
-  for (const n of names) env[n] !== void 0 ? secrets[n] = env[n] : missing.push(n);
-  return { secrets, missing };
+  for (const n of names) env[n] !== void 0 ? secrets2[n] = env[n] : missing.push(n);
+  return { secrets: secrets2, missing };
 }
 function specId(text) {
   return /^id:\s*["']?([^"'\s#]+)/m.exec(text)?.[1] ?? /^\s{0,2}"id"\s*:\s*"([^"]+)"/m.exec(text)?.[1];
@@ -3172,17 +4152,17 @@ Ed\xEDtalo y luego: easybits apply ${out} --dry-run`)));
     const yaml = await getYaml();
     const dir = resolve2(out);
     mkdirSync4(dir, { recursive: true });
-    writeFileSync5(join6(dir, "agent.yaml"), yaml);
+    writeFileSync5(join7(dir, "agent.yaml"), yaml);
     const x = await buildExport(ctx, id, { secrets: false, fileContents: true });
     const put = (path, b64) => {
       mkdirSync4(dirname2(path), { recursive: true });
       writeFileSync5(path, Buffer.from(b64, "base64"));
     };
     for (const s of x.skills ?? []) {
-      writeFileSync5((mkdirSync4(join6(dir, "skills", s.slug), { recursive: true }), join6(dir, "skills", s.slug, "SKILL.md")), s.markdown);
-      for (const a of s.assets) put(join6(dir, "skills", s.slug, a.name), a.contentBase64);
+      writeFileSync5((mkdirSync4(join7(dir, "skills", s.slug), { recursive: true }), join7(dir, "skills", s.slug, "SKILL.md")), s.markdown);
+      for (const a of s.assets) put(join7(dir, "skills", s.slug, a.name), a.contentBase64);
     }
-    for (const f of x.files ?? []) if (f.contentBase64 !== void 0) put(join6(dir, "files", f.path), f.contentBase64);
+    for (const f of x.files ?? []) if (f.contentBase64 !== void 0) put(join7(dir, "files", f.path), f.contentBase64);
     const summary = { saved: dir, skills: (x.skills ?? []).map((s) => s.slug), files: (x.files ?? []).map((f) => f.path) };
     emit(
       ctx,
@@ -3195,30 +4175,30 @@ ${t("Edit it, then", "Ed\xEDtalo y luego")}: easybits apply ${out} --dry-run`
   }
 };
 function readTarget(target, usage2) {
-  if (!existsSync10(target)) throw usageError(t(`Not found: ${target}`, `No existe: ${target}`), usage2);
-  if (statSync6(target).isDirectory()) {
-    const name = SPEC_NAMES.find((n) => existsSync10(join6(target, n)));
+  if (!existsSync12(target)) throw usageError(t(`Not found: ${target}`, `No existe: ${target}`), usage2);
+  if (statSync8(target).isDirectory()) {
+    const name = SPEC_NAMES.find((n) => existsSync12(join7(target, n)));
     if (!name) throw usageError(t(`${target} has no agent.yaml.`, `${target} no tiene agent.yaml.`), usage2);
-    return { text: readFileSync11(join6(target, name), "utf8"), dir: target };
+    return { text: readFileSync13(join7(target, name), "utf8"), dir: target };
   }
-  return { text: readFileSync11(target, "utf8") };
+  return { text: readFileSync13(target, "utf8") };
 }
 var line = (c) => `${c.op} ${c.what}`;
 var printPlan = (plan) => console.log(plan.map(line).join("\n"));
 function saveBackup(id, yaml) {
-  const dir = join6(homedir3(), ".easybits", "backups");
+  const dir = join7(homedir3(), ".easybits", "backups");
   mkdirSync4(dir, { recursive: true });
-  const path = join6(dir, `${id}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.yaml`);
+  const path = join7(dir, `${id}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.yaml`);
   writeFileSync5(path, yaml);
   return path;
 }
 async function applyTarget(ctx, target, o) {
   const { text, dir } = readTarget(target, o.usage);
-  const { secrets, missing } = secretsFor(text);
+  const { secrets: secrets2, missing } = secretsFor(text);
   const uploads = dir ? readUploads(dir) : {};
   if (o.create) {
     if (o.agent) throw usageError(t("Use --agent or --create, not both.", "Usa --agent o --create, no los dos."), o.usage);
-    const body2 = { spec: text, secrets, ...o.name ? { name: o.name } : {} };
+    const body2 = { spec: text, secrets: secrets2, ...o.name ? { name: o.name } : {} };
     const plan2 = await api(ctx, "POST", "/agents/apply", { ...body2, dryRun: true });
     if (o.dryRun) {
       emit(ctx, { create: true, ...plan2, ...uploads.skills ? { skills: Object.keys(uploads.skills) } : {}, ...uploads.files ? { files: Object.keys(uploads.files) } : {} }, () => {
@@ -3239,7 +4219,7 @@ async function applyTarget(ctx, target, o) {
     if (/\n?(skills|files):/m.test(text) || uploads.skills || uploads.files) {
       await waitMachine(ctx, id2).catch(() => {
       });
-      rest = await api(ctx, "POST", `/agents/${id2}/apply`, { spec: text, secrets, ...uploads, ...o.name ? { name: o.name } : {} });
+      rest = await api(ctx, "POST", `/agents/${id2}/apply`, { spec: text, secrets: secrets2, ...uploads, ...o.name ? { name: o.name } : {} });
     }
     const extra = (rest?.plan ?? []).filter((c) => c.op !== "!" && !/^(prompt|env)\b/.test(c.what));
     const res = { agentId: id2, sandboxId: created.sandboxId, plan: [...created.plan, ...extra], applied: rest?.applied, failed: rest?.failed };
@@ -3258,7 +4238,7 @@ async function applyTarget(ctx, target, o) {
 `, `No est\xE1n en tu entorno (conservan su valor de hoy): ${missing.join(", ")}
 `));
   const path = `/agents/${id}/apply`;
-  const body = { spec: text, secrets, ...uploads, ...o.prune ? { prune: true } : {} };
+  const body = { spec: text, secrets: secrets2, ...uploads, ...o.prune ? { prune: true } : {} };
   const plan = await api(ctx, "POST", path, { ...body, dryRun: true });
   const actionable = plan.plan.filter((c) => c.op !== "!");
   if (o.dryRun || !actionable.length) {
@@ -3324,7 +4304,7 @@ var apply = {
 // src/commands/agents.ts
 function isLegacyExport(path) {
   try {
-    return existsSync11(path) && !statSync7(path).isDirectory() && /"kind"\s*:\s*"easybits\.agent"/.test(readFileSync12(path, "utf8"));
+    return existsSync13(path) && !statSync9(path).isDirectory() && /"kind"\s*:\s*"easybits\.agent"/.test(readFileSync14(path, "utf8"));
   } catch {
     return false;
   }
@@ -3391,9 +4371,9 @@ var agents = {
         if (promptInline != null && promptFile) throw usageError(t("Use --prompt or --prompt-file, not both.", "Usa --prompt o --prompt-file, no los dos."), this.usage);
         const mode = str(ctx, "prompt-mode");
         if (mode && mode !== "append" && mode !== "replace") throw usageError(t("--prompt-mode must be append or replace.", "--prompt-mode debe ser append o replace."), this.usage);
-        if (promptFile && !existsSync11(promptFile)) throw usageError(t(`File not found: ${promptFile}`, `No existe el archivo: ${promptFile}`), this.usage);
+        if (promptFile && !existsSync13(promptFile)) throw usageError(t(`File not found: ${promptFile}`, `No existe el archivo: ${promptFile}`), this.usage);
         const mcpFile = str(ctx, "mcp-file");
-        if (mcpFile && !existsSync11(mcpFile)) throw usageError(t(`File not found: ${mcpFile}`, `No existe el archivo: ${mcpFile}`), this.usage);
+        if (mcpFile && !existsSync13(mcpFile)) throw usageError(t(`File not found: ${mcpFile}`, `No existe el archivo: ${mcpFile}`), this.usage);
         if (bool(ctx, "copy-files") && !like && !from) throw usageError(t("--copy-files needs --like or --from.", "--copy-files necesita --like o --from."), this.usage);
         if (from && !isLegacyExport(from)) {
           await applyTarget(ctx, from, { create: true, name: str(ctx, "name"), dryRun: bool(ctx, "dry-run"), usage: this.usage });
@@ -3403,7 +4383,7 @@ var agents = {
         const template = str(ctx, "template") ?? source?.template;
         if (!template) throw usageError(t("Missing --template (or --like / --from).", "Falta --template (o --like / --from)."), this.usage);
         const env = await envFrom(ctx, this.usage);
-        const prompt = promptInline ?? (promptFile ? readFileSync12(promptFile, "utf8") : source?.systemPrompt);
+        const prompt = promptInline ?? (promptFile ? readFileSync14(promptFile, "utf8") : source?.systemPrompt);
         const promptMode = mode ?? source?.systemPromptMode;
         const multiline = !!prompt && /[\r\n]/.test(prompt.trimEnd());
         const promptAfter = multiline ? prompt : void 0;
@@ -3412,7 +4392,7 @@ var agents = {
         }
         if (prompt && !multiline) env.SYSTEM_PROMPT = prompt.trimEnd();
         if (promptMode && (prompt || mode) && !multiline) env.SYSTEM_PROMPT_MODE = promptMode;
-        const mcpServers = mcpFile ? parseMcpFile(readFileSync12(mcpFile, "utf8"), this.usage) : source?.mcpServers;
+        const mcpServers = mcpFile ? parseMcpFile(readFileSync14(mcpFile, "utf8"), this.usage) : source?.mcpServers;
         if (mcpServers && hasMasked(mcpServers)) {
           throw usageError(t(`${from ?? "the source"} has masked MCP values (\u2026***).`, `${from ?? "la fuente"} trae valores del MCP tapados (\u2026***).`), t("Re-export with --show-secrets, or pass --mcp-file", "Vuelve a exportar con --show-secrets, o pasa --mcp-file"));
         }
@@ -3508,10 +4488,201 @@ var agents = {
   }
 };
 
+// src/commands/fleet.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync14, readFileSync as readFileSync15 } from "fs";
+var fleetRecord = (p) => ({
+  id: p.id,
+  name: p.name ?? null,
+  assistantName: p.assistantName ?? null,
+  workerTemplate: p.workerTemplate ?? null,
+  hasOwnNumber: !!p.hasOwnNumber,
+  createdAt: p.createdAt ?? null
+});
+var CONFIGURE_USAGE = "easybits fleet configure <agent> [--name <name>] [--prompt-file <file|->] [--engine <id>] [--model <id>] [--effort <level>] [--own-number on|off] [--recycle]";
+function configureActions(f) {
+  const out = [];
+  if (f.name != null) out.push({ action: "set-name", name: f.name });
+  if (f.prompt != null) out.push({ action: "set-agent-prompt", systemPrompt: f.prompt });
+  if (f.engine != null) out.push({ action: "set-engine", engine: f.engine });
+  if (f.model != null) out.push({ action: "set-model", model: f.model });
+  if (f.effort != null) {
+    if (!["low", "medium", "high", "xhigh", "max"].includes(f.effort)) throw usageError(t("--effort is low, medium, high, xhigh or max.", "--effort es low, medium, high, xhigh o max."), CONFIGURE_USAGE);
+    out.push({ action: "set-effort", effort: f.effort });
+  }
+  if (f.ownNumber != null) {
+    if (f.ownNumber !== "on" && f.ownNumber !== "off") throw usageError(t("--own-number is on or off.", "--own-number es on u off."), CONFIGURE_USAGE);
+    out.push({ action: "toggle-own-number", on: f.ownNumber === "on" });
+  }
+  if (f.recycle) out.push({ action: "recycle-box" });
+  if (!out.length) throw usageError(t("Nothing to change: pass a flag (--name, --prompt-file, --model\u2026).", "Nada que cambiar: pasa una bandera (--name, --prompt-file, --model\u2026)."), CONFIGURE_USAGE);
+  return out;
+}
+async function readText(path, usage2) {
+  if (path === "-") return (await readStdin()).toString("utf8");
+  if (!existsSync14(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
+  return readFileSync15(path, "utf8");
+}
+var caps = (ctx, id, q) => api(ctx, "GET", `/fleet-agents/${encodeURIComponent(id)}/capabilities${q ? `?q=${encodeURIComponent(q)}` : ""}`);
+var fleet = {
+  name: "fleet",
+  aliases: ["flota"],
+  group: "Compute",
+  summary: "Fleet agents: one agent, many conversations (WhatsApp, WABA, Teams, web)",
+  synopsis: "fleet <ls|get|\u2026>",
+  subs: {
+    ls: {
+      aliases: ["list"],
+      summary: "List your fleet agents",
+      usage: "easybits fleet ls",
+      examples: ["easybits fleet ls", "easybits fleet ls --json"],
+      async run(ctx) {
+        const { pools } = await api(ctx, "GET", "/fleet-agents");
+        const rows = pools.map(fleetRecord);
+        emit(
+          ctx,
+          rows,
+          () => table(
+            rows.map((r) => ({ ...r, createdAt: fmtDate(r.createdAt) })),
+            [["id", "ID"], ["name", "NAME"], ["workerTemplate", "ENGINE"], ["createdAt", "CREATED"]],
+            t("No fleet agents yet. Create one at https://www.easybits.cloud/dash/flota", "Todav\xEDa no hay agentes de flota. Crea uno en https://www.easybits.cloud/dash/flota")
+          )
+        );
+      }
+    },
+    get: {
+      summary: "Show a fleet agent: engine, model, effort, prompt and channels",
+      usage: "easybits fleet get <agent> [--prompt-out <file>]",
+      options: { "prompt-out": { type: "string", value: "file", description: "Write the system prompt to a file instead of printing it" } },
+      examples: ["easybits fleet get soporte", "easybits fleet get soporte --json", "easybits fleet get soporte --prompt-out PROMPT.md"],
+      async run(ctx) {
+        const id = need(ctx, 0, "agent", this.usage);
+        const [{ pools }, view] = await Promise.all([api(ctx, "GET", "/fleet-agents"), caps(ctx, id)]);
+        const rec = fleetRecord(pools.find((p) => p.id === id) ?? { id });
+        const out = { ...rec, ...view.agent, engine: view.engine, channels: view.channels.map((c) => c.key), skills: view.skills, customMcps: view.customMcps };
+        const promptOut = str(ctx, "prompt-out");
+        if (promptOut) {
+          const { writeFileSync: writeFileSync11 } = await import("fs");
+          writeFileSync11(promptOut, view.agent.systemPrompt);
+          out.systemPrompt = { file: promptOut, bytes: Buffer.byteLength(view.agent.systemPrompt) };
+        }
+        emit(ctx, out, () => {
+          console.log(`ID:       ${rec.id}${rec.name ? `  (${rec.name})` : ""}`);
+          console.log(`${t("Engine:  ", "Motor:   ")} ${view.engine ?? view.agent.workerTemplate}${view.agent.modelLabel ? ` \xB7 ${view.agent.modelLabel}` : ""} \xB7 effort ${view.agent.effort}`);
+          console.log(`${t("Number:  ", "N\xFAmero:  ")} ${view.agent.hasOwnNumber ? t("dedicated", "dedicado") : t("shared (replies carry the name prefix)", "compartido (las respuestas llevan el nombre)")}`);
+          console.log(`${t("Channels:", "Canales: ")} ${view.channels.map((c) => c.key).join(", ")}`);
+          if (view.skills.length) console.log(`Skills:   ${view.skills.map((s) => `${s.name}${s.enabled ? "" : " (off)"}`).join(", ")}`);
+          if (view.customMcps.length) console.log(`MCP:      ${view.customMcps.map((m) => m.name).join(", ")}`);
+          if (promptOut) console.log(t(`Prompt written to ${promptOut}`, `Prompt escrito en ${promptOut}`));
+          else console.log(`
+${view.agent.systemPrompt || t("(no system prompt)", "(sin system prompt)")}`);
+        });
+      }
+    },
+    capabilities: {
+      aliases: ["caps"],
+      summary: "The catalog and current state: engines, models, tool buckets, MCPs, skills, channels",
+      usage: "easybits fleet capabilities <agent> [--q <text>]",
+      options: { q: { type: "string", value: "text", description: "Filter the capabilities catalog" } },
+      examples: ["easybits fleet capabilities soporte --json", "easybits fleet caps soporte --q calendar"],
+      async run(ctx) {
+        const id = need(ctx, 0, "agent", this.usage);
+        const view = await caps(ctx, id, str(ctx, "q"));
+        emit(ctx, view, () => {
+          console.log(`${t("Engines:", "Motores:")}  ${view.engines.map((e) => `${e.id}${e.id === view.engine ? "*" : ""}${e.ready ? "" : " (soon)"}`).join(", ")}`);
+          console.log(`${t("Models: ", "Modelos:")}  ${view.models.map((m) => `${m.key}${m.key === view.agent.model ? "*" : ""}`).join(", ") || "-"}`);
+          console.log(`Effort:   ${view.efforts.map((e) => `${e}${e === view.agent.effort ? "*" : ""}`).join(", ")}`);
+          console.log(`Buckets:  ${view.agent.buckets.join(", ") || "-"}`);
+          console.log(`${t("Built-in:", "Incluidos:")} ${view.builtins.map((b) => b.name).join(", ")}`);
+          console.log(`${t("Channels:", "Canales:")}  ${view.channels.map((c) => c.key).join(", ")}`);
+          console.log(`${t("Secrets: ", "Secretos:")}  ${view.secretsPresent.join(", ") || "-"}`);
+          console.log(t("(* = current. --json has the full view: per-channel config, buckets and their tools.)", "(* = el actual. --json trae la vista completa: config por canal, buckets y sus tools.)"));
+        });
+      }
+    },
+    configure: {
+      aliases: ["set"],
+      summary: "Change name, system prompt, engine, model, effort or number mode; --recycle applies it now",
+      usage: CONFIGURE_USAGE,
+      options: {
+        name: { type: "string", value: "name", description: "Display name and the name the agent goes by" },
+        "prompt-file": { type: "string", value: "file|-", description: "System prompt for every channel (- reads stdin)" },
+        engine: { type: "string", value: "id", description: "Engine (claude, deepseek, codex\u2026); recycles its boxes by itself" },
+        model: { type: "string", value: "id", description: "Model of the current engine (see fleet capabilities)" },
+        effort: { type: "string", value: "level", description: "low, medium, high, xhigh or max" },
+        "own-number": { type: "string", value: "on|off", description: "on: dedicated number (no name prefix on replies)" },
+        recycle: { type: "boolean", description: "Recycle its running boxes so the change applies on the next turn" }
+      },
+      examples: [
+        "easybits fleet configure soporte --prompt-file PROMPT.md",
+        "easybits fleet configure soporte --model claude-sonnet-5-5 --effort high --recycle",
+        "easybits fleet configure soporte --name Nik --own-number on"
+      ],
+      async run(ctx) {
+        const id = need(ctx, 0, "agent", CONFIGURE_USAGE);
+        const promptFile = str(ctx, "prompt-file");
+        const actions = configureActions({
+          name: str(ctx, "name"),
+          prompt: promptFile ? await readText(promptFile, CONFIGURE_USAGE) : void 0,
+          engine: str(ctx, "engine"),
+          model: str(ctx, "model"),
+          effort: str(ctx, "effort"),
+          ownNumber: str(ctx, "own-number"),
+          recycle: bool(ctx, "recycle")
+        });
+        const applied = [];
+        for (const a of actions) {
+          await api(ctx, "POST", `/fleet-agents/${encodeURIComponent(id)}/capabilities`, a);
+          applied.push(String(a.action));
+        }
+        emit(ctx, { ok: true, applied }, () => {
+          console.log(t(`Applied: ${applied.join(", ")}`, `Aplicado: ${applied.join(", ")}`));
+          if (!applied.includes("recycle-box") && !applied.includes("set-engine")) {
+            console.log(t("Sleeping boxes pick it up when they wake; a running one when it sleeps (or pass --recycle).", "Las cajas dormidas lo toman al despertar; una corriendo, al dormirse (o pasa --recycle)."));
+          }
+        });
+      }
+    },
+    message: {
+      summary: "Send one message to a fleet agent and print its reply",
+      usage: "easybits fleet message <agent> <text|-> [--group <id>] [--config-group <id>] [--sender <who>] [--timezone <tz>]",
+      options: {
+        group: { type: "string", value: "id", description: "Conversation id; reuse it to continue (default: a new cli-<uuid>)" },
+        "config-group": { type: "string", value: "id", description: "Channel whose config (tools, MCP, prompt) applies, e.g. web or waba:<id>" },
+        sender: { type: "string", value: "who", description: "Who is writing (phone, user id)" },
+        timezone: { type: "string", value: "tz", description: "IANA timezone for the turn, e.g. America/Mexico_City" }
+      },
+      examples: [
+        'easybits fleet message soporte "\xBFqu\xE9 horarios tienen?" --config-group web',
+        'easybits fleet message soporte "y el s\xE1bado?" --group cli-1234 --config-group web   # same conversation',
+        "cat pregunta.txt | easybits fleet message soporte - --json"
+      ],
+      async run(ctx) {
+        const id = need(ctx, 0, "agent", this.usage);
+        let text = ctx.args.slice(1).join(" ");
+        if (text === "-") text = (await readStdin()).toString("utf8").trim();
+        if (!text) throw usageError(t("Missing <text>.", "Falta <text>."), this.usage);
+        const groupId = str(ctx, "group") ?? `cli-${randomUUID()}`;
+        const r = await api(ctx, "POST", `/fleet-agents/${encodeURIComponent(id)}/message`, {
+          groupId,
+          text,
+          configGroupId: str(ctx, "config-group"),
+          sender: str(ctx, "sender"),
+          timezone: str(ctx, "timezone")
+        });
+        emit(ctx, { ...r, groupId }, () => {
+          console.log(r.reply);
+          if (!str(ctx, "group")) console.error(t(`(continue with --group ${groupId})`, `(sigue con --group ${groupId})`));
+        });
+      }
+    }
+  }
+};
+
 // src/commands/completion.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 var GLOBAL_FLAGS = ["--json", "--token", "--lang", "--help", "--version"];
 var AGENT_FLAGS = /* @__PURE__ */ new Set(["--agent", "--like"]);
 var findSub = (c, name) => Object.entries(c.subs ?? {}).find(([n, l]) => n === name || l.aliases?.includes(name));
@@ -3548,11 +4719,11 @@ function completionFor(words, current2, commands) {
   if (spec && spec.index === n) return { kind: "names", ref: spec.kind };
   return { kind: "words", words: [] };
 }
-var cacheFile = () => join7(process.env.XDG_CACHE_HOME || join7(homedir4(), ".cache"), "easybits", "complete.json");
+var cacheFile = () => join8(process.env.XDG_CACHE_HOME || join8(homedir4(), ".cache"), "easybits", "complete.json");
 async function namesOf(ctx, kind) {
   let cache2 = {};
   try {
-    cache2 = JSON.parse(readFileSync13(cacheFile(), "utf8"));
+    cache2 = JSON.parse(readFileSync16(cacheFile(), "utf8"));
     const c = cache2[kind];
     if (c && Date.now() - c.at < 5 * 6e4) return c.names;
   } catch {
@@ -3634,7 +4805,7 @@ var completion = {
 
 // src/commands/docs.ts
 import { spawn as spawn2 } from "child_process";
-import { resolveBaseUrl as resolveBaseUrl5 } from "@easybits.cloud/sdk";
+import { resolveBaseUrl as resolveBaseUrl6 } from "@easybits.cloud/sdk";
 var docs = {
   name: "docs",
   group: "Help",
@@ -3649,7 +4820,7 @@ var docs = {
     },
     examples: ["easybits docs", "easybits docs cli --en", "easybits docs hosting", "easybits docs --open"],
     async run(ctx) {
-      const base = await resolveBaseUrl5();
+      const base = await resolveBaseUrl6();
       const prefix = bool(ctx, "en") ? "/en/docs" : "/docs";
       const section = ctx.args[0];
       if (!section) {
@@ -3679,16 +4850,16 @@ var docs = {
 };
 
 // src/commands/doctor.ts
-import { existsSync as existsSync12, statSync as statSync8 } from "fs";
+import { existsSync as existsSync15, statSync as statSync10 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
-import { resolveBaseUrl as resolveBaseUrl6 } from "@easybits.cloud/sdk";
+import { join as join10 } from "path";
+import { resolveBaseUrl as resolveBaseUrl7 } from "@easybits.cloud/sdk";
 
 // src/update.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join8 } from "path";
-var FILE = join8(process.env.XDG_CONFIG_HOME || join8(homedir5(), ".config"), "easybits", "update.json");
+import { dirname as dirname4, join as join9 } from "path";
+var FILE = join9(process.env.XDG_CONFIG_HOME || join9(homedir5(), ".config"), "easybits", "update.json");
 var TTL = 60 * 60 * 1e3;
 var UPGRADE = "npm i -g @easybits.cloud/cli@latest";
 function newer(a, b) {
@@ -3700,7 +4871,7 @@ function newer(a, b) {
 var updateCheckDisabled = () => Boolean(process.env.EASYBITS_NO_UPDATE_CHECK || process.env.CI);
 function readCache() {
   try {
-    return JSON.parse(readFileSync14(FILE, "utf8"));
+    return JSON.parse(readFileSync17(FILE, "utf8"));
   } catch {
     return {};
   }
@@ -3739,7 +4910,7 @@ async function updateNotice(current2) {
 }
 
 // src/commands/doctor.ts
-var VERSION = true ? "0.15.5" : "dev";
+var VERSION = true ? "0.17.0" : "dev";
 var doctor2 = {
   name: "doctor",
   group: "Account",
@@ -3764,7 +4935,7 @@ var doctor2 = {
           ...old ? { hint: `${t("Run", "Corre")}: ${UPGRADE}` } : {}
         });
       }
-      const base = await resolveBaseUrl6();
+      const base = await resolveBaseUrl7();
       const health = await fetch(`${base.replace(/\/+$/, "")}/api/health`, { signal: AbortSignal.timeout(5e3) }).then((r) => ({ ok: r.ok, detail: `${base} (${r.status})` })).catch((e) => ({ ok: false, detail: `${base}: ${e.message}` }));
       checks.push({ check: "api", ...health, ...health.ok ? {} : { hint: t("Check your network or EASYBITS_URL.", "Revisa tu red o EASYBITS_URL.") } });
       const rc = readRc();
@@ -3782,9 +4953,9 @@ var doctor2 = {
           checks.push({ check: "credential-env", ok: true, detail: t("EASYBITS_API_KEY wins over the saved login in ~/.easybitsrc", "EASYBITS_API_KEY le gana a la sesi\xF3n guardada en ~/.easybitsrc") });
         }
       }
-      const rcPath = join9(homedir6(), ".easybitsrc");
-      if (existsSync12(rcPath)) {
-        const mode = statSync8(rcPath).mode & 511;
+      const rcPath = join10(homedir6(), ".easybitsrc");
+      if (existsSync15(rcPath)) {
+        const mode = statSync10(rcPath).mode & 511;
         const ok2 = (mode & 63) === 0;
         checks.push({ check: "rc-file", ok: ok2, detail: `${rcPath} ${mode.toString(8).padStart(3, "0")}`, ...ok2 ? {} : { hint: t(`It holds tokens. Run: chmod 600 ${rcPath}`, `Guarda tokens. Corre: chmod 600 ${rcPath}`) } });
       }
@@ -3801,23 +4972,1254 @@ var doctor2 = {
   }
 };
 
-// src/commands/index.ts
-var COMMANDS = [
-  login,
-  logout,
-  whoami,
+// src/commands/web.ts
+import { writeFileSync as writeFileSync8 } from "fs";
+import { EasybitsError as EasybitsError4 } from "@easybits.cloud/sdk";
+var ENGINES = ["google", "bing", "yandex", "duckduckgo"];
+var PACKS_URL = "https://www.easybits.cloud/dash/packs?tab=web";
+async function web(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (e instanceof EasybitsError4 && e.status === 402) {
+      const buy = /"buy"\s*:\s*"([^"]+)"/.exec(String(e.body ?? ""))?.[1] ?? PACKS_URL;
+      throw new CliError(t("No web queries left.", "Ya no te quedan consultas web."), EXIT.API, t(`Buy a pack: ${buy}`, `Compra un paquete: ${buy}`), "quota_exceeded", 402);
+    }
+    if (e instanceof EasybitsError4 && e.status === 429) {
+      throw new CliError(t("The source is cooling down that query.", "La fuente puso esa consulta en pausa."), EXIT.API, t("Try again in about a minute.", "Vuelve a intentar en un minuto."), "upstream_cooldown", 429);
+    }
+    throw e;
+  }
+}
+function organicResults(results) {
+  const r = results ?? {};
+  const items = Array.isArray(r.organic) ? r.organic : Array.isArray(results) ? results : [];
+  return items.map((o, i) => ({ rank: i + 1, title: (o.title ?? "").trim(), url: o.link ?? o.url ?? "" })).filter((o) => o.url);
+}
+function extractInput(inputJson, urls, usage2) {
+  if (inputJson && urls.length) throw usageError(t("Pass --input or --url, not both.", "Pasa --input o --url, no ambos."), usage2);
+  if (urls.length) return urls.map((url) => ({ url }));
+  if (!inputJson) throw usageError(t("Missing --input <json> (or --url <url>).", "Falta --input <json> (o --url <url>)."), usage2);
+  try {
+    const v = JSON.parse(inputJson);
+    if (v && typeof v === "object") return v;
+  } catch {
+  }
+  throw usageError(t(`--input must be a JSON object or array, got: ${inputJson}`, `--input debe ser un objeto o arreglo JSON, lleg\xF3: ${inputJson}`), usage2);
+}
+function printJob(ctx, job) {
+  emit(ctx, job, () => {
+    if (job.status === "running") {
+      console.log(t(`Job ${job.jobId} running (${job.source}). Check it with: easybits web extract-status ${job.jobId}`, `Trabajo ${job.jobId} corriendo (${job.source}). Rev\xEDsalo con: easybits web extract-status ${job.jobId}`));
+    } else if (job.status === "error") {
+      console.log(t(`Job ${job.jobId} failed: ${job.error ?? "unknown error"}`, `El trabajo ${job.jobId} fall\xF3: ${job.error ?? "error desconocido"}`));
+    } else {
+      for (const r of job.records ?? []) console.log(JSON.stringify(r));
+      console.error(t(`${job.records?.length ?? 0} records (${job.source}).`, `${job.records?.length ?? 0} registros (${job.source}).`));
+    }
+  });
+  if (job.status === "error") process.exitCode = EXIT.API;
+}
+var webCmd = {
+  name: "web",
+  group: "Web",
+  summary: "Search, read, extract and crawl the web (metered in web queries)",
+  synopsis: "web",
+  subs: {
+    search: {
+      summary: "Search Google, Bing, Yandex or DuckDuckGo (1 query)",
+      usage: "easybits web search <query...> [--engine google|bing|yandex|duckduckgo] [--country <cc>]",
+      options: {
+        engine: { type: "string", value: "name", description: "google (default), bing, yandex or duckduckgo" },
+        country: { type: "string", value: "cc", description: "ISO country for localized results (mx, us\u2026)" }
+      },
+      examples: ["easybits web search dentista polanco --country mx", `easybits web search "react router 7 loaders" --json | jq '.results.organic[0]'`],
+      async run(ctx) {
+        const query = ctx.args.join(" ").trim();
+        if (!query) throw usageError(t("Missing <query>.", "Falta <query>."), this.usage);
+        const engine = str(ctx, "engine");
+        if (engine && !ENGINES.includes(engine)) throw usageError(t(`--engine must be one of: ${ENGINES.join(", ")}.`, `--engine debe ser uno de: ${ENGINES.join(", ")}.`), this.usage);
+        const eb = await getClient(ctx);
+        const r = await web(() => eb.webSearch({ query, engine, country: str(ctx, "country") }));
+        emit(ctx, r, () => table(organicResults(r.results), [["rank", "#"], ["title", "TITLE"], ["url", "URL"]], t("No results.", "Sin resultados.")));
+      }
+    },
+    fetch: {
+      summary: "Read a page even if it blocks bots: raw HTML or clean markdown (1 query)",
+      usage: "easybits web fetch <url> [--markdown] [--main] [--country <cc>] [--out <file>]",
+      options: {
+        markdown: { type: "boolean", description: "Clean markdown instead of raw HTML" },
+        main: { type: "boolean", description: "With --markdown: drop nav, footer and icons" },
+        country: { type: "string", value: "cc", description: "ISO country to fetch from (mx, us\u2026)" },
+        out: { type: "string", value: "file", description: "Save the body to a file instead of stdout" }
+      },
+      examples: ["easybits web fetch https://example.com --markdown --main", "easybits web fetch https://example.com --out page.html"],
+      async run(ctx) {
+        const url = need(ctx, 0, "url", this.usage);
+        const asMarkdown = bool(ctx, "markdown");
+        if (bool(ctx, "main") && !asMarkdown) throw usageError(t("--main only works with --markdown.", "--main s\xF3lo funciona con --markdown."), this.usage);
+        const eb = await getClient(ctx);
+        const r = await web(() => eb.webFetch({ url, asMarkdown, onlyMainContent: bool(ctx, "main") || void 0, country: str(ctx, "country") }));
+        const out = str(ctx, "out");
+        if (out) {
+          writeFileSync8(out, r.body);
+          const { body: _b, ...meta } = r;
+          emit(ctx, { ...meta, out, bytes: Buffer.byteLength(r.body) }, () => console.error(t(`Saved ${fmtBytes(Buffer.byteLength(r.body))} to ${out} (HTTP ${r.statusCode})`, `Guard\xE9 ${fmtBytes(Buffer.byteLength(r.body))} en ${out} (HTTP ${r.statusCode})`)));
+          return;
+        }
+        emit(ctx, r, () => process.stdout.write(r.body.endsWith("\n") ? r.body : r.body + "\n"));
+      }
+    },
+    extract: {
+      summary: "Structured records from a known source (Google Maps, Mercado Libre\u2026); 1 query per record",
+      usage: "easybits web extract <source> (--input <json> | --url <url>...) [--limit <n>] [--wait]",
+      options: {
+        input: { type: "string", value: "json", description: 'Input for the source: [{"keyword":"\u2026","country":"MX"}], {"query":"\u2026"} or [{"url":"\u2026"}]' },
+        url: { type: "string", multiple: true, value: "url", description: `Shortcut for --input '[{"url":\u2026}]' (repeatable)` },
+        limit: { type: "string", value: "n", description: "Max records per input (default 20, max 200)" },
+        dataset: { type: "string", value: "id", description: "Catalog dataset id, for sources not on the list (source becomes optional)" },
+        wait: { type: "boolean", description: "Wait for the job to finish (polls every 15 s, up to 5 min)" }
+      },
+      examples: [
+        `easybits web extract google_maps --input '[{"keyword":"dentista Polanco CDMX","country":"MX"}]' --limit 50 --wait`,
+        `easybits web extract mercadolibre --input '{"query":"iphone 15"}' --json`,
+        "easybits web extract instagram_profiles --url https://instagram.com/easybits --wait"
+      ],
+      async run(ctx) {
+        const dataset = str(ctx, "dataset");
+        const source = ctx.args[0];
+        if (!source && !dataset) throw usageError(t("Missing <source> (or --dataset <id>).", "Falta <source> (o --dataset <id>)."), this.usage);
+        const input = extractInput(str(ctx, "input"), list(ctx, "url"), this.usage);
+        const limit = int(ctx, "limit", this.usage);
+        const params = { source, datasetId: dataset, input, limit };
+        const eb = await getClient(ctx);
+        const job = await web(() => bool(ctx, "wait") ? eb.webExtractAndWait(params) : eb.webExtract(params));
+        printJob(ctx, job);
+      }
+    },
+    "extract-status": {
+      summary: "Check an extract job; when done, prints its records",
+      usage: "easybits web extract-status <jobId>",
+      examples: ["easybits web extract-status j_abc123", "easybits web extract-status j_abc123 --json | jq '.records | length'"],
+      async run(ctx) {
+        const jobId = need(ctx, 0, "jobId", this.usage);
+        const eb = await getClient(ctx);
+        printJob(ctx, await web(() => eb.webExtractStatus(jobId)));
+      }
+    },
+    crawl: {
+      summary: "Read a page and follow its internal links as markdown (1 query per page)",
+      usage: "easybits web crawl <url> [--max-pages <n>] [--main] [--country <cc>]",
+      options: {
+        "max-pages": { type: "string", value: "n", description: "Pages to read, 1-20 (default 10)" },
+        main: { type: "boolean", description: "Drop nav, footer and icons from each page (good for RAG)" },
+        country: { type: "string", value: "cc", description: "ISO country to fetch from (mx, us\u2026)" }
+      },
+      examples: ["easybits web crawl https://docs.example.com --max-pages 5 --main", "easybits web crawl https://example.com --json | jq '.pages[].url'"],
+      async run(ctx) {
+        const url = need(ctx, 0, "url", this.usage);
+        const maxPages = int(ctx, "max-pages", this.usage);
+        if (maxPages != null && (maxPages < 1 || maxPages > 20)) throw usageError(t("--max-pages must be 1-20.", "--max-pages debe ser de 1 a 20."), this.usage);
+        const eb = await getClient(ctx);
+        const r = await web(() => eb.webCrawl({ url, maxPages, onlyMainContent: bool(ctx, "main") || void 0, country: str(ctx, "country") }));
+        emit(ctx, r, () => {
+          for (const p of r.pages) console.log(`<!-- ${p.url} -->
+${p.markdown.trim()}
+`);
+          console.error(
+            t(`${r.pages.length} pages; ${r.pending.length} links not visited (--json to get them).`, `${r.pages.length} p\xE1ginas; ${r.pending.length} links sin visitar (--json para verlos).`)
+          );
+        });
+      }
+    }
+  }
+};
+
+// src/commands/webhooks.ts
+function eventList(values) {
+  return [...new Set(values.flatMap((v) => v.split(",")).map((s) => s.trim()).filter(Boolean))];
+}
+function scopeList(value) {
+  if (value == null) return void 0;
+  const out = [...new Set(value.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean))];
+  return out.length ? out : void 0;
+}
+function matchKey(ref, keys2) {
+  const byId = keys2.find((k) => k.id === ref);
+  if (byId) return { id: byId.id };
+  const r = ref.trim();
+  const found = keys2.filter((k) => k.status !== "REVOKED" && (k.prefix === r || k.name.toLowerCase() === r.toLowerCase()));
+  return found.length === 1 ? { id: found[0].id } : { matches: found };
+}
+var EVENT_OPTION = {
+  event: { type: "string", multiple: true, value: "name", description: "Event to deliver (repeatable or comma-separated): file.created, website.deleted, form.submitted\u2026" }
+};
+var webhooks = {
+  name: "webhooks",
+  aliases: ["webhook"],
+  group: "Account",
+  summary: "Webhooks: HTTPS POSTs signed with HMAC when your files, websites or forms change",
+  synopsis: "webhooks",
+  subs: {
+    ls: {
+      aliases: ["list"],
+      summary: "List your webhooks",
+      usage: "easybits webhooks ls",
+      examples: ["easybits webhooks ls", "easybits webhooks ls --json"],
+      async run(ctx) {
+        const { items } = await (await getClient(ctx)).listWebhooks();
+        emit(
+          ctx,
+          items,
+          () => table(
+            items.map((w) => ({ ...w, events: w.events.join(","), fails: w.failCount })),
+            [["id", "ID"], ["url", "URL"], ["events", "EVENTS"], ["status", "STATUS"], ["fails", "FAILS"]],
+            t("No webhooks. Create one: easybits webhooks create https://example.com/hook --event file.created", "Sin webhooks. Crea uno: easybits webhooks create https://ejemplo.com/hook --event file.created")
+          )
+        );
+      }
+    },
+    create: {
+      summary: "Create a webhook; prints its signing secret ONCE",
+      usage: "easybits webhooks create <https-url> --event <name>...",
+      options: { ...EVENT_OPTION },
+      examples: [
+        "easybits webhooks create https://example.com/hook --event file.created --event file.deleted",
+        "easybits webhooks create https://example.com/hook --event form.submitted --json | jq -r .secret"
+      ],
+      async run(ctx) {
+        const url = need(ctx, 0, "https-url", this.usage);
+        const events = eventList(list(ctx, "event"));
+        if (!events.length) throw usageError(t("Missing --event (at least one).", "Falta --event (al menos uno)."), this.usage);
+        const w = await (await getClient(ctx)).createWebhook({ url, events });
+        emit(ctx, w, () => {
+          console.log(t(`Created ${w.id} \u2192 ${w.url} (${w.events.join(", ")})`, `Creado ${w.id} \u2192 ${w.url} (${w.events.join(", ")})`));
+          console.log(`${t("Signing secret", "Secreto de firma")}: ${w.secret}`);
+          console.error(
+            t(
+              "Save it now: it is not shown again. Verify X-Easybits-Signature (HMAC-SHA256 of the body) with it.",
+              "Gu\xE1rdalo ya: no se vuelve a mostrar. Con \xE9l verificas X-Easybits-Signature (HMAC-SHA256 del cuerpo)."
+            )
+          );
+        });
+      }
+    },
+    update: {
+      summary: "Change a webhook's URL or events, or pause/resume it",
+      usage: "easybits webhooks update <id> [--url <https-url>] [--event <name>...] [--pause|--resume]",
+      options: {
+        url: { type: "string", value: "https-url", description: "New destination URL" },
+        ...EVENT_OPTION,
+        pause: { type: "boolean", description: "Stop deliveries (status PAUSED)" },
+        resume: { type: "boolean", description: "Deliver again and reset the failure count (status ACTIVE)" }
+      },
+      examples: ["easybits webhooks update 66f0c2a1b2c3d4e5f6a7b8c9 --event file.created,file.updated", "easybits webhooks update 66f0c2a1b2c3d4e5f6a7b8c9 --resume"],
+      async run(ctx) {
+        const id = need(ctx, 0, "id", this.usage);
+        if (bool(ctx, "pause") && bool(ctx, "resume")) throw usageError(t("Pass --pause or --resume, not both.", "Pasa --pause o --resume, no ambos."), this.usage);
+        const events = eventList(list(ctx, "event"));
+        const params = {
+          ...str(ctx, "url") ? { url: str(ctx, "url") } : {},
+          ...events.length ? { events } : {},
+          ...bool(ctx, "pause") ? { status: "PAUSED" } : bool(ctx, "resume") ? { status: "ACTIVE" } : {}
+        };
+        if (!Object.keys(params).length) throw usageError(t("Nothing to change: pass --url, --event, --pause or --resume.", "Nada que cambiar: pasa --url, --event, --pause o --resume."), this.usage);
+        const w = await (await getClient(ctx)).updateWebhook(id, params);
+        emit(ctx, w, () => console.log(t(`Updated ${w.id}: ${w.url} (${w.events.join(", ")}) ${w.status}`, `Actualizado ${w.id}: ${w.url} (${w.events.join(", ")}) ${w.status}`)));
+      }
+    },
+    rm: {
+      aliases: ["remove", "delete"],
+      summary: "Delete a webhook",
+      usage: "easybits webhooks rm <id> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits webhooks rm 66f0c2a1b2c3d4e5f6a7b8c9 --yes"],
+      async run(ctx) {
+        const id = need(ctx, 0, "id", this.usage);
+        requireYesIfHeadless(ctx);
+        await confirm(ctx, t(`Delete webhook ${id}? Deliveries stop right away.`, `\xBFBorrar el webhook ${id}? Las entregas paran de inmediato.`));
+        const r = await (await getClient(ctx)).deleteWebhook(id);
+        emit(ctx, { ...r, id }, () => console.log(t(`Deleted ${id}`, `Borrado ${id}`)));
+      }
+    }
+  }
+};
+async function resolveKey(ctx, ref) {
+  const { keys: keys2 } = await (await getClient(ctx)).listKeys();
+  const m = matchKey(ref, keys2);
+  if ("id" in m) return keys2.find((k) => k.id === m.id);
+  if (!m.matches.length) {
+    throw new CliError(t(`No active key with id, name or prefix "${ref}".`, `No hay key activa con id, nombre o prefijo "${ref}".`), EXIT.API, `${t("List them with", "Enl\xEDstalas con")}: easybits keys ls`, "not_found", 404);
+  }
+  throw new CliError(
+    t(`"${ref}" matches ${m.matches.length} keys. Use the id:`, `"${ref}" coincide con ${m.matches.length} keys. Usa el id:`),
+    EXIT.USAGE,
+    m.matches.map((k) => `  ${k.id}  ${k.prefix}\u2026  ${k.name}`).join("\n"),
+    "ambiguous"
+  );
+}
+var keys = {
+  name: "keys",
+  aliases: ["key"],
+  group: "Account",
+  summary: "API keys of your account: list, create, revoke",
+  synopsis: "keys",
+  subs: {
+    ls: {
+      aliases: ["list"],
+      summary: "List your API keys (prefix only; the full key is never shown again)",
+      usage: "easybits keys ls",
+      examples: ["easybits keys ls", "easybits keys ls --json"],
+      async run(ctx) {
+        const { keys: items } = await (await getClient(ctx)).listKeys();
+        emit(
+          ctx,
+          items,
+          () => table(
+            items.map((k) => ({ ...k, prefix: `${k.prefix}\u2026`, scopes: k.scopes.join(","), createdAt: fmtDate(k.createdAt), expiresAt: k.expiresAt ? fmtDate(k.expiresAt) : t("never", "nunca") })),
+            [["id", "ID"], ["name", "NAME"], ["prefix", "PREFIX"], ["scopes", "SCOPES"], ["status", "STATUS"], ["expiresAt", "EXPIRES"]],
+            t("No API keys.", "Sin API keys.")
+          )
+        );
+      }
+    },
+    create: {
+      summary: "Create an API key; prints it ONCE",
+      usage: "easybits keys create <name> [--scopes READ,WRITE,DELETE] [--expires <date>]",
+      options: {
+        scopes: { type: "string", value: "list", description: "Comma-separated: READ, WRITE, DELETE, ADMIN (default READ,WRITE,DELETE; never more than your own credential has)" },
+        expires: { type: "string", value: "date", description: "Expiry date (ISO, e.g. 2027-01-31); default never" }
+      },
+      examples: [
+        "easybits keys create ci-deploy",
+        "easybits keys create dashboard-readonly --scopes READ --expires 2027-01-31",
+        "KEY=$(easybits keys create ci --json | jq -r .raw)"
+      ],
+      async run(ctx) {
+        const name = need(ctx, 0, "name", this.usage);
+        const expires = str(ctx, "expires");
+        if (expires && Number.isNaN(new Date(expires).getTime())) throw usageError(t(`--expires must be a date (2027-01-31), got "${expires}".`, `--expires debe ser una fecha (2027-01-31), lleg\xF3 "${expires}".`), this.usage);
+        const k = await api(ctx, "POST", "/keys", { name, scopes: scopeList(str(ctx, "scopes")), ...expires ? { expiresAt: new Date(expires).toISOString() } : {} });
+        emit(ctx, k, () => {
+          console.log(t(`Created ${k.name} (${k.id}) \u2014 ${k.scopes.join(", ")}`, `Creada ${k.name} (${k.id}) \u2014 ${k.scopes.join(", ")}`));
+          console.log(k.raw);
+          console.error(t("Save it now: it is not shown again (keys ls only shows the prefix).", "Gu\xE1rdala ya: no se vuelve a mostrar (keys ls s\xF3lo muestra el prefijo)."));
+        });
+      }
+    },
+    revoke: {
+      aliases: ["rm", "delete"],
+      summary: "Revoke an API key (by id, name or prefix); anything using it stops working",
+      usage: "easybits keys revoke <id|name|prefix> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits keys revoke ci-deploy", "easybits keys revoke eb_sk_live_abcd1234 --yes"],
+      async run(ctx) {
+        const ref = need(ctx, 0, "key", this.usage);
+        requireYesIfHeadless(ctx);
+        const k = await resolveKey(ctx, ref);
+        const self = (await resolveCredential(ctx)).startsWith(k.prefix);
+        await confirm(
+          ctx,
+          self ? t(`Revoke ${k.name} (${k.prefix}\u2026)? It is the key THIS CLI is using: you will need easybits login after.`, `\xBFRevocar ${k.name} (${k.prefix}\u2026)? Es la key que usa ESTE CLI: despu\xE9s tendr\xE1s que correr easybits login.`) : t(`Revoke ${k.name} (${k.prefix}\u2026)? Anything using it stops working right away.`, `\xBFRevocar ${k.name} (${k.prefix}\u2026)? Lo que la use deja de funcionar de inmediato.`)
+        );
+        const r = await api(ctx, "DELETE", `/keys/${encodeURIComponent(k.id)}`);
+        emit(ctx, { ...r, id: k.id, name: k.name, prefix: k.prefix }, () => console.log(t(`Revoked ${k.name} (${k.prefix}\u2026)`, `Revocada ${k.name} (${k.prefix}\u2026)`)));
+      }
+    }
+  }
+};
+
+// src/commands/secrets.ts
+var NAME = /^[A-Z_][A-Z0-9_]*$/;
+var SET_USAGE = "easybits secrets set (--dotenv <path|-> | <NAME> < value)";
+async function secretsToSet(args, dotenv, stdin) {
+  if (args.some((a) => a.includes("="))) {
+    throw usageError(t("Values never go in argv (ps and shell history see them). Use --dotenv or stdin.", "Los valores nunca van en argv (los ven ps y el historial). Usa --dotenv o stdin."), SET_USAGE);
+  }
+  if (dotenv && args.length) throw usageError(t("Give --dotenv or a NAME, not both.", "Pasa --dotenv o un NOMBRE, no los dos."), SET_USAGE);
+  let values;
+  if (dotenv) values = await readEnvFile(dotenv, SET_USAGE);
+  else if (args.length === 1) {
+    const v = (await stdin()).replace(/\r?\n$/, "");
+    values = { [args[0]]: v };
+  } else throw usageError(t("Give --dotenv <path|-> or one NAME with the value on stdin.", "Pasa --dotenv <ruta|-> o un NOMBRE con el valor por stdin."), SET_USAGE);
+  for (const [k, v] of Object.entries(values)) {
+    if (!NAME.test(k)) throw usageError(t(`Bad name "${k}": use [A-Z_][A-Z0-9_]* (e.g. GITHUB_TOKEN).`, `Nombre inv\xE1lido "${k}": usa [A-Z_][A-Z0-9_]* (p. ej. GITHUB_TOKEN).`), SET_USAGE);
+    if (!v) throw usageError(t(`Empty value for ${k}.`, `Valor vac\xEDo para ${k}.`), SET_USAGE);
+  }
+  if (!Object.keys(values).length) throw usageError(t("Nothing to save.", "Nada que guardar."), SET_USAGE);
+  return values;
+}
+var secrets = {
+  name: "secrets",
+  aliases: ["secret"],
+  group: "Account",
+  summary: "Your account's secrets vault: names only; used as $secret:NAME",
+  synopsis: "secrets <ls|set|rm>",
+  subs: {
+    ls: {
+      aliases: ["list"],
+      summary: "List the names in your vault (values never come back)",
+      usage: "easybits secrets ls",
+      examples: ["easybits secrets ls", "easybits secrets ls --json"],
+      async run(ctx) {
+        const { items } = await api(ctx, "GET", "/secrets");
+        emit(
+          ctx,
+          { items },
+          () => table(
+            items.map((s) => ({ ...s, createdAt: fmtDate(s.createdAt), lastUsedAt: fmtDate(s.lastUsedAt) })),
+            [["name", "NAME"], ["createdAt", "CREATED"], ["lastUsedAt", "LAST USED"]],
+            t("No secrets yet. Save one: easybits secrets set --dotenv .env", "Todav\xEDa no hay secretos. Guarda uno: easybits secrets set --dotenv .env")
+          )
+        );
+      }
+    },
+    set: {
+      summary: "Save or replace secrets from a dotenv file, or one value from stdin",
+      usage: SET_USAGE,
+      options: { ...ENV_FILE_OPTION },
+      examples: [
+        "easybits secrets set --dotenv .env.production",
+        `printf '%s' "$TOKEN" | easybits secrets set GITHUB_TOKEN`,
+        "op read op://vault/stripe/key | easybits secrets set STRIPE_SECRET_KEY   # from a password manager"
+      ],
+      async run(ctx) {
+        if (ctx.args.length === 1 && !str(ctx, "dotenv") && process.stdin.isTTY) {
+          throw usageError(t(`Pipe the value on stdin: printf '%s' "$VALUE" | easybits secrets set ${ctx.args[0]}`, `Pasa el valor por stdin: printf '%s' "$VALOR" | easybits secrets set ${ctx.args[0]}`), SET_USAGE);
+        }
+        const values = await secretsToSet(ctx.args, str(ctx, "dotenv"), async () => (await readStdin()).toString("utf8"));
+        for (const [name, value] of Object.entries(values)) await api(ctx, "POST", "/secrets", { name, value });
+        const saved = Object.keys(values);
+        emit(ctx, { saved }, () => console.log(t(`Saved ${saved.join(", ")}. Use it as $secret:${saved[0]}`, `Guardado ${saved.join(", ")}. \xDAsalo como $secret:${saved[0]}`)));
+      }
+    },
+    rm: {
+      aliases: ["remove", "delete"],
+      summary: "Delete secrets by name; whatever references them stops resolving",
+      usage: "easybits secrets rm <NAME>... [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits secrets rm GITHUB_TOKEN", "easybits secrets rm OLD_A OLD_B --yes --json"],
+      async run(ctx) {
+        if (!ctx.args.length) throw usageError(t("Missing <NAME>.", "Falta <NAME>."), this.usage);
+        requireYesIfHeadless(ctx);
+        await confirm(ctx, t(`Delete ${ctx.args.join(", ")} from your vault? The value cannot be recovered.`, `\xBFBorrar ${ctx.args.join(", ")} de tu b\xF3veda? El valor no se puede recuperar.`));
+        const deleted = [];
+        for (const name of ctx.args) {
+          await api(ctx, "DELETE", `/secrets/${encodeURIComponent(name)}`);
+          deleted.push(name);
+        }
+        emit(ctx, { deleted }, () => console.log(t(`Deleted ${deleted.join(", ")}`, `Borrado ${deleted.join(", ")}`)));
+      }
+    }
+  },
+  defaultSub: "ls"
+};
+
+// src/commands/documents.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync18, statSync as statSync11, writeFileSync as writeFileSync10 } from "fs";
+import { join as join11 } from "path";
+import { EasybitsError as EasybitsError5, resolveBaseUrl as resolveBaseUrl8 } from "@easybits.cloud/sdk";
+
+// src/progress.ts
+import { writeFileSync as writeFileSync9 } from "fs";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function progress(ctx, label) {
+  const started = Date.now();
+  const secs = () => Math.round((Date.now() - started) / 1e3);
+  if (ctx.json) return { update() {
+  }, stop() {
+  } };
+  if (!interactive(ctx)) {
+    let last = "";
+    const line2 = (l) => {
+      if (l !== last) process.stderr.write(`${l}
+`);
+      last = l;
+    };
+    line2(label);
+    return { update: line2, stop: (final) => final && process.stderr.write(`${final}
+`) };
+  }
+  let i = 0;
+  let current2 = label;
+  const draw = () => process.stderr.write(`\r\x1B[2K${FRAMES[i++ % FRAMES.length]} ${current2} (${secs()}s)`);
+  draw();
+  const timer = setInterval(draw, 100);
+  return {
+    update(l) {
+      current2 = l;
+    },
+    stop(final) {
+      clearInterval(timer);
+      process.stderr.write(`\r\x1B[2K${final ? `${final}
+` : ""}`);
+    }
+  };
+}
+async function withProgress(ctx, label, work) {
+  const p = progress(ctx, label);
+  try {
+    return await work(p);
+  } finally {
+    p.stop();
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function download(url, out, headers = {}) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) throw new CliError(t(`Download failed (${res.status}): ${url}`, `Fall\xF3 la descarga (${res.status}): ${url}`), EXIT.API);
+  const buf = Buffer.from(await res.arrayBuffer());
+  writeFileSync9(out, buf);
+  return buf.length;
+}
+
+// src/commands/documents.ts
+var DOC_PRESETS = {
+  "ig-square": { width: 1080, height: 1080 },
+  "fb-square": { width: 1080, height: 1080 },
+  "ig-feed": { width: 1080, height: 1350 },
+  "li-feed": { width: 1080, height: 1350 },
+  "ig-story": { width: 1080, height: 1920 },
+  "wsp-status": { width: 1080, height: 1920 },
+  tiktok: { width: 1080, height: 1920 },
+  "slide-16-9": { width: 1920, height: 1080 },
+  letter: null,
+  "1080x1080": { width: 1080, height: 1080 },
+  "1080x1350": { width: 1080, height: 1350 }
+};
+function parseSize(s) {
+  const m = /^(\d{2,5})x(\d{2,5})$/i.exec(s.trim());
+  return m ? { width: Number(m[1]), height: Number(m[2]) } : null;
+}
+function docFormat(input, usage2) {
+  if (!input) return { dims: null };
+  if (input in DOC_PRESETS) return { body: { preset: input }, dims: DOC_PRESETS[input] };
+  const size = parseSize(input);
+  if (!size) {
+    throw usageError(
+      t(`Unknown --format "${input}". One of: ${Object.keys(DOC_PRESETS).join(", ")}, or WxH in px.`, `--format desconocido "${input}". Uno de: ${Object.keys(DOC_PRESETS).join(", ")}, o WxH en px.`),
+      usage2
+    );
+  }
+  if ([size.width, size.height].some((n) => n < 100 || n > 1e4)) {
+    throw usageError(t("--format WxH goes from 100 to 10000 px per side.", "--format WxH va de 100 a 10000 px por lado."), usage2);
+  }
+  return { body: size, dims: size };
+}
+function blankPageHtml(dims) {
+  if (!dims) return void 0;
+  return `<section class="w-[${dims.width}px] h-[${dims.height}px] flex flex-col relative overflow-hidden bg-surface"></section>`;
+}
+var pagesOf = (doc) => [...doc.sections ?? []].sort((a, b) => a.order - b.order);
+function pageRef(pages, ref, usage2) {
+  const byId = pages.find((p) => p.id === ref);
+  if (byId) return byId;
+  if (/^\d+$/.test(ref)) {
+    const n = Number(ref);
+    if (n >= 1 && n <= pages.length) return pages[n - 1];
+  }
+  throw usageError(
+    t(`No page "${ref}" in this document (${pages.length} pages: use 1-${pages.length} or a page id).`, `No hay p\xE1gina "${ref}" en este documento (${pages.length} p\xE1ginas: usa 1-${pages.length} o el id de la p\xE1gina).`),
+    usage2
+  );
+}
+function reorderIds(pages, refs, usage2) {
+  const ids = refs.map((r) => pageRef(pages, r, usage2).id);
+  if (ids.length !== pages.length || new Set(ids).size !== ids.length) {
+    throw usageError(t(`Give every page exactly once (${pages.length} pages).`, `Pasa cada p\xE1gina exactamente una vez (${pages.length} p\xE1ginas).`), usage2);
+  }
+  return ids;
+}
+function pageRows(pages) {
+  return pages.map((p, i) => ({ n: i + 1, id: p.id, label: p.label || p.name || "-", bytes: (p.html ?? "").length }));
+}
+var sized = (rows) => rows.map((r) => ({ ...r, size: fmtBytes(r.bytes) }));
+var safeName = (s) => s.replace(/[^\w\-. ]+/g, "_").trim().slice(0, 80) || "document";
+function readHtml(path, usage2) {
+  if (path === "-") {
+    if (process.stdin.isTTY) throw usageError(t("Expected the HTML on stdin.", "Se esperaba el HTML por stdin."), usage2);
+    return readStdin().then((b) => b.toString("utf8"));
+  }
+  if (!existsSync16(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
+  return readFileSync18(path, "utf8");
+}
+var getDoc = (ctx, id) => api(ctx, "GET", `/documents/${encodeURIComponent(id)}`);
+var docPath = (id) => `/documents/${encodeURIComponent(id)}`;
+async function editorUrl(id) {
+  return `${(await resolveBaseUrl8()).replace(/\/$/, "")}/dash/documents/${id}`;
+}
+async function getBytes(ctx, path) {
+  const token = await resolveCredential(ctx);
+  const base = (await resolveBaseUrl8()).replace(/\/$/, "");
+  const res = await fetch(`${base}/api/v2${path}`, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) throw new EasybitsError5(res.status, await res.text());
+  return Buffer.from(await res.arrayBuffer());
+}
+var PAGES_USAGE = "easybits documents pages <ls|get|set> <document> [<page>] [<file.html|->] [--out FILE]";
+var EXPORT_USAGE = "easybits documents export <pdf|png> <document> [--out PATH] [--pages 1,3]";
+var documents = {
+  name: "documents",
+  aliases: ["document", "doc"],
+  group: "Content",
+  summary: "Documents (/dash/documents): pages of HTML you write, published and exported to PDF/PNG",
+  synopsis: "documents <ls|get|create|\u2026>",
+  subs: {
+    ls: {
+      aliases: ["list"],
+      summary: "List your documents, newest first",
+      usage: "easybits documents ls [--search TEXT] [--limit N]",
+      options: {
+        search: { type: "string", value: "text", description: "Only documents whose name contains this" },
+        limit: { type: "string", value: "n", description: "How many (default 20, max 100)" }
+      },
+      examples: ["easybits documents ls", "easybits documents ls --search cotizaci\xF3n --json"],
+      async run(ctx) {
+        const q = new URLSearchParams();
+        const search = str(ctx, "search");
+        const limit = str(ctx, "limit");
+        if (search) q.set("search", search);
+        if (limit) q.set("limit", limit);
+        const r = await api(ctx, "GET", `/documents${q.size ? `?${q}` : ""}`);
+        emit(ctx, r, () => {
+          table(
+            r.items.map((d) => ({ ...d, url: d.shareUrl ?? t("(not published)", "(sin publicar)"), updatedAt: fmtDate(d.updatedAt) })),
+            [["id", "ID"], ["name", "NAME"], ["pageCount", "PAGES"], ["updatedAt", "MODIFIED"], ["url", "URL"]],
+            t('No documents yet. Create one: easybits documents create --name "\u2026" --html page.html', 'Todav\xEDa no hay documentos. Crea uno: easybits documents create --name "\u2026" --html pagina.html')
+          );
+          if (r.total > r.items.length) console.log(t(`(${r.items.length} of ${r.total}; --limit up to 100 or --search)`, `(${r.items.length} de ${r.total}; --limit hasta 100 o --search)`));
+        });
+      }
+    },
+    get: {
+      summary: "Show one document: format, URL and its pages",
+      usage: "easybits documents get <document>",
+      examples: ["easybits documents get 'Cotizaci\xF3n ACME'", "easybits documents get 6650f0c2a1b2c3d4e5f60718 --json"],
+      async run(ctx) {
+        const id = need(ctx, 0, "document", this.usage);
+        const doc = await getDoc(ctx, id);
+        emit(ctx, doc, () => {
+          const f = doc.metadata?.format;
+          console.log(`${doc.name}  (${doc.id})`);
+          console.log(`${t("Format", "Formato")}: ${f ? `${f.width}\xD7${f.height}px` : t("letter", "carta")}   ${t("Theme", "Tema")}: ${doc.metadata?.theme || doc.theme}`);
+          console.log(`URL: ${doc.shareUrl ?? t("(not published: easybits documents deploy)", "(sin publicar: easybits documents deploy)")}`);
+          if (doc.pdfUrl) console.log(`PDF: ${doc.pdfUrl}`);
+          console.log("");
+          table(sized(pageRows(pagesOf(doc))), [["n", "#"], ["id", "ID"], ["label", "NAME"], ["size", "SIZE"]], t("No pages.", "Sin p\xE1ginas."));
+        });
+      }
+    },
+    create: {
+      aliases: ["new"],
+      summary: "Create a document from HTML files (one page each) or a blank page",
+      usage: "easybits documents create --name <name> [--html <file>\u2026] [--format <preset|WxH>] [--theme <theme>] [--brand-kit <id>]",
+      options: {
+        name: { type: "string", value: "name", description: "Document name" },
+        html: { type: "string", multiple: true, value: "file", description: "A page's HTML, in order (repeatable; - reads stdin). Without it: one blank page" },
+        format: { type: "string", value: "preset|WxH", description: "letter (default), ig-feed, ig-square, ig-story, li-feed, slide-16-9, tiktok\u2026 or WxH in px" },
+        theme: { type: "string", value: "theme", description: "Theme name (default: your brand kit or default)" },
+        "brand-kit": { type: "string", value: "id", description: "Brand kit to apply (default: your default kit)" }
+      },
+      examples: [
+        'easybits documents create --name "Cotizaci\xF3n ACME" --html portada.html --html precios.html',
+        'easybits documents create --name "Carrusel" --format ig-feed --json   # one blank 1080x1350 page'
+      ],
+      async run(ctx) {
+        const name = str(ctx, "name");
+        if (!name?.trim()) throw usageError(t("Missing --name.", "Falta --name."), this.usage);
+        const { body: format, dims } = docFormat(str(ctx, "format"), this.usage);
+        const pagesHtml = [];
+        for (const f of list(ctx, "html")) pagesHtml.push(await readHtml(f, this.usage));
+        const body = { name };
+        if (format) body.format = format;
+        const theme = str(ctx, "theme");
+        const kit = str(ctx, "brand-kit");
+        if (theme) body.theme = theme;
+        if (kit) body.brandKitId = kit;
+        const { document: doc } = await api(ctx, "POST", "/documents", body);
+        const htmls = pagesHtml.length ? pagesHtml : [blankPageHtml(dims)];
+        const pages = [];
+        for (const html of htmls) pages.push(await api(ctx, "POST", `${docPath(doc.id)}/pages`, html ? { html } : {}));
+        const out = { id: doc.id, name: doc.name, format: dims, pages: pages.map((p) => ({ id: p.id, label: p.label })), editorUrl: await editorUrl(doc.id) };
+        emit(ctx, out, () => {
+          console.log(t(`Created ${doc.name} (${doc.id}) with ${pages.length} page(s).`, `Creado ${doc.name} (${doc.id}) con ${pages.length} p\xE1gina(s).`));
+          console.log(`${t("Editor", "Editor")}: ${out.editorUrl}`);
+          console.log(t(`Next: easybits documents pages set ${doc.id} 1 page.html  \xB7  easybits documents deploy ${doc.id}`, `Sigue: easybits documents pages set ${doc.id} 1 pagina.html  \xB7  easybits documents deploy ${doc.id}`));
+        });
+      }
+    },
+    pages: {
+      summary: "List pages, print one page's HTML, or replace it with a file",
+      usage: PAGES_USAGE,
+      options: {
+        out: { type: "string", value: "file", description: "get: write the HTML to this file instead of stdout" }
+      },
+      examples: [
+        "easybits documents pages ls 'Cotizaci\xF3n ACME'",
+        "easybits documents pages get 'Cotizaci\xF3n ACME' 2 --out precios.html",
+        "easybits documents pages set 'Cotizaci\xF3n ACME' 2 precios.html",
+        "cat page.html | easybits documents pages set 'Cotizaci\xF3n ACME' 1 -"
+      ],
+      async run(ctx) {
+        const action = need(ctx, 0, "ls|get|set", PAGES_USAGE);
+        const id = need(ctx, 1, "document", PAGES_USAGE);
+        if (!["ls", "get", "set"].includes(action)) throw usageError(t(`Unknown pages action "${action}".`, `Acci\xF3n de pages desconocida "${action}".`), PAGES_USAGE);
+        const doc = await getDoc(ctx, id);
+        const pages = pagesOf(doc);
+        if (action === "ls") {
+          const rows = pageRows(pages);
+          emit(ctx, rows, () => table(sized(rows), [["n", "#"], ["id", "ID"], ["label", "NAME"], ["size", "SIZE"]], t("No pages.", "Sin p\xE1ginas.")));
+          return;
+        }
+        const page = pageRef(pages, need(ctx, 2, "page", PAGES_USAGE), PAGES_USAGE);
+        if (action === "get") {
+          const p = await api(ctx, "GET", `${docPath(id)}/pages/${encodeURIComponent(page.id)}`);
+          const out = str(ctx, "out");
+          if (out) {
+            writeFileSync10(out, p.html ?? "");
+            emit(ctx, { id: p.id, out, bytes: (p.html ?? "").length }, () => console.log(t(`Wrote ${fmtBytes((p.html ?? "").length)} to ${out}`, `Escrib\xED ${fmtBytes((p.html ?? "").length)} en ${out}`)));
+          } else emit(ctx, p, () => process.stdout.write((p.html ?? "") + "\n"));
+          return;
+        }
+        const html = await readHtml(need(ctx, 3, "file.html|-", PAGES_USAGE), PAGES_USAGE);
+        const r = await api(ctx, "PATCH", `${docPath(id)}/pages/${encodeURIComponent(page.id)}`, { html });
+        emit(
+          ctx,
+          r,
+          () => console.log(r.noop ? t("No change: the page already had that HTML.", "Sin cambios: la p\xE1gina ya ten\xEDa ese HTML.") : t(`Page ${pages.indexOf(page) + 1} updated (${page.id}).`, `P\xE1gina ${pages.indexOf(page) + 1} actualizada (${page.id}).`))
+        );
+      }
+    },
+    "add-page": {
+      summary: "Add a page from an HTML file (blank without one)",
+      usage: "easybits documents add-page <document> [<file.html|->] [--after N] [--label NAME]",
+      options: {
+        after: { type: "string", value: "n", description: "Insert after page N (0 = first; default: at the end)" },
+        label: { type: "string", value: "name", description: "Page name in the editor" }
+      },
+      examples: ["easybits documents add-page 'Cotizaci\xF3n ACME' anexo.html", "easybits documents add-page 'Cotizaci\xF3n ACME' portada.html --after 0 --label Portada"],
+      async run(ctx) {
+        const id = need(ctx, 0, "document", this.usage);
+        const file = ctx.args[1];
+        const body = {};
+        if (file) body.html = await readHtml(file, this.usage);
+        const after = str(ctx, "after");
+        if (after != null) {
+          if (!/^\d+$/.test(after)) throw usageError(t("--after must be a page number (0 = first).", "--after debe ser un n\xFAmero de p\xE1gina (0 = al inicio)."), this.usage);
+          body.afterPageIndex = Number(after) - 1;
+        }
+        const label = str(ctx, "label");
+        if (label) body.label = label;
+        if (!file) {
+          const doc = await getDoc(ctx, id);
+          const html = blankPageHtml(doc.metadata?.format ?? null);
+          if (html) body.html = html;
+        }
+        const p = await api(ctx, "POST", `${docPath(id)}/pages`, body);
+        emit(ctx, p, () => console.log(t(`Added page ${p.label ?? ""} (${p.id}).`, `Agregu\xE9 la p\xE1gina ${p.label ?? ""} (${p.id}).`)));
+      }
+    },
+    "rm-page": {
+      summary: "Delete one page (a document keeps at least one)",
+      usage: "easybits documents rm-page <document> <page> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits documents rm-page 'Cotizaci\xF3n ACME' 3 --yes"],
+      async run(ctx) {
+        const id = need(ctx, 0, "document", this.usage);
+        const ref = need(ctx, 1, "page", this.usage);
+        requireYesIfHeadless(ctx);
+        const pages = pagesOf(await getDoc(ctx, id));
+        const page = pageRef(pages, ref, this.usage);
+        await confirm(ctx, t(`Delete page ${pages.indexOf(page) + 1} (${page.label || page.id})?`, `\xBFBorrar la p\xE1gina ${pages.indexOf(page) + 1} (${page.label || page.id})?`));
+        const r = await api(ctx, "DELETE", `${docPath(id)}/pages/${encodeURIComponent(page.id)}`);
+        emit(ctx, r, () => console.log(t(`Deleted. ${r.remainingPages} page(s) left.`, `Borrada. Quedan ${r.remainingPages} p\xE1gina(s).`)));
+      }
+    },
+    reorder: {
+      summary: "Put the pages in a new order (every page, by number or id)",
+      usage: "easybits documents reorder <document> <page>\u2026",
+      examples: ["easybits documents reorder 'Cotizaci\xF3n ACME' 1 3 2   # swap pages 2 and 3"],
+      async run(ctx) {
+        const id = need(ctx, 0, "document", this.usage);
+        if (ctx.args.length < 2) throw usageError(t("Give the new order: every page by number or id.", "Pasa el orden nuevo: cada p\xE1gina por n\xFAmero o id."), this.usage);
+        const pageIds = reorderIds(pagesOf(await getDoc(ctx, id)), ctx.args.slice(1), this.usage);
+        const r = await api(ctx, "PUT", `${docPath(id)}/pages/reorder`, { pageIds });
+        emit(ctx, r, () => table(r.map((p) => ({ n: p.order + 1, id: p.id, label: p.label ?? "-" })), [["n", "#"], ["id", "ID"], ["label", "NAME"]]));
+      }
+    },
+    deploy: {
+      aliases: ["publish"],
+      summary: "Publish (or republish) the document at its public URL",
+      usage: "easybits documents deploy <document>",
+      examples: ["easybits documents deploy 'Cotizaci\xF3n ACME'"],
+      async run(ctx) {
+        const id = need(ctx, 0, "document", this.usage);
+        const r = await withProgress(
+          ctx,
+          t("Publishing\u2026", "Publicando\u2026"),
+          () => api(ctx, "POST", `${docPath(id)}/deploy`)
+        );
+        emit(ctx, r, () => {
+          console.log(`URL: ${r.customUrl ?? r.url}`);
+          if (r.pdfUrl) console.log(`PDF: ${r.pdfUrl}`);
+        });
+      }
+    },
+    export: {
+      summary: "Render to a PDF file or to one PNG per page (rendered on the server)",
+      usage: EXPORT_USAGE,
+      options: {
+        out: { type: "string", value: "path", description: "pdf: the file (default <name>.pdf); png: the folder (default .)" },
+        pages: { type: "string", value: "1,3", description: "Only these pages (numbers or ids, comma-separated)" }
+      },
+      examples: [
+        "easybits documents export pdf 'Cotizaci\xF3n ACME' --out cotizacion.pdf",
+        "easybits documents export png Carrusel --out ./slides   # one PNG per page at its exact size"
+      ],
+      async run(ctx) {
+        const kind = need(ctx, 0, "pdf|png", EXPORT_USAGE);
+        if (kind !== "pdf" && kind !== "png") throw usageError(t(`Export as pdf or png, not "${kind}".`, `Exporta como pdf o png, no "${kind}".`), EXPORT_USAGE);
+        const id = need(ctx, 1, "document", EXPORT_USAGE);
+        const doc = await getDoc(ctx, id);
+        const pages = pagesOf(doc);
+        const only = str(ctx, "pages");
+        const ids = only ? only.split(",").map((r) => pageRef(pages, r.trim(), EXPORT_USAGE).id) : [];
+        const qs = ids.length ? `?sections=${ids.map(encodeURIComponent).join(",")}` : "";
+        const out = str(ctx, "out");
+        if (kind === "pdf") {
+          const file = out ?? `${safeName(doc.name)}.pdf`;
+          const pdf = await withProgress(ctx, t("Rendering the PDF\u2026", "Renderizando el PDF\u2026"), () => getBytes(ctx, `${docPath(id)}/pdf${qs}`));
+          writeFileSync10(file, pdf);
+          emit(ctx, { file, bytes: pdf.length }, () => console.log(t(`Wrote ${fmtBytes(pdf.length)} to ${file}`, `Escrib\xED ${fmtBytes(pdf.length)} en ${file}`)));
+          return;
+        }
+        const dir = out ?? ".";
+        if (existsSync16(dir) && !statSync11(dir).isDirectory()) throw usageError(t(`--out for png is a folder; ${dir} is a file.`, `--out para png es una carpeta; ${dir} es un archivo.`), EXPORT_USAGE);
+        mkdirSync7(dir, { recursive: true });
+        const files3 = await withProgress(ctx, t(`Rendering ${ids.length || pages.length} page(s)\u2026`, `Renderizando ${ids.length || pages.length} p\xE1gina(s)\u2026`), async (p) => {
+          const r = await api(ctx, "GET", `${docPath(id)}/images${qs}`);
+          const saved = [];
+          for (const [i, f] of r.files.entries()) {
+            p.update(t(`Downloading ${i + 1}/${r.files.length}\u2026`, `Bajando ${i + 1}/${r.files.length}\u2026`));
+            const page = pages.findIndex((x) => x.id === f.sectionId) + 1 || i + 1;
+            const file = join11(dir, `${safeName(doc.name)}-${String(page).padStart(2, "0")}.png`);
+            saved.push({ page, file, url: f.url, fileId: f.id, bytes: await download(f.url, file) });
+          }
+          return saved;
+        });
+        emit(ctx, { files: files3 }, () => {
+          for (const f of files3) console.log(`${f.file}  ${fmtBytes(f.bytes)}`);
+        });
+      }
+    },
+    rm: {
+      aliases: ["delete"],
+      summary: "Delete a document (irreversible)",
+      usage: "easybits documents rm <document> [--yes]",
+      options: { ...YES_OPTION },
+      examples: ["easybits documents rm 'Borrador viejo' --yes"],
+      async run(ctx) {
+        const id = need(ctx, 0, "document", this.usage);
+        requireYesIfHeadless(ctx);
+        const doc = await getDoc(ctx, id);
+        await confirm(ctx, t(`Delete the document "${doc.name}" (${pagesOf(doc).length} pages)? This cannot be undone.`, `\xBFBorrar el documento "${doc.name}" (${pagesOf(doc).length} p\xE1ginas)? No se puede deshacer.`));
+        const r = await api(ctx, "DELETE", docPath(id));
+        emit(ctx, { ...r, id }, () => console.log(t(`Deleted ${doc.name}.`, `Borr\xE9 ${doc.name}.`)));
+      }
+    }
+  }
+};
+
+// src/commands/video.ts
+import { existsSync as existsSync17, readFileSync as readFileSync19 } from "fs";
+import { EasybitsError as EasybitsError6, resolveBaseUrl as resolveBaseUrl9 } from "@easybits.cloud/sdk";
+var VIDEO_PRESETS = {
+  portrait: [1080, 1920],
+  story: [1080, 1920],
+  reel: [1080, 1920],
+  tiktok: [1080, 1920],
+  square: [1080, 1080],
+  landscape: [1920, 1080],
+  "16-9": [1920, 1080],
+  youtube: [1920, 1080]
+};
+var VIDEO_THEMES = ["default", "dark", "light", "brand"];
+var VOICES = ["em_santa", "em_alex", "ef_dora"];
+function projectBody(o, usage2) {
+  const body = {};
+  if (o.name) body.name = o.name;
+  if (o.format) {
+    if (o.format in VIDEO_PRESETS) body.format = { preset: o.format };
+    else {
+      const m = /^(\d{3,4})x(\d{3,4})$/i.exec(o.format);
+      if (!m || [m[1], m[2]].some((n) => Number(n) < 100 || Number(n) > 4096)) {
+        throw usageError(t(`Unknown --format "${o.format}". One of: ${Object.keys(VIDEO_PRESETS).join(", ")}, or WxH (100-4096 px).`, `--format desconocido "${o.format}". Uno de: ${Object.keys(VIDEO_PRESETS).join(", ")}, o WxH (100-4096 px).`), usage2);
+      }
+      body.width = Number(m[1]);
+      body.height = Number(m[2]);
+    }
+  }
+  if (o.fps != null) {
+    const n = Number(o.fps);
+    if (!Number.isInteger(n) || n < 1 || n > 60) throw usageError(t("--fps goes from 1 to 60.", "--fps va de 1 a 60."), usage2);
+    body.fps = n;
+  }
+  if (o.theme) {
+    if (!VIDEO_THEMES.includes(o.theme)) throw usageError(t(`--theme is one of: ${VIDEO_THEMES.join(", ")}.`, `--theme es uno de: ${VIDEO_THEMES.join(", ")}.`), usage2);
+    body.theme = o.theme;
+  }
+  return body;
+}
+var scenesOf = (p) => [...p.scenes ?? []].sort((a, b) => a.order - b.order);
+function sceneRef(scenes, ref, usage2) {
+  const byId = scenes.find((s) => s.id === ref);
+  if (byId) return byId;
+  if (/^\d+$/.test(ref)) {
+    const n = Number(ref);
+    if (n >= 1 && n <= scenes.length) return scenes[n - 1];
+  }
+  throw usageError(
+    t(`No scene "${ref}" in this project (${scenes.length} scenes: use 1-${scenes.length} or a scene id).`, `No hay escena "${ref}" en este proyecto (${scenes.length} escenas: usa 1-${scenes.length} o el id de la escena).`),
+    usage2
+  );
+}
+function sceneRows(scenes) {
+  return scenes.map((s, i) => ({ n: i + 1, id: s.id, label: s.label ?? "-", durationSec: s.durationSec, narration: s.narration ? s.narration.slice(0, 40) : "-" }));
+}
+function sceneBody(o, usage2, readFile = (p) => existsSync17(p) ? readFileSync19(p, "utf8") : null) {
+  const body = {};
+  if (o.timeline != null) body.timeline = readFile(o.timeline) ?? o.timeline;
+  if (o.duration != null) {
+    const n = Number(o.duration);
+    if (!Number.isFinite(n) || n < 0.3 || n > 120) throw usageError(t("--duration goes from 0.3 to 120 seconds.", "--duration va de 0.3 a 120 segundos."), usage2);
+    body.durationSec = n;
+  }
+  if (o.label != null) body.label = o.label;
+  if (o.narration != null) body.narration = o.narration;
+  if (o.voice != null) {
+    if (!VOICES.includes(o.voice)) throw usageError(t(`--voice is one of: ${VOICES.join(", ")}.`, `--voice es una de: ${VOICES.join(", ")}.`), usage2);
+    body.narrationVoice = o.voice;
+  }
+  return body;
+}
+function renderErrorIsFinal(e) {
+  if (!(e instanceof EasybitsError6)) return false;
+  if (e.status < 500) return true;
+  try {
+    return typeof JSON.parse(e.body)?.error === "string";
+  } catch {
+    return false;
+  }
+}
+var SIZE = (p) => `${p.width}x${p.height}`;
+var projectPath = (id) => `/video-projects/${encodeURIComponent(id)}`;
+var getProject = (ctx, id) => api(ctx, "GET", projectPath(id));
+function readHtml2(path, usage2) {
+  if (path === "-") {
+    if (process.stdin.isTTY) throw usageError(t("Expected the HTML on stdin.", "Se esperaba el HTML por stdin."), usage2);
+    return readStdin().then((b) => b.toString("utf8"));
+  }
+  if (!existsSync17(path)) throw usageError(t(`File not found: ${path}`, `No existe el archivo: ${path}`), usage2);
+  return readFileSync19(path, "utf8");
+}
+async function postRender(ctx, id, signal) {
+  const token = await resolveCredential(ctx);
+  const base = (await resolveBaseUrl9()).replace(/\/$/, "");
+  const res = await fetch(`${base}/api/v2${projectPath(id)}/render`, { method: "POST", headers: { Authorization: `Bearer ${token}` }, signal });
+  const text = await res.text();
+  if (!res.ok) throw new EasybitsError6(res.status, text);
+  return JSON.parse(text);
+}
+var SCENE_FLAGS = {
+  timeline: { type: "string", value: "file|code", description: "GSAP against the paused timeline `tl`: a file, or the code itself" },
+  duration: { type: "string", value: "sec", description: "Seconds on screen (default: fits the narration, else 3)" },
+  label: { type: "string", value: "name", description: "Scene name" },
+  narration: { type: "string", value: "text", description: 'Voiceover text, synthesized at render time ("" removes it)' },
+  voice: { type: "string", value: "id", description: "Narration voice: em_santa (default), em_alex, ef_dora" }
+};
+var PROJECTS_USAGE = "easybits video projects <ls|get|create|rm> [<project>] [--name N] [--format F] [--fps N] [--theme T]";
+var SCENES_USAGE = "easybits video scenes <ls|add|set|rm|reorder> <project> [<scene>] [<file.html|->] [flags]";
+var MUSIC_USAGE = "easybits video music set <project> <url|none> [--name FILE]";
+var video = {
+  name: "video",
+  aliases: ["videos"],
+  group: "Content",
+  summary: "Video projects: HTML + GSAP scenes with narration and music, rendered to MP4",
+  synopsis: "video <projects|scenes|\u2026>",
+  subs: {
+    projects: {
+      summary: "List, show, create or delete video projects",
+      usage: PROJECTS_USAGE,
+      options: {
+        name: { type: "string", value: "name", description: "create: project name" },
+        format: { type: "string", value: "preset|WxH", description: "create: portrait (default 1080x1920), square, landscape, story, reel, tiktok, youtube, 16-9, or WxH" },
+        fps: { type: "string", value: "n", description: "create: frames per second (default 30)" },
+        theme: { type: "string", value: "theme", description: "create: background theme: default, dark, light, brand" },
+        ...YES_OPTION
+      },
+      examples: [
+        "easybits video projects ls",
+        'easybits video projects create --name "Promo oto\xF1o" --format square --json',
+        "easybits video projects get 'Promo oto\xF1o'   # scenes, music, last render",
+        "easybits video projects rm 'Promo oto\xF1o' --yes"
+      ],
+      async run(ctx) {
+        const action = need(ctx, 0, "ls|get|create|rm", PROJECTS_USAGE);
+        if (action === "ls" || action === "list") {
+          const r = await api(ctx, "GET", "/video-projects?limit=100");
+          emit(
+            ctx,
+            r,
+            () => table(
+              r.items.map((p2) => ({ ...p2, size: SIZE(p2), duration: `${p2.durationSec.toFixed(1)}s`, render: p2.lastRenderUrl ?? "-", updatedAt: fmtDate(p2.updatedAt) })),
+              [["id", "ID"], ["name", "NAME"], ["sceneCount", "SCENES"], ["duration", "DURATION"], ["size", "SIZE"], ["status", "STATUS"], ["render", "URL"]],
+              t('No video projects yet. Create one: easybits video projects create --name "\u2026"', 'Todav\xEDa no hay proyectos de video. Crea uno: easybits video projects create --name "\u2026"')
+            )
+          );
+          return;
+        }
+        if (action === "create" || action === "new") {
+          const body = projectBody({ name: str(ctx, "name"), format: str(ctx, "format"), fps: str(ctx, "fps"), theme: str(ctx, "theme") }, PROJECTS_USAGE);
+          const { project } = await api(ctx, "POST", "/video-projects", body);
+          emit(ctx, project, () => {
+            console.log(t(`Created ${project.name} (${project.id}) \u2014 ${SIZE(project)} @ ${project.fps} fps.`, `Creado ${project.name} (${project.id}) \u2014 ${SIZE(project)} a ${project.fps} fps.`));
+            console.log(t(`Next: easybits video scenes add ${project.id} scene.html --narration "\u2026"`, `Sigue: easybits video scenes add ${project.id} escena.html --narration "\u2026"`));
+          });
+          return;
+        }
+        if (action !== "get" && action !== "rm") throw usageError(t(`Unknown projects action "${action}".`, `Acci\xF3n de projects desconocida "${action}".`), PROJECTS_USAGE);
+        const id = need(ctx, 1, "project", PROJECTS_USAGE);
+        if (action === "rm") {
+          requireYesIfHeadless(ctx);
+          const p2 = await getProject(ctx, id);
+          await confirm(ctx, t(`Delete the video project "${p2.name}" (${p2.sceneCount} scenes)? Rendered MP4s stay in your files.`, `\xBFBorrar el proyecto de video "${p2.name}" (${p2.sceneCount} escenas)? Los MP4 renderizados se quedan en tus archivos.`));
+          const r = await api(ctx, "DELETE", projectPath(id));
+          emit(ctx, { ...r, id }, () => console.log(t(`Deleted ${p2.name}.`, `Borr\xE9 ${p2.name}.`)));
+          return;
+        }
+        const p = await getProject(ctx, id);
+        emit(ctx, p, () => {
+          console.log(`${p.name}  (${p.id})`);
+          console.log(`${SIZE(p)} @ ${p.fps} fps   ${t("Theme", "Tema")}: ${p.theme}   ${t("Status", "Estado")}: ${p.status}${p.failReason ? ` \u2014 ${p.failReason}` : ""}`);
+          console.log(`${t("Music", "M\xFAsica")}: ${p.audioAssetName ?? "-"}   ${t("Duration", "Duraci\xF3n")}: ${p.durationSec.toFixed(1)}s`);
+          if (p.lastRenderUrl) console.log(`MP4: ${p.lastRenderUrl}`);
+          console.log("");
+          table(sceneRows(scenesOf(p)), [["n", "#"], ["id", "ID"], ["label", "NAME"], ["durationSec", "DURATION"], ["narration", "NARRATION"]], t("No scenes yet.", "Todav\xEDa no hay escenas."));
+        });
+      }
+    },
+    scenes: {
+      summary: "List, add, edit, delete or reorder a project's scenes",
+      usage: SCENES_USAGE,
+      options: {
+        ...SCENE_FLAGS,
+        after: { type: "string", value: "n", description: "add: insert after scene N (0 = first; default: at the end)" },
+        ...YES_OPTION
+      },
+      examples: [
+        "easybits video scenes ls 'Promo oto\xF1o'",
+        `easybits video scenes add 'Promo oto\xF1o' intro.html --timeline intro.js --narration "Lleg\xF3 el oto\xF1o"`,
+        "easybits video scenes set 'Promo oto\xF1o' 2 --duration 4 --voice ef_dora",
+        "easybits video scenes set 'Promo oto\xF1o' 2 escena2.html   # replace its HTML",
+        "easybits video scenes reorder 'Promo oto\xF1o' 2 1 3",
+        "easybits video scenes rm 'Promo oto\xF1o' 3 --yes"
+      ],
+      async run(ctx) {
+        const action = need(ctx, 0, "ls|add|set|rm|reorder", SCENES_USAGE);
+        if (!["ls", "add", "set", "rm", "reorder"].includes(action)) throw usageError(t(`Unknown scenes action "${action}".`, `Acci\xF3n de scenes desconocida "${action}".`), SCENES_USAGE);
+        const id = need(ctx, 1, "project", SCENES_USAGE);
+        const flags = () => sceneBody({ timeline: str(ctx, "timeline"), duration: str(ctx, "duration"), label: str(ctx, "label"), narration: str(ctx, "narration"), voice: str(ctx, "voice") }, SCENES_USAGE);
+        if (action === "add") {
+          const body2 = { ...flags(), html: await readHtml2(need(ctx, 2, "file.html|-", SCENES_USAGE), SCENES_USAGE) };
+          const after = str(ctx, "after");
+          if (after != null) {
+            if (!/^\d+$/.test(after)) throw usageError(t("--after must be a scene number (0 = first).", "--after debe ser un n\xFAmero de escena (0 = al inicio)."), SCENES_USAGE);
+            body2.afterIndex = Number(after) - 1;
+          }
+          const r2 = await api(ctx, "POST", `${projectPath(id)}/scenes`, body2);
+          emit(ctx, r2, () => console.log(t(`Added ${r2.scene.label ?? r2.scene.id} (${r2.scene.durationSec}s). ${r2.sceneCount} scene(s).`, `Agregu\xE9 ${r2.scene.label ?? r2.scene.id} (${r2.scene.durationSec}s). ${r2.sceneCount} escena(s).`)));
+          return;
+        }
+        if (action === "rm") requireYesIfHeadless(ctx);
+        const scenes = scenesOf(await getProject(ctx, id));
+        if (action === "ls") {
+          const rows = sceneRows(scenes);
+          emit(ctx, rows, () => table(rows, [["n", "#"], ["id", "ID"], ["label", "NAME"], ["durationSec", "DURATION"], ["narration", "NARRATION"]], t("No scenes yet.", "Todav\xEDa no hay escenas.")));
+          return;
+        }
+        if (action === "reorder") {
+          const refs = ctx.args.slice(2);
+          const ids = refs.map((r3) => sceneRef(scenes, r3, SCENES_USAGE).id);
+          if (ids.length !== scenes.length || new Set(ids).size !== ids.length) {
+            throw usageError(t(`Give every scene exactly once (${scenes.length} scenes).`, `Pasa cada escena exactamente una vez (${scenes.length} escenas).`), SCENES_USAGE);
+          }
+          const r2 = await api(ctx, "PUT", `${projectPath(id)}/scenes`, { sceneIds: ids });
+          emit(ctx, r2, () => table(r2.scenes.map((s) => ({ n: s.order + 1, id: s.id, label: s.label ?? "-" })), [["n", "#"], ["id", "ID"], ["label", "NAME"]]));
+          return;
+        }
+        const scene = sceneRef(scenes, need(ctx, 2, "scene", SCENES_USAGE), SCENES_USAGE);
+        const n = scenes.indexOf(scene) + 1;
+        if (action === "rm") {
+          await confirm(ctx, t(`Delete scene ${n} (${scene.label ?? scene.id})?`, `\xBFBorrar la escena ${n} (${scene.label ?? scene.id})?`));
+          const r2 = await api(ctx, "DELETE", `${projectPath(id)}/scenes/${encodeURIComponent(scene.id)}`);
+          emit(ctx, r2, () => console.log(t(`Deleted. ${r2.sceneCount} scene(s) left.`, `Borrada. Quedan ${r2.sceneCount} escena(s).`)));
+          return;
+        }
+        const body = flags();
+        if (ctx.args[3]) body.html = await readHtml2(ctx.args[3], SCENES_USAGE);
+        if (Object.keys(body).length === 0) throw usageError(t("Nothing to change: pass a file.html and/or --timeline, --duration, --label, --narration, --voice.", "Nada que cambiar: pasa un archivo.html y/o --timeline, --duration, --label, --narration, --voice."), SCENES_USAGE);
+        const r = await api(ctx, "PATCH", `${projectPath(id)}/scenes/${encodeURIComponent(scene.id)}`, body);
+        emit(ctx, r, () => console.log(r.changed ? t(`Scene ${n} updated.`, `Escena ${n} actualizada.`) : t("No change: the scene already had that.", "Sin cambios: la escena ya ten\xEDa eso.")));
+      }
+    },
+    music: {
+      summary: "Set or remove the background music (a public audio URL)",
+      usage: MUSIC_USAGE,
+      options: { name: { type: "string", value: "file", description: "File name inside the bundle (default: from the URL)" } },
+      examples: [
+        "easybits video music set 'Promo oto\xF1o' https://cdn.example.com/bed.mp3",
+        "easybits video music set 'Promo oto\xF1o' none   # remove it"
+      ],
+      async run(ctx) {
+        const action = need(ctx, 0, "set", MUSIC_USAGE);
+        if (action !== "set") throw usageError(t(`Unknown music action "${action}".`, `Acci\xF3n de music desconocida "${action}".`), MUSIC_USAGE);
+        const id = need(ctx, 1, "project", MUSIC_USAGE);
+        const url = need(ctx, 2, "url|none", MUSIC_USAGE);
+        const clear = url === "none";
+        if (!clear && !/^https?:\/\//.test(url)) throw usageError(t("Give a public http(s) URL (upload a local file first: easybits files upload song.mp3 --public).", "Pasa una URL p\xFAblica http(s) (sube primero el archivo local: easybits files upload cancion.mp3 --public)."), MUSIC_USAGE);
+        const r = await api(ctx, "POST", `${projectPath(id)}/audio`, { url: clear ? null : url, name: str(ctx, "name") });
+        emit(ctx, r, () => console.log(r.audio ? t(`Music: ${r.audio.name}`, `M\xFAsica: ${r.audio.name}`) : t("Music removed.", "M\xFAsica quitada.")));
+      }
+    },
+    render: {
+      summary: "Render the project to MP4 on the server; --wait follows it to the end",
+      usage: "easybits video render <project> [--wait] [--out FILE.mp4] [--timeout MIN]",
+      options: {
+        wait: { type: "boolean", description: "Wait for the MP4 (spinner in a terminal); without it, start and return" },
+        out: { type: "string", value: "file", description: "With --wait: also download the MP4 here" },
+        timeout: { type: "string", value: "min", description: "With --wait: give up after this many minutes (default 15)" }
+      },
+      examples: [
+        "easybits video render 'Promo oto\xF1o' --wait --out promo.mp4",
+        "easybits video render 'Promo oto\xF1o'          # starts it; then:",
+        "easybits video projects get 'Promo oto\xF1o' --json   # status: rendering \u2192 ready | failed"
+      ],
+      async run(ctx) {
+        const id = need(ctx, 0, "project", this.usage);
+        const wait = bool(ctx, "wait");
+        const out = str(ctx, "out");
+        if (out && !wait) throw usageError(t("--out needs --wait.", "--out necesita --wait."), this.usage);
+        const minutes = Number(str(ctx, "timeout") ?? 15);
+        if (!Number.isFinite(minutes) || minutes <= 0) throw usageError(t("--timeout is minutes, > 0.", "--timeout son minutos, > 0."), this.usage);
+        const before = await getProject(ctx, id);
+        if (before.sceneCount === 0) throw usageError(t("The project has no scenes: easybits video scenes add \u2026", "El proyecto no tiene escenas: easybits video scenes add \u2026"), this.usage);
+        const p = progress(ctx, t(`Rendering ${before.name} (${before.durationSec.toFixed(1)}s of video)\u2026`, `Renderizando ${before.name} (${before.durationSec.toFixed(1)}s de video)\u2026`));
+        const ctrl = new AbortController();
+        let post = null;
+        let postDone = false;
+        let postResult = null;
+        let postError = null;
+        if (before.status !== "rendering") {
+          post = postRender(ctx, id, ctrl.signal).then(
+            (r) => (postDone = true, postResult = r),
+            (e) => (postDone = true, postError = e)
+          );
+        }
+        try {
+          if (!wait) {
+            for (let i = 0; i < 30 && !postDone; i++) {
+              if ((await getProject(ctx, id)).status === "rendering") break;
+              await sleep(1e3);
+            }
+            if (postError && renderErrorIsFinal(postError)) throw postError;
+            if (!postDone) ctrl.abort();
+            p.stop();
+            const state2 = postResult ? postResult : await getProject(ctx, id);
+            emit(ctx, state2, () => {
+              if (state2.status === "ready" && state2.lastRenderUrl) console.log(`MP4: ${state2.lastRenderUrl}`);
+              else console.log(t(`Rendering on the server. Follow it: easybits video render ${id} --wait`, `Renderizando en el servidor. S\xEDguelo: easybits video render ${id} --wait`));
+            });
+            return;
+          }
+          if (post) await post;
+          if (postError && renderErrorIsFinal(postError)) throw postError;
+          let final = null;
+          const deadline = Date.now() + minutes * 6e4;
+          while (!postResult) {
+            final = await getProject(ctx, id);
+            if (final.status !== "rendering") break;
+            if (Date.now() > deadline) throw new CliError(t(`Still rendering after ${minutes} min.`, `Sigue renderizando despu\xE9s de ${minutes} min.`), EXIT.API, t(`Check later: easybits video projects get ${id}`, `Revisa luego: easybits video projects get ${id}`));
+            p.update(t(`Rendering ${before.name}\u2026 (status: ${final.status})`, `Renderizando ${before.name}\u2026 (estado: ${final.status})`));
+            await sleep(3e3);
+          }
+          const state = postResult ?? final;
+          if (state.status === "failed" || !state.lastRenderUrl) {
+            const reason = state.failReason ?? (await getProject(ctx, id)).failReason;
+            throw new CliError(t(`Render failed: ${reason ?? "unknown"}`, `Fall\xF3 el render: ${reason ?? "desconocido"}`), EXIT.API);
+          }
+          let bytes;
+          if (out) {
+            p.update(t("Downloading the MP4\u2026", "Bajando el MP4\u2026"));
+            bytes = await download(state.lastRenderUrl, out);
+          }
+          p.stop();
+          emit(ctx, { ...state, ...out ? { out, bytes } : {} }, () => {
+            console.log(`MP4: ${state.lastRenderUrl}`);
+            if (out) console.log(t(`Saved to ${out}`, `Guardado en ${out}`));
+          });
+        } finally {
+          p.stop();
+        }
+      }
+    },
+    ls: {
+      aliases: ["list"],
+      summary: "List AI-generated videos (prompt \u2192 clip), newest first",
+      usage: "easybits video ls [--limit N]",
+      options: { limit: { type: "string", value: "n", description: "How many (default 50, max 100)" } },
+      examples: ["easybits video ls", "easybits video ls --limit 5 --json"],
+      async run(ctx) {
+        const limit = str(ctx, "limit");
+        const r = await api(ctx, "GET", `/videos${limit ? `?limit=${encodeURIComponent(limit)}` : ""}`);
+        emit(
+          ctx,
+          r.videos,
+          () => table(
+            r.videos.map((v) => ({ ...v, prompt: v.prompt.slice(0, 40), duration: `${v.duration}s`, createdAt: fmtDate(v.createdAt) })),
+            [["id", "ID"], ["prompt", "PROMPT"], ["status", "STATUS"], ["duration", "DURATION"], ["createdAt", "CREATED"]],
+            t("No generated videos yet.", "Todav\xEDa no hay videos generados.")
+          )
+        );
+      }
+    }
+  }
+};
+
+// src/commands/index.ts
+var COMMANDS = [
+  login,
+  logout,
+  whoami,
   doctor2,
   usage,
+  secrets,
   sandboxes,
   agents,
+  fleet,
   apply,
   machines,
+  sites,
   domains,
   init,
   db,
   files,
   websites,
+  documents,
+  video,
   providers,
+  webCmd,
+  webhooks,
+  keys,
   mcp,
   sshKey,
   sshProxy,
@@ -3892,7 +6294,7 @@ var HELP_ES = {
   "Last N lines (default 200)": "\xDAltimos N renglones (default 200)",
   'journalctl time spec, e.g. "10 min ago"': 'Tiempo en sintaxis de journalctl, p. ej. "10 min ago"',
   "Only lines matching": "S\xF3lo los renglones que coincidan",
-  "List, read or write files inside a sandbox": "Enlista, lee o escribe archivos dentro de un sandbox",
+  "List, read, write, delete, move files and make folders inside a sandbox": "Enlista, lee, escribe, borra y mueve archivos y crea carpetas dentro de un sandbox",
   "write: inline content instead of a local file": "write: contenido en l\xEDnea en vez de un archivo local",
   "read: save to a local file (binary-safe)": "read: guarda en un archivo local (seguro con binarios)",
   "Suspend to disk (frees CPU; TTL paused)": "Lo suspende a disco (libera CPU; el TTL se pausa)",
@@ -3965,6 +6367,8 @@ var HELP_ES = {
   "a copy": "una copia",
   "what would be removed": "lo que se quitar\xEDa",
   "Hosting": "Hosting",
+  "Your site-builder sites (/dash/sitios): static and web apps": "Tus sitios del creador (/dash/sitios): est\xE1ticos y web apps",
+  "List your sites with their kind, engine and public URL": "Enlista tus sitios con su tipo, motor y URL p\xFAblica",
   "Permanent machines and their releases (easybits deploy <machine> publishes)": "M\xE1quinas permanentes y sus releases (easybits deploy <m\xE1quina> publica)",
   "List your permanent machines": "Enlista tus m\xE1quinas permanentes",
   "Publish the machine's current app code as a new release": "Publica el c\xF3digo actual de la app como un release nuevo",
@@ -3993,15 +6397,54 @@ var HELP_ES = {
   "Last N lines": "\xDAltimos N renglones",
   "Put a previous release back on the same machine (data untouched)": "Vuelve a poner un release anterior en la misma m\xE1quina (datos intactos)",
   "App env vars stored encrypted in your vault": "Variables de entorno de la app, cifradas en tu vault",
-  "Custom domains with auto TLS on a sandbox or machine": "Dominios propios con TLS autom\xE1tico en un sandbox o m\xE1quina",
-  "List domains attached to a sandbox": "Enlista los dominios de un sandbox",
-  "Attach a domain to a port; prints the DNS record to create": "Liga un dominio a un puerto; imprime el registro DNS que hay que crear",
-  "Port inside the sandbox (required)": "Puerto dentro del sandbox (obligatorio)",
-  "Check DNS + HTTPS for a domain": "Revisa DNS + HTTPS de un dominio",
-  "Detach a domain": "Desliga un dominio",
+  "Your own domains for your websites (sandbox ports: sandboxes domains)": "Dominios propios para tus sitios (puertos de una caja: sandboxes domains)",
+  "List the custom domains of your account": "Enlista los dominios propios de tu cuenta",
+  "Register a domain; prints the DNS records to create": "Registra un dominio; imprime los registros DNS que hay que crear",
+  "Check the TXT record and issue the certificate": "Revisa el registro TXT y emite el certificado",
+  "Write the DNS records into your Mailmask zone and verify (--undo restores)": "Escribe los registros DNS en tu zona de Mailmask y verifica (--undo los restaura)",
+  "Restore the records EasyBits wrote (keeps the ones you changed)": "Restaura los registros que escribi\xF3 EasyBits (respeta los que cambiaste)",
+  "Serve one of your websites at the root domain and www (--clear removes it)": "Sirve uno de tus sitios en la ra\xEDz del dominio y en www (--clear lo quita)",
+  "Stop serving a website at the root": "Deja de servir un sitio en la ra\xEDz",
+  "Remove a domain: unlinks its websites and deletes its certificates": "Quita un dominio: desliga sus sitios y borra sus certificados",
+  "Custom domains with auto TLS on a sandbox or machine port": "Dominios propios con TLS autom\xE1tico en un puerto de un sandbox o m\xE1quina",
+  "add: port inside the sandbox (required)": "add: puerto dentro del sandbox (obligatorio)",
+  "Web": "Web",
+  "Search, read, extract and crawl the web (metered in web queries)": "Busca, lee, extrae y rastrea la web (se mide en consultas web)",
+  "Search Google, Bing, Yandex or DuckDuckGo (1 query)": "Busca en Google, Bing, Yandex o DuckDuckGo (1 consulta)",
+  "google (default), bing, yandex or duckduckgo": "google (default), bing, yandex o duckduckgo",
+  "ISO country for localized results (mx, us\u2026)": "Pa\xEDs ISO para resultados locales (mx, us\u2026)",
+  "Read a page even if it blocks bots: raw HTML or clean markdown (1 query)": "Lee una p\xE1gina aunque bloquee bots: HTML crudo o markdown limpio (1 consulta)",
+  "Clean markdown instead of raw HTML": "Markdown limpio en vez de HTML crudo",
+  "With --markdown: drop nav, footer and icons": "Con --markdown: quita men\xFA, pie e iconos",
+  "ISO country to fetch from (mx, us\u2026)": "Pa\xEDs ISO desde donde leer (mx, us\u2026)",
+  "Save the body to a file instead of stdout": "Guarda el contenido en un archivo en vez de stdout",
+  "Structured records from a known source (Google Maps, Mercado Libre\u2026); 1 query per record": "Registros estructurados de una fuente conocida (Google Maps, Mercado Libre\u2026); 1 consulta por registro",
+  'Input for the source: [{"keyword":"\u2026","country":"MX"}], {"query":"\u2026"} or [{"url":"\u2026"}]': 'Entrada seg\xFAn la fuente: [{"keyword":"\u2026","country":"MX"}], {"query":"\u2026"} o [{"url":"\u2026"}]',
+  "Shortcut for --input '[{\"url\":\u2026}]' (repeatable)": `Atajo de --input '[{"url":\u2026}]' (repetible)`,
+  "Max records per input (default 20, max 200)": "Registros m\xE1ximos por entrada (default 20, m\xE1x. 200)",
+  "Catalog dataset id, for sources not on the list (source becomes optional)": "Id de dataset del cat\xE1logo, para fuentes fuera de la lista (source se vuelve opcional)",
+  "Wait for the job to finish (polls every 15 s, up to 5 min)": "Espera a que termine el trabajo (revisa cada 15 s, hasta 5 min)",
+  "Check an extract job; when done, prints its records": "Revisa un trabajo de extract; si ya termin\xF3, imprime sus registros",
+  "Read a page and follow its internal links as markdown (1 query per page)": "Lee una p\xE1gina y sigue sus links internos, en markdown (1 consulta por p\xE1gina)",
+  "Pages to read, 1-20 (default 10)": "P\xE1ginas a leer, 1-20 (default 10)",
+  "Drop nav, footer and icons from each page (good for RAG)": "Quita men\xFA, pie e iconos de cada p\xE1gina (bueno para RAG)",
+  "Webhooks: HTTPS POSTs signed with HMAC when your files, websites or forms change": "Webhooks: POSTs HTTPS firmados con HMAC cuando cambian tus archivos, sitios o formularios",
+  "List your webhooks": "Enlista tus webhooks",
+  "Create a webhook; prints its signing secret ONCE": "Crea un webhook; imprime su secreto de firma UNA vez",
+  "Event to deliver (repeatable or comma-separated): file.created, website.deleted, form.submitted\u2026": "Evento a entregar (repetible o separado por comas): file.created, website.deleted, form.submitted\u2026",
+  "Change a webhook's URL or events, or pause/resume it": "Cambia la URL o los eventos de un webhook, o lo pausa/reanuda",
+  "New destination URL": "URL de destino nueva",
+  "Stop deliveries (status PAUSED)": "Detiene las entregas (estado PAUSED)",
+  "Deliver again and reset the failure count (status ACTIVE)": "Vuelve a entregar y reinicia el conteo de fallas (estado ACTIVE)",
+  "Delete a webhook": "Borra un webhook",
+  "API keys of your account: list, create, revoke": "API keys de tu cuenta: enlistar, crear, revocar",
+  "List your API keys (prefix only; the full key is never shown again)": "Enlista tus API keys (s\xF3lo el prefijo; la key completa no se vuelve a mostrar)",
+  "Create an API key; prints it ONCE": "Crea una API key; la imprime UNA vez",
+  "Comma-separated: READ, WRITE, DELETE, ADMIN (default READ,WRITE,DELETE; never more than your own credential has)": "Separados por comas: READ, WRITE, DELETE, ADMIN (default READ,WRITE,DELETE; nunca m\xE1s de los que tiene tu credencial)",
+  "Expiry date (ISO, e.g. 2027-01-31); default never": "Fecha de vencimiento (ISO, p. ej. 2027-01-31); default nunca",
+  "Revoke an API key (by id, name or prefix); anything using it stops working": "Revoca una API key (por id, nombre o prefijo); lo que la use deja de funcionar",
   "Write the GitHub Actions deploy workflow for this repo": "Escribe el workflow de GitHub Actions que despliega este repo",
   "Write the GitHub Actions workflow that deploys this repo on every push to main": "Escribe el workflow de GitHub Actions que despliega este repo en cada push a main",
-  "Where the app lives in the machine (default /srv/app)": "D\xF3nde vive la app en la m\xE1quina (default /srv/app)",
   "Port your app listens on (default 3000)": "Puerto en el que escucha tu app (default 3000)",
   "Data": "Datos",
   "SQL databases (libSQL)": "Bases de datos SQL (libSQL)",
@@ -4027,7 +6470,14 @@ var HELP_ES = {
   "Public file with an open CDN URL (default: private)": "Archivo p\xFAblico con URL abierta en el CDN (por defecto: privado)",
   "Delete a file (soft delete, 7-day trash)": "Borra un archivo (a la papelera 7 d\xEDas)",
   "List your static websites": "Enlista tus sitios est\xE1ticos",
-  "Static websites: list, create, change slug": "Sitios est\xE1ticos: enlistar, crear, cambiar slug",
+  "Static websites: list, create, upload, deploy a folder, delete": "Sitios est\xE1ticos: enlistar, crear, subir, publicar una carpeta, borrar",
+  "Show one website (by slug or id)": "Muestra un sitio (por slug o id)",
+  "List a website's files (paths inside the site)": "Enlista los archivos de un sitio (rutas dentro del sitio)",
+  "Upload one file to a website (public; replaces the same path)": "Sube un archivo a un sitio (p\xFAblico; reemplaza la misma ruta)",
+  "Path inside the site (default: the file name), e.g. img/hero.jpg": "Ruta dentro del sitio (default: el nombre del archivo), p. ej. img/hero.jpg",
+  "Upload a whole folder (e.g. your build) keeping its paths; same paths are replaced": "Sube una carpeta entera (p. ej. tu build) con sus rutas; las mismas rutas se reemplazan",
+  "List what would be uploaded; upload nothing": "Enlista lo que se subir\xEDa; no sube nada",
+  "Delete a website and its files (asks you to type the slug)": "Borra un sitio y sus archivos (pide teclear el slug)",
   "Create an empty static website (optionally with your own slug)": "Crea un sitio est\xE1tico vac\xEDo (con tu propio slug si quieres)",
   "Public slug: /s/<slug>/ (a-z, 0-9, hyphens, 3-60 chars)": "Slug p\xFAblico: /s/<slug>/ (a-z, 0-9, guiones, 3-60 caracteres)",
   "Change a website's slug (the old URL redirects 301 to the new one)": "Cambia el slug de un sitio (la URL vieja redirige 301 a la nueva)",
@@ -4057,7 +6507,147 @@ var HELP_ES = {
   "Column for the link (default: image_url, photo_url, imagen\u2026)": "Columna de la liga (default: image_url, photo_url, imagen\u2026)",
   "Also replace rows that already have a permanent link": "Reemplaza tambi\xE9n las filas que ya tienen liga permanente",
   "Show the plan; upload nothing": "Ense\xF1a el plan; no sube nada",
-  "how many links are permanent, external or empty": "cu\xE1ntas ligas son permanentes, de fuera o vac\xEDas"
+  "how many links are permanent, external or empty": "cu\xE1ntas ligas son permanentes, de fuera o vac\xEDas",
+  // sites create / theme
+  "Create a site from a prompt; its builder agent picks it up in the editor": "Crea un sitio a partir de un prompt; su agente lo sigue construyendo en el editor",
+  "What to build; also names the site if --name is missing": "Qu\xE9 construir; tambi\xE9n nombra el sitio si falta --name",
+  "Site name": "Nombre del sitio",
+  "webapp (default: its own machine, published later) or static (CDN website)": "webapp (default: su propia m\xE1quina, se publica despu\xE9s) o static (website en el CDN)",
+  "Web app stack: tanstack (default), next, react-router, remix, nuxt, sveltekit, astro, elysia": "Stack de la web app: tanstack (default), next, react-router, remix, nuxt, sveltekit, astro, elysia",
+  "Starting template (tanstack/react-router): consultorio, despacho, portafolio, lanzamiento": "Plantilla de partida (tanstack/react-router): consultorio, despacho, portafolio, lanzamiento",
+  "Read or change a site's color theme without a model turn (the \xABTema\xBB button)": "Lee o cambia el tema de colores de un sitio sin turno del modelo (el bot\xF3n \xABTema\xBB)",
+  "Palette id: minimal, calido, oceano, noche, dracula, nord, tokyo-night, github-light\u2026": "Id de la paleta: minimal, calido, oceano, noche, dracula, nord, tokyo-night, github-light\u2026",
+  "JSON with every token as #rrggbb (- reads stdin)": "JSON con cada token en #rrggbb (- lee stdin)",
+  "edit, then:": "ed\xEDtalo y luego:",
+  // machines get/restart/redeploy/backups/backup/runspec/rm/tiers
+  "Show a machine: tier, size, price, status and whether it sleeps": "Muestra una m\xE1quina: tier, tama\xF1o, precio, estado y si duerme",
+  "Restart the app's process with the current secrets and runspec (seconds, no build)": "Reinicia el proceso de la app con los secretos y el runspec actuales (segundos, sin build)",
+  "Build a NEW machine from a release: recover a lost one, or change its tier (resize)": "Construye una m\xE1quina NUEVA desde un release: recupera una perdida o cambia su tier (resize)",
+  "Release to build from (default: the machine's newest)": "Release de d\xF3nde construir (default: el m\xE1s nuevo de la m\xE1quina)",
+  "Size of the new machine (default: same as the release's)": "Tama\xF1o de la m\xE1quina nueva (default: el mismo del release)",
+  "Label for the new machine": "Nombre de la m\xE1quina nueva",
+  "shared (default) or reserved": "shared (default) o reserved",
+  "Release the old machine once the new one runs (otherwise you pay for both)": "Libera la m\xE1quina vieja cuando la nueva corra (si no, pagas las dos)",
+  "resize": "cambiar tama\xF1o",
+  "recover from a release": "recuperar desde un release",
+  "List the daily data backups, newest first (kept 7 days)": "Enlista los respaldos diarios de datos, el m\xE1s nuevo primero (se guardan 7 d\xEDas)",
+  "Take a data backup now instead of waiting for tonight's": "Toma un respaldo de datos ya, sin esperar al de la noche",
+  "How the app is built, started and backed up (set merges with what is there)": "C\xF3mo se construye, arranca y respalda la app (set se mezcla con lo que ya hay)",
+  "Runspec as JSON (- reads stdin); flags win over it": "Runspec en JSON (- lee stdin); las banderas ganan sobre \xE9l",
+  "Where the app lives in the machine": "D\xF3nde vive la app en la m\xE1quina",
+  "Build command": "Comando de build",
+  "Start command (used when there is no systemd unit)": "Comando de arranque (se usa cuando no hay unit de systemd)",
+  "systemd unit to restart (preferred over --start)": "Unit de systemd a reiniciar (preferida sobre --start)",
+  "Port the app listens on": "Puerto donde escucha la app",
+  "on: releases ship the build and a deploy only starts it": "on: los releases llevan el build y un deploy s\xF3lo lo arranca",
+  "Path kept out of the release (repeatable)": "Ruta que no entra al release (repetible)",
+  "Release a machine: stops billing, takes a last backup and destroys it": "Libera una m\xE1quina: deja de cobrarse, toma un \xFAltimo respaldo y la destruye",
+  "The hosting catalog: sizes and monthly prices in MXN": "El cat\xE1logo de hosting: tama\xF1os y precio mensual en MXN",
+  // secrets (vault de la cuenta)
+  "Your account's secrets vault: names only; used as $secret:NAME": "La b\xF3veda de secretos de tu cuenta: s\xF3lo nombres; se usan como $secret:NOMBRE",
+  "List the names in your vault (values never come back)": "Enlista los nombres de tu b\xF3veda (los valores nunca regresan)",
+  "Save or replace secrets from a dotenv file, or one value from stdin": "Guarda o reemplaza secretos desde un archivo dotenv, o un valor por stdin",
+  "from a password manager": "desde un gestor de contrase\xF1as",
+  "Delete secrets by name; whatever references them stops resolving": "Borra secretos por nombre; lo que los use deja de resolverlos",
+  // sandboxes files rm|mv|mkdir, bg, git
+  "rm: a folder and everything in it": "rm: una carpeta y todo lo que tiene",
+  "Long-running processes: start one in the background, list, poll its output, kill it": "Procesos largos: arranca uno en segundo plano, enl\xEDstalos, lee su salida, detenlo",
+  "kill: seconds between SIGTERM and SIGKILL (default 5)": "kill: segundos entre SIGTERM y SIGKILL (default 5)",
+  "status, exit code, stdout/stderr": "estado, c\xF3digo de salida, stdout/stderr",
+  "Git inside a sandbox: clone, status, commit, push, pull, checkout, log": "Git dentro de un sandbox: clone, status, commit, push, pull, checkout, log",
+  "Repo folder inside the sandbox (required)": "Carpeta del repo dentro del sandbox (obligatoria)",
+  "clone: repo URL (clean; the token goes in --git-token)": "clone: URL del repo (limpia; el token va en --git-token)",
+  "clone/push/checkout: branch": "clone/push/checkout: rama",
+  "clone: shallow depth (default 1)": "clone: profundidad del clone superficial (default 1)",
+  "clone: a specific commit (full clone, detached HEAD)": "clone: un commit concreto (clone completo, HEAD desprendido)",
+  "Username for the token (default: x-access-token)": "Usuario del token (default: x-access-token)",
+  "commit: message": "commit: mensaje",
+  "commit: stage everything first (git add -A)": "commit: agrega todo antes (git add -A)",
+  "commit: only these paths (repeatable); log: only this path": "commit: s\xF3lo estas rutas (repetible); log: s\xF3lo esta ruta",
+  "commit: author name": "commit: nombre del autor",
+  "commit: author email": "commit: correo del autor",
+  "push: remote (default origin)": "push: remoto (default origin)",
+  "push: set the upstream branch": "push: fija la rama upstream",
+  "push: --force-with-lease (fails if the remote moved)": "push: --force-with-lease (falla si el remoto se movi\xF3)",
+  "pull: rebase instead of merge": "pull: rebase en vez de merge",
+  "checkout: create the branch (-B, safe to repeat)": "checkout: crea la rama (-B, seguro de repetir)",
+  "checkout --create: start point": "checkout --create: punto de partida",
+  "log: how many": "log: cu\xE1ntos",
+  // fleet
+  "Fleet agents: one agent, many conversations (WhatsApp, WABA, Teams, web)": "Agentes de flota: un agente, muchas conversaciones (WhatsApp, WABA, Teams, web)",
+  "List your fleet agents": "Enlista tus agentes de flota",
+  "Show a fleet agent: engine, model, effort, prompt and channels": "Muestra un agente de flota: motor, modelo, esfuerzo, prompt y canales",
+  "The catalog and current state: engines, models, tool buckets, MCPs, skills, channels": "El cat\xE1logo y el estado actual: motores, modelos, grupos de tools, MCPs, skills, canales",
+  "Filter the capabilities catalog": "Filtra el cat\xE1logo de capacidades",
+  "Change name, system prompt, engine, model, effort or number mode; --recycle applies it now": "Cambia nombre, system prompt, motor, modelo, esfuerzo o modo de n\xFAmero; --recycle lo aplica ya",
+  "Display name and the name the agent goes by": "Nombre visible y el nombre con el que se presenta el agente",
+  "System prompt for every channel (- reads stdin)": "System prompt para todos los canales (- lee stdin)",
+  "Engine (claude, deepseek, codex\u2026); recycles its boxes by itself": "Motor (claude, deepseek, codex\u2026); recicla sus cajas solo",
+  "Model of the current engine (see fleet capabilities)": "Modelo del motor actual (mira fleet capabilities)",
+  "low, medium, high, xhigh or max": "low, medium, high, xhigh o max",
+  "on: dedicated number (no name prefix on replies)": "on: n\xFAmero dedicado (las respuestas no llevan el nombre al inicio)",
+  "Recycle its running boxes so the change applies on the next turn": "Recicla sus cajas vivas para que el cambio aplique en el siguiente turno",
+  "Send one message to a fleet agent and print its reply": "Manda un mensaje a un agente de flota e imprime su respuesta",
+  "Conversation id; reuse it to continue (default: a new cli-<uuid>)": "Id de la conversaci\xF3n; rep\xEDtelo para seguirla (default: una nueva cli-<uuid>)",
+  "Channel whose config (tools, MCP, prompt) applies, e.g. web or waba:<id>": "Canal cuya config (tools, MCP, prompt) aplica, p. ej. web o waba:<id>",
+  "Who is writing (phone, user id)": "Qui\xE9n escribe (tel\xE9fono, id de usuario)",
+  "IANA timezone for the turn, e.g. America/Mexico_City": "Zona horaria IANA del turno, p. ej. America/Mexico_City",
+  "same conversation": "la misma conversaci\xF3n",
+  // documents
+  "Content": "Contenido",
+  "Documents (/dash/documents): pages of HTML you write, published and exported to PDF/PNG": "Documentos (/dash/documents): p\xE1ginas de HTML que t\xFA escribes, publicadas y exportadas a PDF/PNG",
+  "List your documents, newest first": "Enlista tus documentos, los m\xE1s nuevos primero",
+  "Only documents whose name contains this": "S\xF3lo los documentos cuyo nombre contenga esto",
+  "How many (default 20, max 100)": "Cu\xE1ntos (default 20, m\xE1ximo 100)",
+  "Show one document: format, URL and its pages": "Muestra un documento: formato, URL y sus p\xE1ginas",
+  "Create a document from HTML files (one page each) or a blank page": "Crea un documento desde archivos HTML (una p\xE1gina cada uno) o con una p\xE1gina en blanco",
+  "Document name": "Nombre del documento",
+  "A page's HTML, in order (repeatable; - reads stdin). Without it: one blank page": "El HTML de una p\xE1gina, en orden (repetible; - lee stdin). Sin \xE9l: una p\xE1gina en blanco",
+  "letter (default), ig-feed, ig-square, ig-story, li-feed, slide-16-9, tiktok\u2026 or WxH in px": "letter (default), ig-feed, ig-square, ig-story, li-feed, slide-16-9, tiktok\u2026 o WxH en px",
+  "Theme name (default: your brand kit or default)": "Nombre del tema (default: tu brand kit o default)",
+  "Brand kit to apply (default: your default kit)": "Brand kit a aplicar (default: tu kit predeterminado)",
+  "one blank 1080x1350 page": "una p\xE1gina en blanco de 1080x1350",
+  "List pages, print one page's HTML, or replace it with a file": "Enlista las p\xE1ginas, imprime el HTML de una o lo reemplaza con un archivo",
+  "get: write the HTML to this file instead of stdout": "get: escribe el HTML en este archivo en vez de stdout",
+  "Add a page from an HTML file (blank without one)": "Agrega una p\xE1gina desde un archivo HTML (en blanco sin \xE9l)",
+  "Insert after page N (0 = first; default: at the end)": "Inserta despu\xE9s de la p\xE1gina N (0 = al inicio; default: al final)",
+  "Page name in the editor": "Nombre de la p\xE1gina en el editor",
+  "Delete one page (a document keeps at least one)": "Borra una p\xE1gina (un documento conserva al menos una)",
+  "Put the pages in a new order (every page, by number or id)": "Pone las p\xE1ginas en otro orden (todas, por n\xFAmero o id)",
+  "swap pages 2 and 3": "intercambia las p\xE1ginas 2 y 3",
+  "Publish (or republish) the document at its public URL": "Publica (o republica) el documento en su URL p\xFAblica",
+  "Render to a PDF file or to one PNG per page (rendered on the server)": "Lo renderiza a un PDF o a un PNG por p\xE1gina (en el servidor)",
+  "pdf: the file (default <name>.pdf); png: the folder (default .)": "pdf: el archivo (default <nombre>.pdf); png: la carpeta (default .)",
+  "Only these pages (numbers or ids, comma-separated)": "S\xF3lo estas p\xE1ginas (n\xFAmeros o ids, separados por coma)",
+  "one PNG per page at its exact size": "un PNG por p\xE1gina a su tama\xF1o exacto",
+  "Delete a document (irreversible)": "Borra un documento (irreversible)",
+  // video
+  "Video projects: HTML + GSAP scenes with narration and music, rendered to MP4": "Proyectos de video: escenas de HTML + GSAP con narraci\xF3n y m\xFAsica, renderizadas a MP4",
+  "List, show, create or delete video projects": "Enlista, muestra, crea o borra proyectos de video",
+  "create: project name": "create: nombre del proyecto",
+  "create: portrait (default 1080x1920), square, landscape, story, reel, tiktok, youtube, 16-9, or WxH": "create: portrait (default 1080x1920), square, landscape, story, reel, tiktok, youtube, 16-9, o WxH",
+  "create: frames per second (default 30)": "create: cuadros por segundo (default 30)",
+  "create: background theme: default, dark, light, brand": "create: tema del fondo: default, dark, light, brand",
+  "scenes, music, last render": "escenas, m\xFAsica, \xFAltimo render",
+  "List, add, edit, delete or reorder a project's scenes": "Enlista, agrega, edita, borra o reordena las escenas de un proyecto",
+  "GSAP against the paused timeline `tl`: a file, or the code itself": "GSAP sobre el timeline pausado `tl`: un archivo, o el c\xF3digo tal cual",
+  "Seconds on screen (default: fits the narration, else 3)": "Segundos en pantalla (default: lo que dure la narraci\xF3n, si no 3)",
+  "Scene name": "Nombre de la escena",
+  'Voiceover text, synthesized at render time ("" removes it)': 'Texto de la voz en off, se sintetiza al renderizar ("" la quita)',
+  "Narration voice: em_santa (default), em_alex, ef_dora": "Voz de la narraci\xF3n: em_santa (default), em_alex, ef_dora",
+  "add: insert after scene N (0 = first; default: at the end)": "add: inserta despu\xE9s de la escena N (0 = al inicio; default: al final)",
+  "replace its HTML": "reemplaza su HTML",
+  "Set or remove the background music (a public audio URL)": "Pone o quita la m\xFAsica de fondo (una URL p\xFAblica de audio)",
+  "File name inside the bundle (default: from the URL)": "Nombre del archivo dentro del bundle (default: el de la URL)",
+  "remove it": "la quita",
+  "Render the project to MP4 on the server; --wait follows it to the end": "Renderiza el proyecto a MP4 en el servidor; --wait lo sigue hasta el final",
+  "Wait for the MP4 (spinner in a terminal); without it, start and return": "Espera el MP4 (spinner en una terminal); sin ella, lo arranca y regresa",
+  "With --wait: also download the MP4 here": "Con --wait: adem\xE1s baja el MP4 aqu\xED",
+  "With --wait: give up after this many minutes (default 15)": "Con --wait: se rinde tras estos minutos (default 15)",
+  "starts it; then:": "lo arranca; luego:",
+  "status: rendering \u2192 ready | failed": "status: rendering \u2192 ready | failed",
+  "List AI-generated videos (prompt \u2192 clip), newest first": "Enlista los videos generados con IA (prompt \u2192 clip), los m\xE1s nuevos primero",
+  "How many (default 50, max 100)": "Cu\xE1ntos (default 50, m\xE1ximo 100)"
 };
 
 // src/help.ts
@@ -4077,15 +6667,15 @@ var GLOBAL_FLAGS_EN = `Global flags:
 Naming (like gh): noun then verb \u2014 easybits <noun> <verb>. Old spellings still work
 and print the new one on stderr (never with --json).
 
-Names or ids: agents, sandboxes/machines and databases take either
+Names or ids: agents, sandboxes/machines, databases and sites take either
 (exact, case-insensitive; two with the same name \u2192 exit 2 with the ids).
 
-Deletes (sandboxes destroy, agents destroy, db rm, domains rm, files rm, agents files|skills rm)
+Deletes (every rm, destroy and revoke: sandboxes, machines, agents, db, domains, files, webhooks, keys, websites, documents\u2026)
 ask first; without a terminal or with --json pass -y/--yes, or they exit 2.
 Agent writes (agents set|create|files|skills|mcp) take --dry-run: show the change, touch nothing.
 
 Env: EASYBITS_API_KEY (API key), EASYBITS_URL (API server, default https://www.easybits.cloud),
-     EASYBITS_NO_UPDATE_CHECK=1 (no daily "update available" notice on stderr)
+     EASYBITS_NO_UPDATE_CHECK=1 (no "update available" notice on stderr; npm is checked hourly)
 
 Exit codes: 0 ok, 1 API error, 2 usage error, 3 not logged in or bad key`;
 var GLOBAL_FLAGS_ES = `Flags globales:
@@ -4098,16 +6688,16 @@ var GLOBAL_FLAGS_ES = `Flags globales:
 Nombres (como gh): sustantivo y luego verbo \u2014 easybits <sustantivo> <verbo>. Las formas
 viejas siguen funcionando y avisan la nueva en stderr (nunca con --json).
 
-Nombres o ids: agentes, sandboxes/m\xE1quinas y bases aceptan cualquiera de los dos
+Nombres o ids: agentes, sandboxes/m\xE1quinas, bases y sitios aceptan cualquiera de los dos
 (exacto, sin distinguir may\xFAsculas; dos con el mismo nombre \u2192 sale con 2 y los ids).
 
-Los borrados (sandboxes destroy, agents destroy, db rm, domains rm, files rm, agents files|skills rm)
+Los borrados (todo rm, destroy y revoke: sandboxes, m\xE1quinas, agentes, db, dominios, archivos, webhooks, llaves, websites, documentos\u2026)
 preguntan antes; sin terminal o con --json pasa -y/--yes, o salen con 2.
 Lo que escribe en un agente (agents set|create|files|skills|mcp) acepta --dry-run: ense\xF1a el
 cambio y no toca nada.
 
 Env: EASYBITS_API_KEY (API key), EASYBITS_URL (servidor de la API, default https://www.easybits.cloud),
-     EASYBITS_NO_UPDATE_CHECK=1 (sin el aviso diario de versi\xF3n nueva en stderr)
+     EASYBITS_NO_UPDATE_CHECK=1 (sin el aviso de versi\xF3n nueva en stderr; npm se revisa cada hora)
 
 C\xF3digos de salida: 0 ok, 1 error de la API, 2 error de uso, 3 sin sesi\xF3n o key inv\xE1lida`;
 var globalFlags = () => lang() === "es" ? GLOBAL_FLAGS_ES : GLOBAL_FLAGS_EN;
@@ -4178,7 +6768,7 @@ function indent(s, n) {
 var BANNER = "            \x1B[38;2;244;245;251m\u2860\u2812\u2812\u28E4\x1B[38;2;152;112;237m\u28C0\u28C0\u2840    \x1B[38;2;244;245;251m\u28FF\u28FF\u28FF\u28FF\u28FF\u28FF                       \u28FF\u28FF\u28FF\u28FF\u28FF\u28FF\u28E4 \u28FF\u28FF  \u28E4\u28FF\x1B[0m\n    \x1B[38;2;244;245;251m\u28A0\u2854\u2809\u2809\u2809\u2822\u2840\u285E\x1B[38;2;152;112;237m\u2880\u2874\u288B\u282D\x1B[38;2;244;245;251m\u2809\u28AF\x1B[38;2;152;112;237m\u28FD\u28F7\u2844  \x1B[38;2;244;245;251m\u28FF\u28FF     \u28E4\u28FF\u28FF\u28FF\u28FF\u28FF\u28E4 \u28E4\u28FF\u28FF\u28FF\u28FF\u28E4 \u28FF\u28FF  \u28FF\u28FF \u28FF\u28FF   \u28FF\u28FF \u28E4\u28E4 \u28E4\u28FF\u28FF\u28E4\u28E4 \u28E4\u28FF\u28FF\u28FF\u28FF\u28E4\x1B[0m\n   \x1B[38;2;152;112;237m\u2880\x1B[38;2;244;245;251m\u28FF\x1B[38;2;152;112;237m\u289B\u280D\u2809\u2899\u2873\u28FC\u2857\u28FE\u28B0\x1B[38;2;244;245;251m\u28A1\u28F6\u28E4\u2818\u2846 \x1B[38;2;152;112;237m\u28BB  \x1B[38;2;244;245;251m\u28FF\u28FF\u28FF\u28FF\u28FF   \u28E4\u28E4\u28E4\u28E4\u28FF\u28FF \u28FF\u28FF\u28E4\u28E4\u28E4  \u28FF\u28FF  \u28FF\u28FF \u28FF\u28FF\u28FF\u28FF\u28FF\u28FF\u28E4 \u28FF\u28FF \u281B\u28FF\u28FF\u281B\u281B \u28FF\u28FF\u28E4\u28E4\u28E4\x1B[0m\n\x1B[38;2;152;112;237m\u28E4\u28C4\u28C0\u28FF\x1B[38;2;244;245;251m\u28DF\x1B[38;2;152;112;237m\u2801  \x1B[38;2;244;245;251m\u28FE\u28FF\u280E\x1B[38;2;152;112;237m\u28E7\u28BF\u284C\x1B[38;2;244;245;251m\u2808\u2819\u280B \u2847\x1B[38;2;152;112;237m\u2880\u287E  \x1B[38;2;244;245;251m\u28FF\u28FF     \u28FF\u28FF\u281B\u281B\u281B\u28FF\u28FF  \u281B\u281B\u281B\u28FF\u28FF \u281B\u28FF\u28FF\u28E4\u28FF\u28FF \u28FF\u28FF   \u28FF\u28FF \u28FF\u28FF  \u28FF\u28FF    \u281B\u281B\u281B\u28FF\u28FF\x1B[0m\n\x1B[38;2;152;112;237m\u2801 \u2808\u28E7\x1B[38;2;244;245;251m\u28BF\u28C6   \u2809\x1B[38;2;152;112;237m\u2880\u285F\x1B[38;2;244;245;251m\u28E7\x1B[38;2;152;112;237m\u2859\u2832\u28A4\u28E4\u2874\u2835\u280B   \x1B[38;2;244;245;251m\u28FF\u28FF\u28FF\u28FF\u28FF\u28FF \u281B\u28FF\u28FF\u28FF\u281B\u28FF\u28FF \u281B\u28FF\u28FF\u28FF\u28FF\u281B  \u28E4\u28FF\u28FF\u281B  \u28FF\u28FF\u28FF\u28FF\u28FF\u28FF\u281B \u28FF\u28FF  \u281B\u28FF\u28FF\u28FF \u281B\u28FF\u28FF\u28FF\u28FF\u281B\x1B[0m\n   \x1B[38;2;152;112;237m\u2808\u283B\x1B[38;2;244;245;251m\u28BF\u28E6\x1B[38;2;152;112;237m\u28C0\u28E0\u28F4\u281F\x1B[38;2;244;245;251m\u2801\u2808\u2819\u2833\u2836\u280A                            \u28FF\u28FF\u281B\x1B[0m\n      \x1B[38;2;244;245;251m\u2808\u2809\u2809\u2801\x1B[0m";
 
 // src/index.ts
-import { EasybitsError as EasybitsError3 } from "@easybits.cloud/sdk";
+import { EasybitsError as EasybitsError7 } from "@easybits.cloud/sdk";
 
 // src/aliases.ts
 function positionals(argv2) {
@@ -4198,6 +6788,13 @@ function positionals(argv2) {
 var MACHINE_SUBS = ["ls", "list", "deploy", "release", "releases", "logs", "rollback", "secrets"];
 var SANDBOX_NAMES = ["sandboxes", "sandbox", "sb"];
 var AGENT_NAMES = ["agents", "agent"];
+var DOMAIN_NAMES = ["domains", "domain"];
+function oldSandboxDomains(sub, rest, hasPort) {
+  if (sub === "ls" || sub === "list") return rest >= 1;
+  if (sub === "add") return hasPort || rest >= 2;
+  if (sub === "verify" || sub === "rm" || sub === "remove" || sub === "delete") return rest >= 2;
+  return false;
+}
 function normalizeArgs(input) {
   const argv2 = [...input];
   const notes = [];
@@ -4231,6 +6828,18 @@ function normalizeArgs(input) {
     argv2[pos[1]] = "deploy";
     notes.push(["`machines release` is now `machines deploy`.", "`machines release` ahora es `machines deploy`."]);
   }
+  if (DOMAIN_NAMES.includes(at(0) ?? "")) {
+    const hasPort = head.some((a) => a === "--port" || a.startsWith("--port="));
+    const sub = at(1);
+    if (oldSandboxDomains(sub, pos.length - 2, hasPort)) {
+      argv2.splice(pos[0], 1, "sandboxes", "domains");
+      notes.push([
+        `\`easybits domains ${sub} <sandbox> \u2026\` is now \`easybits sandboxes domains ${sub} <sandbox> \u2026\` (\`domains\` is for your account's domains).`,
+        `\`easybits domains ${sub} <caja> \u2026\` ahora es \`easybits sandboxes domains ${sub} <caja> \u2026\` (\`domains\` es para los dominios de tu cuenta).`
+      ]);
+      pos = positionals(argv2);
+    }
+  }
   const noun = SANDBOX_NAMES.includes(at(0) ?? "") ? "sandboxes" : AGENT_NAMES.includes(at(0) ?? "") ? "agents" : null;
   if (noun && (at(1) === "create" || at(1) === "new")) {
     const stop = argv2.indexOf("--");
@@ -4248,7 +6857,7 @@ function normalizeArgs(input) {
 }
 
 // src/index.ts
-var VERSION2 = true ? "0.15.5" : "dev";
+var VERSION2 = true ? "0.17.0" : "dev";
 var GLOBAL_OPTIONS = {
   json: { type: "boolean" },
   token: { type: "string" },
@@ -4394,7 +7003,7 @@ async function main(input) {
   try {
     await run();
   } catch (e) {
-    if (e instanceof EasybitsError3 && e.status === 401 && usedSession() && await forceRefresh()) {
+    if (e instanceof EasybitsError7 && e.status === 401 && usedSession() && await forceRefresh()) {
       await run();
       return;
     }