@vm0/cli 9.150.11 → 9.152.0

package/zero.js

@@ -10,11 +10,14 @@ import {
   InvalidArgumentError,
   MODEL_PROVIDER_TYPES,
   Option,
+  completeHostedSite,
   completePhoneFileUpload,
   completeSlackFileUpload,
   completeTelegramFileUpload,
   configureGlobalProxyFromEnv,
   connectorTypeSchema,
+  createLocalBrowserReadCommand,
+  createLocalBrowserWriteCommand,
   createSkill,
   createZeroAgent,
   createZeroRun,
@@ -51,6 +54,7 @@ import {
   getConnectorFirewall,
   getConnectorTypeForSecretName,
   getDefaultAuthMethod,
+  getLocalBrowserReadCommand,
   getScopeDiff,
   getSecretsForAuthMethod,
   getSelectableProviderTypes,
@@ -91,6 +95,7 @@ import {
   paginate,
   parseEvent,
   parseTime,
+  prepareHostedSite,
   promptConfirm,
   promptPassword,
   promptSelect,
@@ -130,7 +135,7 @@ import {
   withErrorHandler,
   zeroAgentCustomSkillNameSchema,
   zeroRemoteAgentCommand
-} from "./chunk-2ZSJAVJT.js";
+} from "./chunk-T32CMT7F.js";
 import {
   __toESM,
   init_esm_shims
@@ -1885,8 +1890,8 @@ function formatDateTime(dateStr) {
   const hours = String(date.getHours()).padStart(2, "0");
   const minutes = String(date.getMinutes()).padStart(2, "0");
   const formatted = `${year}-${month}-${day} ${hours}:${minutes}`;
-  const relative = formatRelativeTime(dateStr);
-  return `${formatted} (${relative})`;
+  const relative2 = formatRelativeTime(dateStr);
+  return `${formatted} (${relative2})`;
 }
 function generateCronExpression(frequency, time, day) {
   const [hourStr, minuteStr] = time.split(":");
@@ -3281,8 +3286,8 @@ function renderTerminalRunResult(runId, runResponse) {
   return { succeeded: false, runId };
 }
 function sleep(ms) {
-  return new Promise((resolve) => {
-    return setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    return setTimeout(resolve2, ms);
   });
 }
 async function pollZeroEvents(runId, options) {
@@ -4559,8 +4564,8 @@ Notes:
     async (options) => {
       let fileSize;
       try {
-        const stat = statSync(options.file);
-        fileSize = stat.size;
+        const stat2 = statSync(options.file);
+        fileSize = stat2.size;
       } catch {
         throw new Error(`File not found: ${options.file}`);
       }
@@ -4894,11 +4899,11 @@ Notes:
     async (options) => {
       let fileSize;
       try {
-        const stat = statSync2(options.file);
-        if (!stat.isFile()) {
+        const stat2 = statSync2(options.file);
+        if (!stat2.isFile()) {
           throw new Error(`Not a regular file: ${options.file}`);
         }
-        fileSize = stat.size;
+        fileSize = stat2.size;
       } catch (error) {
         if (error instanceof Error && error.message.startsWith("Not ")) {
           throw error;
@@ -5072,11 +5077,11 @@ Output:
     async (options) => {
       let fileSize;
       try {
-        const stat = statSync3(options.file);
-        if (!stat.isFile()) {
+        const stat2 = statSync3(options.file);
+        if (!stat2.isFile()) {
           throw new Error(`Not a regular file: ${options.file}`);
         }
-        fileSize = stat.size;
+        fileSize = stat2.size;
       } catch (error) {
         if (error instanceof Error && error.message.startsWith("Not ")) {
           throw error;
@@ -5378,13 +5383,13 @@ import { join as join4 } from "path";
 var IGNORED_NAMES = /* @__PURE__ */ new Set(["node_modules", ".git", ".DS_Store"]);
 function readSkillDirectory(dirPath) {
   const files = [];
-  function walk(dir, prefix) {
+  function walk2(dir, prefix) {
     const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".") || IGNORED_NAMES.has(entry.name)) continue;
       const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        walk(join4(dir, entry.name), relPath);
+        walk2(join4(dir, entry.name), relPath);
       } else {
         files.push({
           path: relPath,
@@ -5393,7 +5398,7 @@ function readSkillDirectory(dirPath) {
       }
     }
   }
-  walk(dirPath, "");
+  walk2(dirPath, "");
   if (!files.some((f) => {
     return f.path === "SKILL.md";
   })) {
@@ -6459,12 +6464,12 @@ async function readClipboard() {
   return stdout;
 }
 async function writeClipboard(text) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const proc = spawn("pbcopy", { stdio: ["pipe", "ignore", "ignore"] });
     proc.on("error", reject);
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve();
+        resolve2();
       } else {
         reject(new Error(`pbcopy exited with code ${code}`));
       }
@@ -6486,13 +6491,13 @@ async function openApplication(nameOrBundleId) {
 
 // src/lib/computer-use/desktop-server.ts
 function readBody(req) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(chunk);
     });
     req.on("end", () => {
-      resolve(Buffer.concat(chunks).toString());
+      resolve2(Buffer.concat(chunks).toString());
     });
     req.on("error", reject);
   });
@@ -6532,7 +6537,7 @@ async function handleZoom(searchParams, res) {
   res.end(JSON.stringify(result));
 }
 function parseJsonBody(req) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
     let size = 0;
     req.on("data", (chunk) => {
@@ -6546,7 +6551,7 @@ function parseJsonBody(req) {
     });
     req.on("end", () => {
       try {
-        resolve(JSON.parse(Buffer.concat(chunks).toString()));
+        resolve2(JSON.parse(Buffer.concat(chunks).toString()));
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -6688,12 +6693,12 @@ async function handleOpenApplication(req, res) {
   res.end(JSON.stringify({ ok: true }));
 }
 async function getRandomPort() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = createNetServer();
     server.listen(0, "127.0.0.1", () => {
       const { port } = server.address();
       server.close(() => {
-        resolve(port);
+        resolve2(port);
       });
     });
     server.on("error", reject);
@@ -6760,7 +6765,7 @@ async function handleRequest(token, req, res) {
   }
 }
 function startDesktopServer(token, port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = createServer((req, res) => {
       handleRequest(token, req, res).catch(() => {
         if (!res.headersSent) {
@@ -6771,7 +6776,7 @@ function startDesktopServer(token, port) {
     });
     server.on("error", reject);
     server.listen(port, "127.0.0.1", () => {
-      resolve(server);
+      resolve2(server);
     });
   });
 }
@@ -6835,13 +6840,13 @@ var hostStartCommand = new Command().name("start").description("Start the comput
       console.log(source_default.dim("Press ^C twice to disconnect"));
       console.log();
       let sigintCount = 0;
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const keepAlive = setInterval(() => {
         }, 6e4);
         const done = () => {
           clearInterval(keepAlive);
           process.removeListener("SIGINT", onSigint);
-          resolve();
+          resolve2();
         };
         const onSigint = () => {
           sigintCount++;
@@ -7681,6 +7686,522 @@ Examples:
   Download a file:  zero web download-file <file-id> -o /tmp/out.pdf`
 );
 
+// src/commands/zero/local-browser/index.ts
+init_esm_shims();
+function sleep3(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+function parseTimeoutSeconds(value) {
+  if (!value) return 30;
+  const seconds = Number.parseInt(value, 10);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error("Timeout must be a positive number of seconds");
+  }
+  return seconds;
+}
+function parseOptionalNonNegativeInteger(value, label) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return parsed;
+}
+function parsePositiveInteger2(value, label) {
+  if (value === void 0) {
+    throw new Error(`${label} is required`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return parsed;
+}
+function resultText(command) {
+  if (!command.result) {
+    return "";
+  }
+  return JSON.stringify(command.result, null, 2);
+}
+async function runReadCommand(kind, options) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  const created = await createLocalBrowserReadCommand({
+    kind,
+    timeoutMs: timeoutSeconds * 1e3,
+    ...options.tabId ? { tabId: options.tabId } : {},
+    ...options.host ? { hostName: options.host } : {},
+    ...options.hostId ? { hostId: options.hostId } : {}
+  });
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  while (Date.now() <= deadline) {
+    const command = await getLocalBrowserReadCommand(created.commandId);
+    if (command.status === "queued" || command.status === "running") {
+      if (process.stdout.isTTY) {
+        process.stdout.write(".");
+      }
+      await sleep3(1e3);
+      continue;
+    }
+    if (process.stdout.isTTY) {
+      process.stdout.write("\n");
+    }
+    if (command.status === "failed") {
+      throw new Error(
+        command.error ? `${command.error.code}: ${command.error.message}` : "Local-browser command failed"
+      );
+    }
+    const text = resultText(command);
+    if (text) {
+      console.log(text);
+    }
+    return;
+  }
+  throw new Error(`Local-browser command timed out: ${created.commandId}`);
+}
+async function waitForCommand(commandId, timeoutSeconds) {
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  while (Date.now() <= deadline) {
+    const command = await getLocalBrowserReadCommand(commandId);
+    if (command.status === "pending_approval" || command.status === "queued" || command.status === "running") {
+      if (process.stdout.isTTY) {
+        process.stdout.write(".");
+      }
+      await sleep3(1e3);
+      continue;
+    }
+    if (process.stdout.isTTY) {
+      process.stdout.write("\n");
+    }
+    if (command.status === "failed") {
+      throw new Error(
+        command.error ? `${command.error.code}: ${command.error.message}` : "Local-browser command failed"
+      );
+    }
+    const text = resultText(command);
+    if (text) {
+      console.log(text);
+    }
+    return;
+  }
+  throw new Error(`Local-browser command timed out: ${commandId}`);
+}
+async function runWriteCommand(kind, options, payload) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  const created = await createLocalBrowserWriteCommand({
+    kind,
+    timeoutMs: timeoutSeconds * 1e3,
+    ...options.tabId ? { tabId: options.tabId } : {},
+    ...options.host ? { hostName: options.host } : {},
+    ...options.hostId ? { hostId: options.hostId } : {},
+    ...payload
+  });
+  await waitForCommand(created.commandId, timeoutSeconds);
+}
+function addReadOptions(command) {
+  return command.option("--host <name>", "Run on a named local-browser host").option("--host-id <id>", "Run on a specific local-browser host id").option("--tab-id <id>", "Target a specific browser tab").option("--timeout <seconds>", "Maximum time to wait", "30");
+}
+function addWriteOptions(command, options = {}) {
+  const withHostOptions = command.option("--host <name>", "Run on a named local-browser host").option("--host-id <id>", "Run on a specific local-browser host id").option("--timeout <seconds>", "Maximum time to wait", "30");
+  return options.tabId === false ? withHostOptions : withHostOptions.option("--tab-id <id>", "Target a specific browser tab");
+}
+function readCommand(name, kind) {
+  return addReadOptions(
+    new Command().name(name).description(`Run ${kind}`).action(
+      withErrorHandler(async (options) => {
+        await runReadCommand(kind, options);
+      })
+    )
+  );
+}
+var tabsCommand = new Command().name("tabs").description("Read and control browser tabs").addCommand(readCommand("list", "tabs.list")).addCommand(readCommand("current", "tabs.current")).addCommand(
+  addWriteOptions(
+    new Command().name("activate").description("Run tabs.activate").requiredOption("--tab-id <id>", "Tab to activate").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("tabs.activate", options, {});
+      })
+    ),
+    { tabId: false }
+  )
+).addCommand(
+  addWriteOptions(
+    new Command().name("open").description("Run tabs.open").requiredOption("--url <url>", "URL to open").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("tabs.open", options, { url: options.url });
+      })
+    )
+  )
+).addCommand(
+  addWriteOptions(
+    new Command().name("close").description("Run tabs.close").requiredOption("--tab-id <id>", "Tab to close").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("tabs.close", options, {});
+      })
+    ),
+    { tabId: false }
+  )
+);
+var pageCommand = new Command().name("page").description("Read and control the active browser page").addCommand(readCommand("snapshot", "page.snapshot")).addCommand(readCommand("screenshot", "page.screenshot")).addCommand(readCommand("selection", "page.selection")).addCommand(readCommand("metadata", "page.metadata")).addCommand(
+  addWriteOptions(
+    new Command().name("click").description("Run page.click").option("--selector <selector>", "CSS selector to click").option("--x <pixels>", "X coordinate to click").option("--y <pixels>", "Y coordinate to click").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("page.click", options, {
+          ...options.selector ? { selector: options.selector } : {},
+          ...options.x !== void 0 ? { x: parseOptionalNonNegativeInteger(options.x, "x") } : {},
+          ...options.y !== void 0 ? { y: parseOptionalNonNegativeInteger(options.y, "y") } : {}
+        });
+      })
+    )
+  )
+).addCommand(
+  addWriteOptions(
+    new Command().name("type").description("Run page.type").requiredOption("--selector <selector>", "CSS selector to type into").requiredOption("--text <text>", "Text to type").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("page.type", options, {
+          selector: options.selector,
+          text: options.text
+        });
+      })
+    )
+  )
+).addCommand(
+  addWriteOptions(
+    new Command().name("scroll").description("Run page.scroll").option(
+      "--direction <direction>",
+      "Scroll direction: up or down",
+      "down"
+    ).option("--amount <pixels>", "Scroll amount in pixels", "600").action(
+      withErrorHandler(async (options) => {
+        if (options.direction !== "up" && options.direction !== "down") {
+          throw new Error("direction must be up or down");
+        }
+        await runWriteCommand("page.scroll", options, {
+          direction: options.direction,
+          amount: parsePositiveInteger2(options.amount, "amount")
+        });
+      })
+    )
+  )
+).addCommand(
+  addWriteOptions(
+    new Command().name("navigate").description("Run page.navigate").requiredOption("--url <url>", "URL to navigate to").action(
+      withErrorHandler(async (options) => {
+        await runWriteCommand("page.navigate", options, {
+          url: options.url
+        });
+      })
+    )
+  )
+);
+var zeroLocalBrowserCommand = new Command().name("local-browser").description("Read authorized browser context").addHelpText(
+  "after",
+  `
+Examples:
+  List tabs?       zero local-browser tabs list
+  Current tab?     zero local-browser tabs current
+  Click page?      zero local-browser page click --selector button
+  Open tab?        zero local-browser tabs open --url https://example.com`
+).addCommand(tabsCommand).addCommand(pageCommand);
+
+// src/commands/zero/host/index.ts
+init_esm_shims();
+import { readFile as readFile3 } from "fs/promises";
+
+// src/lib/host/static-site.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+import { extname as extname3, relative, resolve, sep, dirname, posix } from "path";
+var MIME_BY_EXTENSION3 = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".svg": "image/svg+xml; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".wasm": "application/wasm",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav"
+};
+var HTML_REFERENCE_RE = /<(?:script|link|img|source|video|audio|embed|object)\b[^>]*\s(?:src|href|poster|data)=["']([^"']+)["'][^>]*>/giu;
+var SRCSET_RE = /\s(?:srcset)=["']([^"']+)["']/giu;
+var CSS_URL_RE = /url\(\s*["']?([^"')]+)["']?\s*\)/giu;
+var CSS_IMPORT_RE = /@import\s+(?:url\()?["']([^"']+)["']\)?/giu;
+function inferContentType3(path) {
+  return MIME_BY_EXTENSION3[extname3(path).toLowerCase()] ?? "application/octet-stream";
+}
+function looksImmutable(path) {
+  if (path.startsWith("/assets/")) {
+    return true;
+  }
+  return /(?:[-.])[A-Za-z0-9_-]{8,}\.[A-Za-z0-9]+$/u.test(path);
+}
+function toSitePath(root, absolutePath) {
+  const rel = relative(root, absolutePath).split(sep).join("/");
+  return `/${rel}`;
+}
+function isSafeSitePath(path) {
+  if (!path.startsWith("/") || path.startsWith("//")) {
+    return false;
+  }
+  if (path.includes("\\") || path.includes("\0")) {
+    return false;
+  }
+  const segments = path.split("/").filter(Boolean);
+  return !segments.some((segment) => {
+    return segment === "." || segment === "..";
+  });
+}
+function isExternalReference(value) {
+  return /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/iu.test(value);
+}
+function stripQueryAndHash(value) {
+  const hashIndex = value.indexOf("#");
+  const withoutHash = hashIndex >= 0 ? value.slice(0, hashIndex) : value;
+  const queryIndex = withoutHash.indexOf("?");
+  return queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash;
+}
+function normalizeReference(fromPath, raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || isExternalReference(trimmed)) {
+    return null;
+  }
+  const stripped = stripQueryAndHash(trimmed);
+  if (!stripped || stripped.endsWith("/")) {
+    return null;
+  }
+  const resolved = stripped.startsWith("/") ? posix.normalize(stripped) : posix.normalize(posix.join(dirname(fromPath), stripped));
+  const path = resolved.startsWith("/") ? resolved : `/${resolved}`;
+  if (!isSafeSitePath(path)) {
+    throw new Error(`Invalid asset reference in ${fromPath}: ${raw}`);
+  }
+  return path;
+}
+function shouldRequireHtmlReference(path) {
+  return extname3(path).length > 0 || path.startsWith("/assets/");
+}
+function isHtmlExtension(ext) {
+  return ext === ".html" || ext === ".htm";
+}
+function shouldValidateReferences(ext) {
+  return isHtmlExtension(ext) || ext === ".css";
+}
+function collectSrcsetReferences(value) {
+  return value.split(",").map((entry) => {
+    return entry.trim().split(/\s+/u)[0] ?? "";
+  }).filter(Boolean);
+}
+function collectHtmlReferences(text) {
+  const references = [];
+  for (const match of text.matchAll(HTML_REFERENCE_RE)) {
+    if (match[1]) references.push(match[1]);
+  }
+  for (const match of text.matchAll(SRCSET_RE)) {
+    if (!match[1]) continue;
+    references.push(...collectSrcsetReferences(match[1]));
+  }
+  return references;
+}
+function collectCssReferences(text) {
+  const references = [];
+  for (const match of text.matchAll(CSS_URL_RE)) {
+    if (match[1]) references.push(match[1]);
+  }
+  for (const match of text.matchAll(CSS_IMPORT_RE)) {
+    if (match[1]) references.push(match[1]);
+  }
+  return references;
+}
+function collectReferences(ext, text) {
+  return isHtmlExtension(ext) ? collectHtmlReferences(text) : collectCssReferences(text);
+}
+async function hashFile(path) {
+  const bytes = await readFile2(path);
+  return createHash("sha256").update(bytes).digest("hex");
+}
+async function walk(root, dir, files) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(root, fullPath, files);
+      continue;
+    }
+    if (!entry.isFile()) {
+      throw new Error(`Unsupported file type in hosted site: ${fullPath}`);
+    }
+    const fileStat = await stat(fullPath);
+    const path = toSitePath(root, fullPath);
+    if (!isSafeSitePath(path)) {
+      throw new Error(`Invalid hosted-site path: ${path}`);
+    }
+    files.push({
+      absolutePath: fullPath,
+      path,
+      size: fileStat.size,
+      sha256: await hashFile(fullPath),
+      contentType: inferContentType3(path),
+      immutable: looksImmutable(path) || void 0
+    });
+  }
+}
+async function assertReferencesExist(files) {
+  const byPath = new Map(
+    files.map((file) => {
+      return [file.path, file];
+    })
+  );
+  for (const file of files) {
+    const ext = extname3(file.path).toLowerCase();
+    if (!shouldValidateReferences(ext)) {
+      continue;
+    }
+    const text = await readFile2(file.absolutePath, "utf8");
+    const references = collectReferences(ext, text);
+    for (const reference of references) {
+      const normalized = normalizeReference(file.path, reference);
+      if (!normalized) {
+        continue;
+      }
+      if (isHtmlExtension(ext) && !shouldRequireHtmlReference(normalized)) {
+        continue;
+      }
+      if (!byPath.has(normalized)) {
+        throw new Error(
+          `Missing asset referenced by ${file.path}: ${reference}`
+        );
+      }
+    }
+  }
+}
+async function scanStaticSite(rootPath) {
+  const root = resolve(rootPath);
+  const rootStat = await stat(root);
+  if (!rootStat.isDirectory()) {
+    throw new Error(`Hosted site path must be a directory: ${rootPath}`);
+  }
+  const files = [];
+  await walk(root, root, files);
+  if (!files.some((file) => {
+    return file.path === "/index.html";
+  })) {
+    throw new Error("Hosted site directory must include index.html");
+  }
+  await assertReferencesExist(files);
+  return {
+    root,
+    files: files.sort((a, b) => {
+      return a.path.localeCompare(b.path);
+    })
+  };
+}
+
+// src/commands/zero/host/index.ts
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var zeroHostCommand = new Command().name("host").description("Publish a built static site and print its public URL").argument("<dir>", "Static build directory, for example ./dist").requiredOption("--site <slug>", "Public site slug, e.g. my-product-demo").option("--spa", "Serve unknown HTML navigation paths from index.html").option("--json", "Output only the final result as JSON").addHelpText(
+  "after",
+  `
+Examples:
+  Publish a Vite build:  zero host ./dist --site my-product-demo --spa
+  Machine readable:     zero host ./dist --site my-product-demo --spa --json
+
+Notes:
+  - Authenticates via ZERO_TOKEN (requires host:write capability)
+  - The directory must include index.html
+  - Local HTML/CSS asset references must point at files inside the directory`
+).action(
+  withErrorHandler(async (dir, options) => {
+    const scan = await scanStaticSite(dir);
+    const totalSize = scan.files.reduce((sum, file) => {
+      return sum + file.size;
+    }, 0);
+    if (!options.json) {
+      console.log(source_default.dim(`Preparing ${scan.files.length} files...`));
+    }
+    const prepared = await prepareHostedSite({
+      site: options.site,
+      spaFallback: Boolean(options.spa),
+      files: scan.files.map((file) => {
+        return {
+          path: file.path,
+          size: file.size,
+          sha256: file.sha256,
+          contentType: file.contentType,
+          immutable: file.immutable
+        };
+      })
+    });
+    const uploadByPath = new Map(
+      prepared.uploads.map((upload) => {
+        return [upload.path, upload.uploadUrl];
+      })
+    );
+    for (const file of scan.files) {
+      const uploadUrl = uploadByPath.get(file.path);
+      if (!uploadUrl) {
+        throw new Error(`Missing upload URL for ${file.path}`);
+      }
+      if (!options.json) {
+        console.log(source_default.dim(`Uploading ${file.path}`));
+      }
+      const bytes = await readFile3(file.absolutePath);
+      const response = await fetch(uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": file.contentType },
+        body: new Uint8Array(bytes)
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Failed to upload ${file.path} (HTTP ${response.status})`
+        );
+      }
+    }
+    const completed = await completeHostedSite(prepared.deploymentId);
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          siteId: completed.siteId,
+          deploymentId: completed.deploymentId,
+          publicSlug: completed.publicSlug,
+          url: completed.url,
+          fileCount: scan.files.length,
+          size: totalSize
+        })
+      );
+      return;
+    }
+    console.log(source_default.green("\u2713 Hosted site ready"));
+    console.log(source_default.dim(`  Site: ${completed.publicSlug}`));
+    console.log(source_default.dim(`  Deployment: ${completed.deploymentId}`));
+    console.log(source_default.dim(`  Files: ${scan.files.length.toLocaleString()}`));
+    console.log(source_default.dim(`  Size: ${formatBytes(totalSize)}`));
+    console.log(`  URL: ${completed.url}`);
+  })
+);
+
 // src/zero.ts
 var COMMAND_CAPABILITY_MAP = {
   agent: "agent:read",
@@ -7700,7 +8221,9 @@ var COMMAND_CAPABILITY_MAP = {
   "computer-use": "computer-use:write",
   "built-in": "file:write",
   web: null,
-  "remote-agent": ["remote-agent:read", "remote-agent:write"]
+  host: "host:write",
+  "remote-agent": ["remote-agent:read", "remote-agent:write"],
+  "local-browser": ["local-browser:read", "local-browser:write"]
 };
 var DEFAULT_COMMANDS = [
   zeroOrgCommand,
@@ -7724,7 +8247,9 @@ var DEFAULT_COMMANDS = [
   zeroComputerUseCommand,
   zeroBuiltInCommand,
   zeroWebCommand,
-  zeroRemoteAgentCommand
+  zeroHostCommand,
+  zeroRemoteAgentCommand,
+  zeroLocalBrowserCommand
 ];
 function shouldHideCommand(name, payload) {
   if (!payload) return false;
@@ -7738,6 +8263,30 @@ function shouldHideCommand(name, payload) {
   }
   return !payload.capabilities.includes(requiredCap);
 }
+function buildZeroHelpText(payload = decodeZeroTokenPayload()) {
+  const examples = [
+    "  Check a connector?     zero doctor check-connector --env-name <ENV_NAME>",
+    "  Send a Slack message?  zero slack message send --help",
+    "  List Telegram bots?    zero telegram bot list",
+    "  Send Telegram?         zero telegram message send --help",
+    "  Upload Telegram?       zero telegram upload-file --help",
+    "  Download Telegram?     zero telegram download-file --help",
+    "  Send AgentPhone?       zero phone message --help",
+    "  Upload AgentPhone?     zero phone upload-file --help",
+    "  Download AgentPhone?   zero phone download-file --help",
+    "  Set up a schedule?     zero schedule setup --help",
+    "  Update yourself?       zero agent --help",
+    "  Manage custom skills?  zero skill --help",
+    "  Generate image?        zero built-in generate image --help",
+    "  Generate voice?        zero built-in generate voice --help",
+    ...shouldHideCommand("local-browser", payload) ? [] : ["  Read browser context?  zero local-browser --help"],
+    ...shouldHideCommand("host", payload) ? [] : ["  Host a static site?    zero host ./dist --site my-site --spa"],
+    "  Check your identity?   zero whoami"
+  ];
+  return `
+Examples:
+${examples.join("\n")}`;
+}
 function registerZeroCommands(prog, commands) {
   const token = process.env.ZERO_TOKEN;
   const payload = token ? decodeZeroTokenPayload(token) : void 0;
@@ -7749,32 +8298,16 @@ function registerZeroCommands(prog, commands) {
 var program = new Command();
 program.name("zero").description(
   "Zero CLI \u2014 interact with the zero platform from inside the sandbox"
-).version("9.150.11").addHelpText(
-  "after",
-  `
-Examples:
-  Check a connector?     zero doctor check-connector --env-name <ENV_NAME>
-  Send a Slack message?  zero slack message send --help
-  List Telegram bots?    zero telegram bot list
-  Send Telegram?         zero telegram message send --help
-  Upload Telegram?       zero telegram upload-file --help
-  Download Telegram?     zero telegram download-file --help
-  Send AgentPhone?       zero phone message --help
-  Upload AgentPhone?     zero phone upload-file --help
-  Download AgentPhone?   zero phone download-file --help
-  Set up a schedule?     zero schedule setup --help
-  Update yourself?       zero agent --help
-  Manage custom skills?  zero skill --help
-  Generate image?        zero built-in generate image --help
-  Generate voice?        zero built-in generate voice --help
-  Check your identity?   zero whoami`
-);
+).version("9.152.0").addHelpText("after", () => {
+  return buildZeroHelpText();
+});
 if (process.argv[1]?.endsWith("zero.js") || process.argv[1]?.endsWith("zero.ts") || process.argv[1]?.endsWith("zero")) {
   configureGlobalProxyFromEnv();
   registerZeroCommands(program);
   program.parse();
 }
 export {
+  buildZeroHelpText,
   program,
   registerZeroCommands
 };