@nearform/fling 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,3000 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import chalk4 from "chalk";
+
+// src/auth.ts
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { hostname as osHostname } from "node:os";
+
+// ../../packages/shared/src/api.ts
+import { z as z2 } from "zod";
+
+// ../../packages/shared/src/manifest.ts
+import { z } from "zod";
+
+// ../../packages/shared/src/limits.ts
+var MAX_DEPLOY_BYTES = 100 * 1024 * 1024;
+var MAX_FILE_BYTES = 25 * 1024 * 1024;
+var MAX_FILES = 5e3;
+var MAX_PATH_LENGTH = 1024;
+
+// ../../packages/shared/src/manifest.ts
+function isValidSitePath(path) {
+  if (!path || path.length > MAX_PATH_LENGTH) return false;
+  if (path.startsWith("/") || path.includes("\\") || path.includes("\0")) return false;
+  return path.split("/").every((seg) => seg !== "" && seg !== "." && seg !== "..");
+}
+var ManifestFileSchema = z.object({
+  path: z.string().refine(isValidSitePath, "invalid path"),
+  sha256: z.string().regex(/^[a-f0-9]{64}$/),
+  size: z.number().int().min(0).max(MAX_FILE_BYTES),
+  contentType: z.string().min(1).max(255)
+});
+var ManifestSchema = z.object({ files: z.array(ManifestFileSchema).min(1).max(MAX_FILES) }).refine((m) => new Set(m.files.map((f) => f.path)).size === m.files.length, "duplicate paths").refine((m) => m.files.reduce((n, f) => n + f.size, 0) <= MAX_DEPLOY_BYTES, "deploy too large");
+
+// ../../packages/shared/src/api.ts
+var VisibilitySchema = z2.enum(["private", "public"]);
+var MeSchema = z2.object({
+  email: z2.string(),
+  name: z2.string(),
+  picture: z2.string().nullable(),
+  userSlug: z2.string()
+});
+var SiteSchema = z2.object({
+  name: z2.string(),
+  url: z2.string(),
+  visibility: VisibilitySchema,
+  spa: z2.boolean(),
+  archived: z2.boolean(),
+  currentVersionId: z2.string().nullable(),
+  shareUrl: z2.string().nullable(),
+  createdAt: z2.string(),
+  updatedAt: z2.string()
+});
+var VersionSchema = z2.object({
+  id: z2.string(),
+  fileCount: z2.number(),
+  totalBytes: z2.number(),
+  createdAt: z2.string()
+});
+var SiteDetailSchema = SiteSchema.extend({ versions: z2.array(VersionSchema) });
+var SiteListSchema = z2.object({ sites: z2.array(SiteSchema) });
+var SiteFileSchema = z2.object({
+  path: z2.string(),
+  size: z2.number(),
+  contentType: z2.string()
+});
+var VersionFilesSchema = z2.object({
+  versionId: z2.string(),
+  files: z2.array(SiteFileSchema),
+  totalBytes: z2.number(),
+  generatedIndex: z2.boolean()
+});
+var NameCheckSchema = z2.object({
+  name: z2.string(),
+  status: z2.enum(["available", "yours", "taken", "invalid"]),
+  suggestions: z2.array(z2.string())
+});
+var DeployRequestSchema = z2.object({
+  manifest: ManifestSchema,
+  spa: z2.boolean().optional(),
+  visibility: VisibilitySchema.optional()
+});
+var UploadSchema = z2.object({
+  path: z2.string(),
+  url: z2.string(),
+  /** headers the client must send with the PUT (they are part of the signature) */
+  headers: z2.record(z2.string(), z2.string())
+});
+var DeployResponseSchema = z2.discriminatedUnion("status", [
+  /** content identical to the current version — nothing happened */
+  z2.object({ status: z2.literal("unchanged"), versionId: z2.string(), site: SiteSchema }),
+  /** this content was deployed before — site now points at that version again */
+  z2.object({ status: z2.literal("repointed"), versionId: z2.string(), site: SiteSchema }),
+  /** new content — PUT every upload, then POST /api/sites/:name/deploys/:versionId/finalize */
+  z2.object({
+    status: z2.literal("upload"),
+    versionId: z2.string(),
+    uploads: z2.array(UploadSchema)
+  })
+]);
+var FinalizeResponseSchema = z2.object({
+  status: z2.literal("live"),
+  versionId: z2.string(),
+  site: SiteSchema
+});
+var RollbackRequestSchema = z2.object({ versionId: z2.string() });
+var UpdateSiteRequestSchema = z2.object({
+  visibility: VisibilitySchema.optional(),
+  spa: z2.boolean().optional()
+});
+var ApiKeySchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  createdAt: z2.string(),
+  lastUsedAt: z2.string().nullable()
+});
+var ApiKeyListSchema = z2.object({ keys: z2.array(ApiKeySchema) });
+var ErrorEnvelopeSchema = z2.object({
+  error: z2.object({ code: z2.string(), message: z2.string() })
+});
+var ShareResponseSchema = z2.object({ shareUrl: z2.string() });
+var ConnectionSchema = z2.object({
+  id: z2.string(),
+  clientName: z2.string(),
+  /** host the client identifies as (CIMD client_id host or redirect URI host) */
+  clientHost: z2.string().nullable(),
+  createdAt: z2.string(),
+  lastUsedAt: z2.string().nullable()
+});
+var ConnectionListSchema = z2.object({ connections: z2.array(ConnectionSchema) });
+var OAuthRequestInfoSchema = z2.object({
+  clientName: z2.string(),
+  clientUri: z2.string().nullable(),
+  /** host of the CIMD client_id URL, when the client identified itself that way */
+  clientIdHost: z2.string().nullable(),
+  redirectHost: z2.string(),
+  /** true when the code goes to a loopback address (any local program could be asking) */
+  loopback: z2.boolean(),
+  scopes: z2.array(z2.string()),
+  email: z2.string()
+});
+var OAuthDecisionSchema = z2.object({ redirectUrl: z2.string() });
+
+// ../../packages/shared/src/hosts.ts
+var SITE_NAME_MAX = 50;
+var SHARE_TOKEN_LENGTH = 20;
+var RESERVED_SITE_NAMES = [
+  "admin",
+  "api",
+  "app",
+  "assets",
+  "auth",
+  "cdn",
+  "docs-fling",
+  "fling",
+  "help",
+  "login",
+  "mail",
+  "static",
+  "status",
+  "www"
+];
+var SLUG_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SHARE_TOKEN_RE = new RegExp(`^[a-z0-9]{${SHARE_TOKEN_LENGTH}}$`);
+function slugify(input, max = SITE_NAME_MAX) {
+  return input.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/g, "");
+}
+function isValidSiteName(name) {
+  return name.length <= SITE_NAME_MAX && SLUG_RE.test(name) && !name.includes("--") && !RESERVED_SITE_NAMES.includes(name);
+}
+function siteUrl(label, sitesDomain, protocol = "https:") {
+  return `${protocol}//${label}.${sitesDomain}/`;
+}
+
+// ../../packages/shared/src/kvs.ts
+import { z as z3 } from "zod";
+var KvsSiteValueSchema = z3.object({
+  /** siteId — S3 prefix is `sites/<id>/<v>/` */
+  id: z3.string(),
+  /** current versionId */
+  v: z3.string(),
+  vis: z3.enum(["private", "public"]),
+  /** serve /index.html for unknown extensionless paths */
+  spa: z3.boolean()
+});
+
+// ../../packages/shared/src/listing.ts
+var LISTING_GENERATOR_META = "fling-listing";
+var escapeHtml = (s) => s.replace(
+  /[&<>"']/g,
+  (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]
+);
+var hrefFor = (path) => path.split("/").map(encodeURIComponent).join("/");
+function isHtmlPath(path) {
+  return /\.html?$/i.test(path);
+}
+function extractHtmlTitle(html) {
+  const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html.slice(0, 65536));
+  const title = match?.[1]?.replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
+  return title ? title : null;
+}
+function renderHtmlListing(siteName2, entries) {
+  const pages = entries.filter((e) => isHtmlPath(e.path) && e.path.toLowerCase() !== "index.html").sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  const groups = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const slash = page.path.lastIndexOf("/");
+    const folder = slash === -1 ? "" : page.path.slice(0, slash);
+    groups.set(folder, [...groups.get(folder) ?? [], page]);
+  }
+  const sections = [...groups.entries()].sort(([a], [b]) => a === "" ? -1 : b === "" ? 1 : a < b ? -1 : 1).map(([folder, items]) => {
+    const heading = folder ? `<h2>${escapeHtml(folder)}/</h2>` : "";
+    const rows = items.map((item) => {
+      const file = item.path.slice(item.path.lastIndexOf("/") + 1);
+      const label = item.title ? escapeHtml(item.title) : escapeHtml(file);
+      const sub = item.title ? `<span class="file">${escapeHtml(file)}</span>` : "";
+      return `<li><a href="${hrefFor(item.path)}">${label}</a>${sub}</li>`;
+    }).join("\n");
+    return `${heading}<ul>
+${rows}
+</ul>`;
+  }).join("\n");
+  const body = pages.length ? sections : '<p class="empty">No HTML pages in this fling.</p>';
+  const count = `${pages.length} page${pages.length === 1 ? "" : "s"}`;
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="generator" content="${LISTING_GENERATOR_META}">
+<title>${escapeHtml(siteName2)}</title>
+<style>
+  :root { color-scheme: light dark; --fg: #000e38; --muted: #5b6480; --bg: #f7f8fb; --card: #fff;
+    --line: #e3e6ef; --accent: #166bff; --green: #00e5a4; }
+  @media (prefers-color-scheme: dark) { :root { --fg: #eef1f8; --muted: #9aa3bd; --bg: #000e38;
+    --card: #0b1a4a; --line: #1d2c5e; --accent: #6ea2ff; } }
+  * { box-sizing: border-box; }
+  body { margin: 0; font: 16px/1.5 Inter, ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif;
+    color: var(--fg); background: var(--bg); }
+  main { max-width: 760px; margin: 0 auto; padding: 48px 20px 64px; }
+  header { border-left: 4px solid var(--green); padding-left: 14px; margin-bottom: 28px; }
+  h1 { margin: 0; font-size: 1.6rem; }
+  header p, .file, footer { color: var(--muted); font-size: .875rem; }
+  header p { margin: 4px 0 0; }
+  h2 { font-size: .95rem; margin: 28px 0 8px; color: var(--muted); font-weight: 600; }
+  ul { list-style: none; margin: 0; padding: 0; background: var(--card); border: 1px solid var(--line);
+    border-radius: 10px; overflow: hidden; }
+  li { padding: 12px 16px; border-top: 1px solid var(--line); display: flex; gap: 12px;
+    justify-content: space-between; align-items: baseline; flex-wrap: wrap; }
+  li:first-child { border-top: 0; }
+  a { color: var(--accent); text-decoration: none; font-weight: 500; }
+  a:hover { text-decoration: underline; }
+  .empty { color: var(--muted); }
+  footer { margin-top: 40px; }
+</style>
+</head>
+<body>
+<main>
+<header><h1>${escapeHtml(siteName2)}</h1><p>${count}</p></header>
+${body}
+<footer>Flung with Fling</footer>
+</main>
+</body>
+</html>
+`;
+}
+
+// ../../packages/shared/src/mcp-tools.ts
+import { z as z4 } from "zod";
+var MCP_PUBLISH_MAX_BYTES = 4 * 1024 * 1024;
+var MCP_UPLOAD_CHUNK_MAX_CHARS = 4 * 1024 * 1024;
+var MCP_UPLOAD_TTL_SECONDS = 60 * 60;
+var tool = (def) => def;
+var NAME_RULES = `Site names are 1-${SITE_NAME_MAX} chars of lowercase letters, digits and single hyphens, and are one global namespace (first come, first served): the site is served at https://<name>.fling.labs.nearform.com.`;
+var NAME_REQUIRED = 'Publishing needs a name: if the user did not give one, propose a short descriptive one (e.g. "q3-report") and confirm it with them first (fling_check_name tells you whether it is free). If the name is taken by someone else the call fails with free suggestions \u2014 offer those to the user and retry with the one they pick.';
+var VISIBILITY = "Sites are private by default (only signed-in Nearformers can open them); pass `public: true` only if the user asks for a public site. Share links (fling_share) are public to anyone who has them.";
+var INLINE_ONLY = "If you created the content in this conversation, pass it directly \u2014 never pass file paths from your sandbox (this server cannot read them) and never try to curl/upload from your sandbox.";
+var ENCODING = '`encoding` is "utf8" (default, for text: HTML, CSS, JS, SVG, JSON, Markdown\u2026) or "base64" (binary: images, fonts, PDFs).';
+var LIST_HTML = "If the files have no root index.html but do include HTML pages, the call does not publish: it reports how many HTML pages there are and asks you to check with the user. Ask them whether to generate an index.html listing those pages (retry with `listHtml: true`) or to publish without one (`listHtml: false` \u2014 the site root will 404, the pages still work at their own paths), then retry.";
+var listHtml = z4.boolean().optional().describe(
+  "Only matters when there is no root index.html: true \u2192 generate an index.html linking every HTML page; false \u2192 publish without one (root 404s). Omit until the user has decided"
+);
+var siteName = z4.string().min(1).max(200).describe('Site name, e.g. "q3-report"');
+var sitePath = z4.string().min(1).max(1024).describe(
+  'Site-relative path with forward slashes, e.g. "index.html", "css/app.css", "img/logo.png". The root page must be "index.html".'
+);
+var encoding = z4.enum(["utf8", "base64"]).optional().describe('How `content` is encoded: "utf8" (default) for text, "base64" for binary files');
+var spa = z4.boolean().optional().describe(
+  "Single-page app: serve index.html for unknown paths (client-side routing). Omit to keep the current setting"
+);
+var isPublic = z4.boolean().optional().describe(
+  "true \u2192 anyone can view; false \u2192 Nearformers only. Omit to keep the current setting (new sites are private)"
+);
+var mcpTools = {
+  whoami: tool({
+    name: "fling_whoami",
+    title: "Who am I",
+    description: "Show the signed-in Nearform user that Fling acts as.",
+    inputSchema: {},
+    annotations: { readOnlyHint: true, openWorldHint: false }
+  }),
+  list: tool({
+    name: "fling_list",
+    title: "List sites",
+    description: "List the user's Fling sites with URL, visibility and share link.",
+    inputSchema: {
+      archived: z4.boolean().optional().describe("List archived sites instead of live ones")
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false }
+  }),
+  info: tool({
+    name: "fling_info",
+    title: "Site details",
+    description: "Show one site: URL, visibility, share link, current version and version history (ids for fling_rollback).",
+    inputSchema: { name: siteName },
+    annotations: { readOnlyHint: true, openWorldHint: false }
+  }),
+  files: tool({
+    name: "fling_files",
+    title: "List site files",
+    description: "List the files in a site's current version (or in `versionId`, from fling_info): path, size and content type, sorted by path. Use it to check what was actually published \u2014 e.g. when the user sees a 404, confirm the page exists at that path and that there is a root index.html (without one the site root 404s).",
+    inputSchema: {
+      name: siteName,
+      versionId: z4.string().min(1).max(100).optional().describe("Version id (from fling_info); omit for the version being served")
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false }
+  }),
+  checkName: tool({
+    name: "fling_check_name",
+    title: "Check a site name",
+    description: "Check whether a site name can be used before publishing: `available` (a new site), `yours` (publishing updates the user's existing site), `taken` (someone else's \u2014 free `suggestions` are returned) or `invalid`. " + NAME_RULES,
+    inputSchema: { name: z4.string().min(1).max(200).describe("Site name to check") },
+    annotations: { readOnlyHint: true, openWorldHint: false }
+  }),
+  publish: tool({
+    name: "fling_publish",
+    title: "Publish a site",
+    description: `Publish a static site to Fling in one call and get back its URL. Pass every file of the site inline in \`files\` (whole site, up to ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB decoded in total; bigger sites: fling_upload_begin / fling_upload_file / fling_upload_finish). ${INLINE_ONLY} ${ENCODING} Publishing replaces the whole site with exactly these files (it is not a patch: include unchanged files too); publishing identical content again is a no-op. ${NAME_REQUIRED} ${NAME_RULES} ${VISIBILITY} ${LIST_HTML} The result includes \`warnings\`. Share the returned URL with the user; fling_files shows exactly which files the site has.`,
+    inputSchema: {
+      name: siteName,
+      files: z4.array(
+        z4.object({
+          path: sitePath,
+          content: z4.string().describe("The file content, encoded as `encoding` says"),
+          encoding
+        })
+      ).min(1).max(MAX_FILES).describe("Every file of the site"),
+      spa,
+      public: isPublic,
+      listHtml
+    },
+    annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
+  }),
+  uploadBegin: tool({
+    name: "fling_upload_begin",
+    title: "Start a chunked upload",
+    description: `Start publishing a site too big for one fling_publish call (over ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB, or large binary files). Returns an \`uploadId\`; then send each file with fling_upload_file and finish with fling_upload_finish within ${MCP_UPLOAD_TTL_SECONDS / 60} minutes. ${INLINE_ONLY} ${NAME_REQUIRED} ${VISIBILITY}`,
+    inputSchema: { name: siteName, spa, public: isPublic },
+    annotations: { destructiveHint: false, openWorldHint: false }
+  }),
+  uploadFile: tool({
+    name: "fling_upload_file",
+    title: "Upload a file (chunked)",
+    description: `Add one file to a chunked upload started with fling_upload_begin. Sending the same path again replaces it. A file larger than ${MCP_UPLOAD_CHUNK_MAX_CHARS / 1024 / 1024} MB of content can span calls: send the first part normally, then the following parts in order with \`append: true\` (same path and encoding; send appends one at a time, not in parallel). ${ENCODING}`,
+    inputSchema: {
+      uploadId: z4.string().min(1).max(100).describe("From fling_upload_begin"),
+      path: sitePath,
+      content: z4.string().max(MCP_UPLOAD_CHUNK_MAX_CHARS).describe("The file content (or the next part of it, with `append`)"),
+      encoding,
+      append: z4.boolean().optional().describe("Append this content to the file sent earlier with the same path")
+    },
+    annotations: { destructiveHint: false, openWorldHint: false }
+  }),
+  uploadFinish: tool({
+    name: "fling_upload_finish",
+    title: "Finish a chunked upload",
+    description: `Publish everything sent with fling_upload_file as the new version of the site and return its URL. The site becomes exactly the uploaded files. ${LIST_HTML} The upload stays open, so just call fling_upload_finish again with \`listHtml\`. The result includes \`warnings\`.`,
+    inputSchema: {
+      uploadId: z4.string().min(1).max(100).describe("From fling_upload_begin"),
+      listHtml
+    },
+    annotations: { destructiveHint: false, openWorldHint: true }
+  }),
+  share: tool({
+    name: "fling_share",
+    title: "Share link",
+    description: "Get or create a public share link for a site: anyone with the link can view it without signing in (use it to show a private site to someone outside Nearform). `refresh` replaces the link (the old one stops working); `revoke` removes it.",
+    inputSchema: {
+      name: siteName,
+      refresh: z4.boolean().optional().describe("Rotate the link"),
+      revoke: z4.boolean().optional().describe("Remove the link")
+    },
+    annotations: { destructiveHint: false, openWorldHint: true }
+  }),
+  setVisibility: tool({
+    name: "fling_set_visibility",
+    title: "Set visibility",
+    description: "Make a site private (signed-in Nearformers only) or public (anyone).",
+    inputSchema: { name: siteName, visibility: z4.enum(["private", "public"]) },
+    annotations: { idempotentHint: true, openWorldHint: true }
+  }),
+  archive: tool({
+    name: "fling_archive",
+    title: "Archive or restore a site",
+    description: "Archive a site (it stops being served and is hidden from lists, but its name, files and versions are kept) or, with `unarchive`, bring it back. Prefer this over deleting.",
+    inputSchema: {
+      name: siteName,
+      unarchive: z4.boolean().optional().describe("Restore an archived site")
+    },
+    annotations: { idempotentHint: true, openWorldHint: false }
+  }),
+  delete: tool({
+    name: "fling_delete",
+    title: "Delete a site",
+    description: "Permanently delete a site and every version of it, freeing its name. Cannot be undone \u2014 confirm with the user first and pass `confirm: true`. Consider fling_archive instead.",
+    inputSchema: {
+      name: siteName,
+      confirm: z4.literal(true).describe("Must be true: the user has confirmed the deletion")
+    },
+    annotations: { destructiveHint: true, openWorldHint: false }
+  }),
+  rollback: tool({
+    name: "fling_rollback",
+    title: "Roll back",
+    description: "Point a site at an earlier version (ids from fling_info). Instant; nothing is uploaded.",
+    inputSchema: {
+      name: siteName,
+      versionId: z4.string().min(1).max(100).describe("Version id to serve")
+    },
+    annotations: { idempotentHint: true, openWorldHint: false }
+  })
+};
+var MCP_REMOTE_INSTRUCTIONS = [
+  "Fling publishes static sites (HTML/CSS/JS, images, documents) for Nearform staff at https://<name>.fling.labs.nearform.com.",
+  "To publish content you created in this conversation (an HTML page, a report, a small app): call fling_publish with every file inline (text as utf8, binary as base64). This server cannot read files in your sandbox and your sandbox cannot reach Fling, so never pass sandbox file paths and never curl or upload from the sandbox. Make the site self-contained: an index.html at the root, relative links between files.",
+  "Every site needs a name. If the user did not give one, propose a short descriptive name and confirm it before publishing (fling_check_name shows whether it is free). Names are global and first come, first served; when a name is taken, offer the returned suggestions.",
+  "Sites are private (Nearformers only) by default. Only make one public if asked; to show a private site to someone outside Nearform, create a share link with fling_share.",
+  "If a site has HTML pages but no root index.html, fling_publish / fling_upload_finish stop and ask: check with the user whether to generate an index.html listing the pages (`listHtml: true`) or publish without one (`listHtml: false`, the root URL will 404), then retry.",
+  `For sites over ${MCP_PUBLISH_MAX_BYTES / 1024 / 1024} MB use fling_upload_begin, fling_upload_file (repeat, \`append\` for big files) and fling_upload_finish.`,
+  "Always give the user the URL that comes back. Use fling_list / fling_info to find existing sites, fling_rollback to restore a version, fling_archive rather than fling_delete unless the user insists. Use fling_files to see exactly which files a site has (e.g. when the user reports a 404)."
+].join("\n\n");
+var MCP_FILES_LISTED = 200;
+function describeVersionFiles(name, files, opts) {
+  const kb = (n2) => n2 < 1024 ? `${n2} B` : n2 < 1024 * 1024 ? `${(n2 / 1024).toFixed(1)} KB` : `${(n2 / 1024 / 1024).toFixed(1)} MB`;
+  const n = files.files.length;
+  const which = opts.current ? "current version" : "version";
+  const lines = [
+    `${name} ${which} ${files.versionId}: ${n} file${n === 1 ? "" : "s"}, ${kb(files.totalBytes)}` + (opts.current && opts.url ? ` \u2014 served at ${opts.url}` : "") + (opts.current ? "" : " (not the version being served)")
+  ];
+  if (!files.files.some((f) => f.path === "index.html")) {
+    lines.push(
+      "Warning: there is no index.html at the root, so the site root URL returns 404 (each file still works at its own path)."
+    );
+  } else if (files.generatedIndex) {
+    lines.push("index.html is a generated page listing the HTML pages.");
+  }
+  for (const f of files.files.slice(0, MCP_FILES_LISTED)) {
+    lines.push(`- ${f.path} (${kb(f.size)}, ${f.contentType})`);
+  }
+  if (n > MCP_FILES_LISTED) lines.push(`\u2026 and ${n - MCP_FILES_LISTED} more`);
+  return lines.join("\n");
+}
+
+// ../../packages/shared/src/ready.ts
+var READY_TIMEOUT_MS = 15e3;
+var NOT_READY_NOTE = "it can take a few more seconds to appear everywhere; reload if you see a 404";
+var isReachableStatus = (status) => status >= 200 && status < 400 || status === 401 || status === 403;
+var defaultSleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+async function waitUntilReachable(url, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? READY_TIMEOUT_MS;
+  const doFetch = opts.fetch ?? ((u, init) => fetch(u, init));
+  const sleep = opts.sleep ?? defaultSleep;
+  const now = opts.now ?? (() => Date.now());
+  const start = now();
+  let interval = opts.intervalMs ?? 750;
+  let announced = false;
+  for (; ; ) {
+    const remaining = timeoutMs - (now() - start);
+    try {
+      const res = await doFetch(url, {
+        method: "GET",
+        redirect: "manual",
+        cache: "no-store",
+        signal: AbortSignal.timeout(Math.max(250, Math.min(remaining, 5e3)))
+      });
+      await res.body?.cancel().catch(() => {
+      });
+      if (isReachableStatus(res.status)) return { ready: true, waitedMs: now() - start };
+    } catch {
+    }
+    if (!announced) {
+      announced = true;
+      opts.onWaiting?.();
+    }
+    const left = timeoutMs - (now() - start);
+    if (left <= 0) return { ready: false, waitedMs: now() - start };
+    await sleep(Math.min(interval, left));
+    interval = Math.min(interval * 1.25, 2e3);
+  }
+}
+function probeUrl(siteUrl2, paths) {
+  const base = siteUrl2.endsWith("/") ? siteUrl2 : `${siteUrl2}/`;
+  if (paths.length === 0 || paths.includes("index.html")) return base;
+  const pick = paths.find((p) => /\.html?$/i.test(p)) ?? paths[0];
+  return base + pick.split("/").map(encodeURIComponent).join("/");
+}
+function readinessWaitDisabled(env) {
+  return env.FLING_NO_WAIT === "1" || env.VITEST === "true" || env.NODE_ENV === "test";
+}
+
+// src/errors.ts
+var EXIT_ERROR = 1;
+var EXIT_NOT_LOGGED_IN = 2;
+var EXIT_FORBIDDEN = 3;
+var CliError = class extends Error {
+  exitCode;
+  /** Extra dimmed line printed under the error (e.g. "run `fling login`"). */
+  hint;
+  constructor(message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "CliError";
+    this.exitCode = options.exitCode ?? EXIT_ERROR;
+    this.hint = options.hint;
+  }
+};
+var NotLoggedInError = class extends CliError {
+  constructor(binName) {
+    super("Not logged in", {
+      exitCode: EXIT_NOT_LOGGED_IN,
+      hint: `Run \`${binName} login\` first.`
+    });
+    this.name = "NotLoggedInError";
+  }
+};
+function exitCodeFor(error) {
+  return error instanceof CliError ? error.exitCode : EXIT_ERROR;
+}
+
+// package.json
+var package_default = {
+  name: "@nearform/fling",
+  version: "0.1.0",
+  license: "MIT",
+  description: "Fling a folder of static files at fling.labs.nearform.com and get a link back. CLI + MCP server.",
+  type: "module",
+  bin: {
+    fling: "./dist/cli.js"
+  },
+  files: [
+    "dist/cli.js",
+    "dist/cli.js.map",
+    "README.md"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/nearform/fling.git",
+    directory: "apps/cli"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    dev: "tsx src/cli.ts",
+    build: "node scripts/build.mjs",
+    "build:mcpb": "node scripts/build.mjs && node scripts/build-mcpb.mjs",
+    typecheck: "tsc --noEmit",
+    test: "vitest run"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.20.0",
+    chalk: "^5.6.2",
+    commander: "^15.0.0",
+    fflate: "^0.8.3",
+    ignore: "^7.0.5",
+    mime: "^4.1.0",
+    open: "^11.0.0",
+    zod: "^4.6.7"
+  },
+  devDependencies: {
+    "@fling/shared": "workspace:*",
+    "@types/node": "^24.0.0",
+    esbuild: "^0.25.12",
+    tsx: "^4.23.13",
+    typescript: "^5.9.3",
+    vitest: "^3.2.7"
+  }
+};
+
+// src/package-info.ts
+var PACKAGE_NAME = package_default.name;
+var VERSION = package_default.version;
+var BIN_NAME = Object.keys(package_default.bin)[0] ?? "fling";
+var NPX_COMMAND = `npx ${package_default.name}`;
+
+// src/api.ts
+var CliApiError = class extends CliError {
+  status;
+  code;
+  body;
+  constructor(options) {
+    super(options.message, {
+      exitCode: exitCodeForStatus(options.status),
+      hint: options.hint ?? defaultHint(options.status),
+      cause: options.cause
+    });
+    this.name = "CliApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.body = options.body;
+  }
+};
+function exitCodeForStatus(status) {
+  if (status === 401) return EXIT_NOT_LOGGED_IN;
+  if (status === 403) return EXIT_FORBIDDEN;
+  return EXIT_ERROR;
+}
+function defaultHint(status) {
+  if (status === 401) return `Run \`${BIN_NAME} login\` to authenticate.`;
+  if (status === 403) return "You are not allowed to do that.";
+  return void 0;
+}
+function buildUrl(serverUrl, path, query) {
+  const url = new URL(`${serverUrl.replace(/\/+$/, "")}${path.startsWith("/") ? path : `/${path}`}`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function createApiClient(options) {
+  const serverUrl = options.serverUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  async function request(method, path, reqOptions = {}) {
+    const url = buildUrl(serverUrl, path, reqOptions.query);
+    const headers = {
+      Accept: "application/json",
+      "User-Agent": `${BIN_NAME}-cli/${VERSION}`
+    };
+    if (options.apiKey) headers.Authorization = `Bearer ${options.apiKey}`;
+    if (reqOptions.body !== void 0) headers["Content-Type"] = "application/json";
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method,
+        headers,
+        body: reqOptions.body === void 0 ? void 0 : JSON.stringify(reqOptions.body),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (cause) {
+      throw new CliApiError({
+        status: 0,
+        code: "network_error",
+        message: `Could not reach ${serverUrl} (${describeCause(cause)})`,
+        hint: "Check your connection, or the URL given by `--server` / `FLING_URL`.",
+        cause
+      });
+    }
+    const raw = await readBody(response);
+    if (!response.ok) throw errorFromResponse(response.status, raw, method, path);
+    if (!reqOptions.schema) return raw;
+    const parsed = reqOptions.schema.safeParse(raw);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      const where = issue?.path.length ? ` at ${issue.path.join(".")}` : "";
+      throw new CliApiError({
+        status: response.status,
+        code: "invalid_response",
+        body: raw,
+        message: `Unexpected response from ${method} ${path}${where}: ${issue?.message ?? "invalid"}`,
+        hint: `Your ${BIN_NAME} CLI may be out of date \u2014 try \`npm i -g @nearform/fling@latest\`.`
+      });
+    }
+    return parsed.data;
+  }
+  return { serverUrl, request };
+}
+var UploadError = class extends Error {
+  constructor(message, retryable) {
+    super(message);
+    this.retryable = retryable;
+    this.name = "UploadError";
+  }
+};
+async function putUpload(fetchImpl, url, headers, body, timeoutMs = 5 * 6e4) {
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: "PUT",
+      headers,
+      body,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    throw new UploadError(`network error (${describeCause(cause)})`, true);
+  }
+  await response.text().catch(() => "");
+  if (response.ok) return;
+  const retryable = response.status >= 500 || response.status === 408 || response.status === 429;
+  throw new UploadError(`HTTP ${response.status}`, retryable);
+}
+async function readBody(response) {
+  if (response.status === 204) return void 0;
+  const text = await response.text();
+  if (text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function errorFromResponse(status, body, method, path) {
+  const envelope = ErrorEnvelopeSchema.safeParse(body);
+  if (envelope.success) {
+    return new CliApiError({
+      status,
+      code: envelope.data.error.code,
+      body,
+      message: envelope.data.error.message
+    });
+  }
+  return new CliApiError({ status, body, message: `${method} ${path} failed with HTTP ${status}` });
+}
+function describeCause(cause) {
+  if (cause instanceof Error) {
+    const inner = cause.cause;
+    if (inner instanceof Error && "code" in inner) return String(inner.code);
+    if (cause.name === "TimeoutError") return "timed out";
+    return cause.message;
+  }
+  return String(cause);
+}
+
+// src/config.ts
+import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z as z5 } from "zod";
+var CONFIG_DIR_NAME = ".fling";
+var CONFIG_FILE_NAME = "config.json";
+var DEFAULT_SERVER_URL = "https://fling.labs.nearform.com";
+var ENV = {
+  apiKey: "FLING_API_KEY",
+  url: "FLING_URL",
+  configDir: "FLING_CONFIG_DIR",
+  debug: "FLING_DEBUG",
+  /** Where to look for files given by name (the .mcpb extension sets it from its settings). */
+  downloadsDir: "FLING_DOWNLOADS_DIR"
+};
+var cliConfigSchema = z5.object({
+  serverUrl: z5.string().url().optional(),
+  apiKey: z5.string().min(1).optional(),
+  user: z5.object({
+    email: z5.string().optional(),
+    name: z5.string().optional(),
+    userSlug: z5.string().optional()
+  }).optional()
+});
+function systemLocateOptions(env = process.env) {
+  return { cwd: process.cwd(), home: homedir(), platform: process.platform, env };
+}
+function fromEnv(value) {
+  const v = value?.trim();
+  return v && !v.startsWith("${") ? v : void 0;
+}
+function resolveConfigDir(env = process.env) {
+  return env[ENV.configDir] ?? join(env.HOME ?? homedir(), CONFIG_DIR_NAME);
+}
+function createConfigStore(options = {}) {
+  const env = options.env ?? process.env;
+  const dir = options.dir ?? resolveConfigDir(env);
+  const file = join(dir, CONFIG_FILE_NAME);
+  async function load() {
+    let raw;
+    try {
+      raw = await readFile(file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return {};
+      throw error;
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch {
+      throw new Error(`Config file ${file} is not valid JSON`);
+    }
+    const parsed = cliConfigSchema.safeParse(json);
+    if (!parsed.success) {
+      throw new Error(`Config file ${file} is invalid: ${parsed.error.issues[0]?.message}`);
+    }
+    return parsed.data;
+  }
+  async function save(config) {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    await chmod(dir, 448).catch(() => {
+    });
+    await writeFile(file, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+    await chmod(file, 384);
+  }
+  return {
+    dir,
+    file,
+    load,
+    save,
+    async update(patch) {
+      const next = { ...await load(), ...patch };
+      await save(next);
+      return next;
+    },
+    async clearCredentials() {
+      const { serverUrl } = await load();
+      await save(serverUrl ? { serverUrl } : {});
+    },
+    async resolve(overrides = {}) {
+      const config = await load();
+      const envUrl = fromEnv(env[ENV.url]);
+      const envKey = fromEnv(env[ENV.apiKey]);
+      const [serverUrl, serverUrlSource] = overrides.serverUrl ? [overrides.serverUrl, "flag"] : envUrl ? [envUrl, "env"] : config.serverUrl ? [config.serverUrl, "config"] : [DEFAULT_SERVER_URL, "default"];
+      const [apiKey, apiKeySource] = envKey ? [envKey, "env"] : config.apiKey ? [config.apiKey, "config"] : [void 0, "none"];
+      return {
+        serverUrl: serverUrl.replace(/\/+$/, ""),
+        serverUrlSource,
+        apiKey,
+        apiKeySource,
+        user: config.user,
+        debug: Boolean(env[ENV.debug])
+      };
+    }
+  };
+}
+var REDACTED_KEY_CHARS = 10;
+function redactKey(key) {
+  if (!key) return "-";
+  return key.length <= REDACTED_KEY_CHARS + 8 ? "****" : `${key.slice(0, REDACTED_KEY_CHARS)}\u2026`;
+}
+
+// src/auth.ts
+var CALLBACK_PORT_START = 8765;
+var CALLBACK_PORT_END = 8770;
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+var CALLBACK_PATH = "/callback";
+var AUTH_CLI_PATH = "/auth/cli";
+async function loginFlow(options) {
+  const { serverUrl, store, log } = options;
+  const state = randomBytes(16).toString("hex");
+  const callback = await startCallbackServer({ state, timeoutMs: options.timeoutMs });
+  try {
+    const authUrl = buildAuthUrl(serverUrl, callback.url, options.hostname ?? osHostname(), state);
+    options.onAuthUrl?.(authUrl);
+    log.info(`Opening your browser to sign in at ${serverUrl}`);
+    log.hint(`If it does not open, visit: ${authUrl}`);
+    try {
+      await options.open(authUrl);
+    } catch (error) {
+      log.warn(`Could not open a browser (${error.message}); open the URL above.`);
+    }
+    log.info("Waiting for the browser to complete sign-in (5-minute timeout)\u2026");
+    const { key } = await callback.result;
+    const client = createApiClient({ serverUrl, apiKey: key, fetch: options.fetch });
+    const user = await client.request("GET", "/api/me", { schema: MeSchema });
+    await store.update({
+      serverUrl,
+      apiKey: key,
+      user: { email: user.email, name: user.name, userSlug: user.userSlug }
+    });
+    const keyPrefix = redactKey(key);
+    log.success(`Signed in as ${user.email}`);
+    log.hint(`Server: ${serverUrl}`);
+    log.hint(`API key: ${keyPrefix} (stored in ${store.file})`);
+    return { serverUrl, keyPrefix, user };
+  } finally {
+    callback.close();
+  }
+}
+function buildAuthUrl(serverUrl, callbackUrl, hostname, state) {
+  const url = new URL(AUTH_CLI_PATH, `${serverUrl.replace(/\/+$/, "")}/`);
+  url.searchParams.set("redirect_uri", callbackUrl);
+  url.searchParams.set("hostname", hostname);
+  url.searchParams.set("state", state);
+  return url.toString();
+}
+function parseCallback(url, expectedState) {
+  const error = url.searchParams.get("error");
+  if (error) return { ok: false, message: `Sign-in failed: ${error}` };
+  const state = url.searchParams.get("state");
+  if (state !== null && expectedState !== void 0 && state !== expectedState) {
+    return {
+      ok: false,
+      message: "Sign-in failed: state mismatch (the callback was not for this login)"
+    };
+  }
+  const key = url.searchParams.get("key");
+  if (!key) return { ok: false, message: "Callback missing required parameter: key" };
+  return { ok: true, key };
+}
+async function startCallbackServer(options = {}) {
+  const timeoutMs = options.timeoutMs ?? LOGIN_TIMEOUT_MS;
+  let settle;
+  let timer;
+  const result = new Promise((resolve3, reject) => {
+    settle = { resolve: resolve3, reject };
+  }).finally(() => clearTimeout(timer));
+  result.catch(() => {
+  });
+  const server = createServer((req, res) => handleCallback(req, res, port, options.state, settle));
+  const port = await listenOnFreePort(server);
+  timer = setTimeout(() => {
+    settle?.reject(
+      new CliError(
+        `Timed out after ${Math.round(timeoutMs / 6e4) || 1} minute(s) waiting for the browser`,
+        { hint: `Run \`${BIN_NAME} login\` again and finish signing in within 5 minutes.` }
+      )
+    );
+  }, timeoutMs);
+  return {
+    port,
+    url: `http://127.0.0.1:${port}${CALLBACK_PATH}`,
+    result,
+    close: () => {
+      clearTimeout(timer);
+      server.close();
+      server.closeAllConnections?.();
+    }
+  };
+}
+function handleCallback(req, res, port, expectedState, settle) {
+  const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+  if (url.pathname !== CALLBACK_PATH) {
+    res.writeHead(404, { "Content-Type": "text/plain" }).end("Not found");
+    return;
+  }
+  const parsed = parseCallback(url, expectedState);
+  if (!parsed.ok) {
+    respondHtml(
+      res,
+      400,
+      "Sign-in failed",
+      `${escapeHtml2(parsed.message)}. Return to the terminal and try again.`
+    );
+    settle?.reject(
+      new CliError(parsed.message, { hint: `Run \`${BIN_NAME} login\` to try again.` })
+    );
+    return;
+  }
+  respondHtml(res, 200, "Signed in", "You can close this tab and return to the terminal.", true);
+  settle?.resolve({ key: parsed.key });
+}
+function respondHtml(res, status, title, body, close = false) {
+  const html = `<!doctype html><html><head><meta charset="utf-8"><title>Fling \u2014 ${title}</title></head>
+<body style="font-family:system-ui,sans-serif;padding:48px;text-align:center;color:#111">
+<h1 style="font-size:1.5rem">${title}</h1><p>${body}</p>
+${close ? "<script>setTimeout(function(){window.close()},800)</script>" : ""}
+</body></html>`;
+  res.writeHead(status, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Cache-Control": "no-store",
+    Connection: "close"
+  });
+  res.end(html);
+}
+function listenOnFreePort(server) {
+  return new Promise((resolve3, reject) => {
+    let port = CALLBACK_PORT_START;
+    const tryNext = () => {
+      if (port > CALLBACK_PORT_END) {
+        reject(
+          new CliError(
+            `No free port in ${CALLBACK_PORT_START}\u2013${CALLBACK_PORT_END} for the login callback`,
+            {
+              hint: "Another login may be in progress; close it or free one of those ports."
+            }
+          )
+        );
+        return;
+      }
+      server.once("error", (error) => {
+        if (error.code === "EADDRINUSE" || error.code === "EACCES") {
+          port += 1;
+          tryNext();
+        } else reject(error);
+      });
+      server.listen(port, "127.0.0.1", () => {
+        server.removeAllListeners("error");
+        resolve3(port);
+      });
+    };
+    tryNext();
+  });
+}
+function escapeHtml2(text) {
+  return text.replace(/[&<>"']/g, (ch) => `&#${ch.charCodeAt(0)};`);
+}
+
+// src/context.ts
+import { createInterface } from "node:readline/promises";
+
+// src/ready.ts
+import chalk from "chalk";
+var skipWait = async () => ({ ready: true, waitedMs: 0, skipped: true });
+function createReadyWaiter(options = {}) {
+  if (readinessWaitDisabled(options.env ?? process.env)) return skipWait;
+  return (url, paths, opts) => waitUntilReachable(probeUrl(url, paths), {
+    timeoutMs: options.timeoutMs,
+    fetch: options.fetch,
+    onWaiting: opts?.onWaiting
+  });
+}
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+async function waitWithSpinner(waiter, url, paths, io) {
+  if (!waiter) return { ready: true, waitedMs: 0, skipped: true };
+  let frame = 0;
+  let timer;
+  const draw = () => io.progress(`${chalk.cyan(SPINNER[frame++ % SPINNER.length])} Waiting for the edge\u2026`);
+  try {
+    const result = await waiter(url, paths, {
+      onWaiting: () => {
+        draw();
+        timer = setInterval(draw, 100);
+        timer.unref?.();
+      }
+    }).catch(() => ({ ready: false, waitedMs: 0 }));
+    if (timer) io.progress(null);
+    if (!result.ready) io.warn(`${url} \u2014 ${NOT_READY_NOTE}`);
+    return result;
+  } finally {
+    if (timer) clearInterval(timer);
+  }
+}
+
+// src/utils/logger.ts
+import chalk2 from "chalk";
+var PREFIX = chalk2.cyan("fling");
+function createLogger(options = {}) {
+  const write = options.write ?? ((line) => process.stderr.write(`${line}
+`));
+  const debugEnabled = options.debug ?? false;
+  return {
+    info: (message) => write(`${PREFIX} ${message}`),
+    success: (message) => write(`${PREFIX} ${chalk2.green("\u2713")} ${message}`),
+    warn: (message) => write(`${PREFIX} ${chalk2.yellow("!")} ${message}`),
+    error: (message) => write(`${PREFIX} ${chalk2.red("\u2717")} ${message}`),
+    hint: (message) => write(chalk2.dim(`  ${message}`)),
+    debug: (message) => {
+      if (debugEnabled) write(chalk2.dim(`[debug] ${message}`));
+    }
+  };
+}
+var silentLogger = {
+  info: () => {
+  },
+  success: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  hint: () => {
+  },
+  debug: () => {
+  }
+};
+
+// src/utils/output.ts
+import chalk3 from "chalk";
+function createOutput(options = {}) {
+  const json = options.json ?? false;
+  const write = options.write ?? ((chunk) => process.stdout.write(chunk));
+  return {
+    json,
+    data: (raw, human) => write(`${json ? formatJson(raw) : human()}
+`),
+    text: (line) => {
+      if (!json) write(`${line}
+`);
+    }
+  };
+}
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function renderTable(rows, columns) {
+  if (rows.length === 0) return chalk3.dim("(no results)");
+  const cells = rows.map((row) => columns.map((column) => formatCell(column.value(row))));
+  const widths = columns.map(
+    (column, i) => Math.max(column.header.length, ...cells.map((line) => line[i]?.length ?? 0))
+  );
+  const pad = (text, i) => i === columns.length - 1 ? text : text.padEnd(widths[i] ?? 0);
+  const header = columns.map((column, i) => pad(column.header, i)).join("  ");
+  const body = cells.map((line) => line.map(pad).join("  "));
+  return [chalk3.bold(header), ...body].join("\n");
+}
+function formatCell(value) {
+  if (value === null || value === void 0 || value === "") return "-";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function formatDate(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value.toFixed(value < 10 ? 1 : 0)} ${units[unit]}`;
+}
+
+// src/context.ts
+async function createContext(options = {}) {
+  const store = options.store ?? createConfigStore({ env: options.env });
+  const json = options.json ?? false;
+  const config = await store.resolve({ serverUrl: options.server });
+  const interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY);
+  return {
+    store,
+    config,
+    json,
+    log: options.log ?? createLogger({ debug: config.debug }),
+    out: options.out ?? createOutput({ json }),
+    fetch: options.fetch ?? ((input, init) => fetch(input, init)),
+    open: options.open ?? (async (url) => (await import("open")).default(url)),
+    interactive,
+    confirm: ttyConfirm,
+    prompt: ttyPrompt,
+    progress: interactive ? ttyProgress : () => {
+    },
+    binName: BIN_NAME,
+    waitReady: createReadyWaiter({ env: options.env })
+  };
+}
+async function ttyConfirm(question) {
+  const answer = await ttyPrompt(`${question} [y/N] `);
+  return /^y(es)?$/i.test(answer.trim());
+}
+async function ttyPrompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+function ttyProgress(line) {
+  process.stderr.write(`\r\x1B[2K${line ?? ""}`);
+}
+function requireClient(ctx) {
+  if (!ctx.config.apiKey) throw new NotLoggedInError(ctx.binName);
+  return createApiClient({
+    serverUrl: ctx.config.serverUrl,
+    apiKey: ctx.config.apiKey,
+    fetch: ctx.fetch
+  });
+}
+
+// src/sites.ts
+import { z as z6 } from "zod";
+var ShareResponseSchema2 = z6.looseObject({ shareUrl: z6.string() });
+var sitePath2 = (name) => `/api/sites/${encodeURIComponent(name)}`;
+function whoami(client) {
+  return client.request("GET", "/api/me", { schema: MeSchema });
+}
+function checkName(client, name) {
+  return client.request("GET", `/api/names/${encodeURIComponent(name)}`, {
+    schema: NameCheckSchema
+  });
+}
+function sitesBaseFor(serverUrl) {
+  try {
+    const url = new URL(serverUrl);
+    const { hostname } = url;
+    if (url.port || !hostname.includes(".") || /^[\d.]+$/.test(hostname) || hostname.startsWith("["))
+      return null;
+    return { protocol: url.protocol, domain: hostname };
+  } catch {
+    return null;
+  }
+}
+function sitesBaseFromSiteUrl(siteUrl2) {
+  try {
+    const url = new URL(siteUrl2);
+    const dot = url.host.indexOf(".");
+    return dot > 0 ? { protocol: url.protocol, domain: url.host.slice(dot + 1) } : null;
+  } catch {
+    return null;
+  }
+}
+async function discoverSitesBase(client) {
+  const inferred = sitesBaseFor(client.serverUrl);
+  if (inferred) return inferred;
+  const sites = await listSites(client).catch(() => []);
+  const first = sites[0];
+  return first ? sitesBaseFromSiteUrl(first.url) : null;
+}
+function siteUrlFor(name, base) {
+  return siteUrl(name, base.domain, base.protocol);
+}
+function sitesPattern(base) {
+  return base ? siteUrlFor("<name>", base) : "<name>.<sites domain>";
+}
+async function listSites(client, opts = {}) {
+  const res = await client.request("GET", "/api/sites", {
+    schema: SiteListSchema,
+    query: { archived: opts.archived ? 1 : void 0 }
+  });
+  return res.sites;
+}
+function getSite(client, name) {
+  return client.request("GET", sitePath2(name), { schema: SiteDetailSchema });
+}
+async function versionFiles(client, name, versionId) {
+  const site = await getSite(client, name);
+  const id = versionId ?? site.currentVersionId;
+  if (!id) throw new CliError(`${name} has no published version yet`);
+  const files = await client.request(
+    "GET",
+    `${sitePath2(name)}/versions/${encodeURIComponent(id)}/files`,
+    { schema: VersionFilesSchema }
+  );
+  return { name: site.name, url: site.url, current: id === site.currentVersionId, ...files };
+}
+async function siteAfter(client, name, raw) {
+  const parsed = SiteSchema.safeParse(raw);
+  if (parsed.success) return parsed.data;
+  const nested = SiteSchema.safeParse(raw?.site);
+  if (nested.success) return nested.data;
+  return getSite(client, name);
+}
+async function rollback(client, name, versionId) {
+  const raw = await client.request("POST", `${sitePath2(name)}/current`, { body: { versionId } });
+  return siteAfter(client, name, raw);
+}
+async function setVisibility(client, name, visibility) {
+  const raw = await client.request("PATCH", sitePath2(name), { body: { visibility } });
+  return siteAfter(client, name, raw);
+}
+async function archiveSite(client, name, opts = {}) {
+  const raw = await client.request(
+    "POST",
+    `${sitePath2(name)}/${opts.unarchive ? "unarchive" : "archive"}`
+  );
+  return siteAfter(client, name, raw);
+}
+async function deleteSite(client, name) {
+  await client.request("DELETE", sitePath2(name));
+  return { name, deleted: true };
+}
+async function share(client, name, opts = {}) {
+  if (opts.revoke) {
+    await client.request("DELETE", `${sitePath2(name)}/share`);
+    return { name, action: "revoked", shareUrl: null };
+  }
+  let hadLink = false;
+  if (!opts.refresh) {
+    const site = await getSite(client, name);
+    if (site.shareUrl) return { name, action: "existing", shareUrl: site.shareUrl };
+  } else hadLink = true;
+  const res = await client.request("POST", `${sitePath2(name)}/share`, {
+    schema: ShareResponseSchema2
+  });
+  return { name, action: hadLink ? "refreshed" : "created", shareUrl: res.shareUrl };
+}
+
+// src/commands/auth.ts
+async function runLogin(ctx) {
+  const result = await loginFlow({
+    serverUrl: ctx.config.serverUrl,
+    store: ctx.store,
+    log: ctx.log,
+    open: ctx.open,
+    fetch: ctx.fetch
+  });
+  if (ctx.json) ctx.out.data(result, () => "");
+}
+async function runLogout(ctx) {
+  const config = await ctx.store.load();
+  if (!config.apiKey) {
+    ctx.log.info("Not logged in \u2014 nothing to do");
+    return;
+  }
+  await ctx.store.clearCredentials();
+  ctx.log.success("Logged out; API key removed from this machine");
+  ctx.log.hint(`Revoke it on the server under API keys at ${ctx.config.serverUrl}`);
+}
+async function runWhoami(ctx) {
+  const client = requireClient(ctx);
+  const me = await whoami(client);
+  const base = ctx.json ? null : await discoverSitesBase(client);
+  ctx.out.data(
+    {
+      ...me,
+      serverUrl: ctx.config.serverUrl,
+      apiKey: redactKey(ctx.config.apiKey),
+      apiKeySource: ctx.config.apiKeySource
+    },
+    () => [
+      `${chalk4.bold("User:")}    ${me.name} <${me.email}>`,
+      `${chalk4.bold("Sites:")}   ${sitesPattern(base)} ${chalk4.dim("(names are first come, first served)")}`,
+      `${chalk4.bold("Server:")}  ${ctx.config.serverUrl}`,
+      `${chalk4.bold("API key:")} ${redactKey(ctx.config.apiKey)} ${chalk4.dim(`(from ${ctx.config.apiKeySource})`)}`
+    ].join("\n")
+  );
+}
+
+// src/commands/deploy.ts
+import chalk5 from "chalk";
+
+// src/deploy.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// src/manifest.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readdir, readFile as readFile2, realpath, stat as stat2 } from "node:fs/promises";
+import { join as join2, sep } from "node:path";
+import ignore from "ignore";
+import mime from "mime";
+var IGNORE_FILE = ".flingignore";
+var NO_INDEX_WARNING = "No index.html at the top of the folder \u2014 the site root will 404.";
+var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules"]);
+var CHARSET_TYPES = /* @__PURE__ */ new Set([
+  "application/javascript",
+  "application/json",
+  "application/manifest+json",
+  "application/xml",
+  "image/svg+xml"
+]);
+function contentTypeFor(path) {
+  const type = mime.getType(path) ?? "application/octet-stream";
+  return type.startsWith("text/") || CHARSET_TYPES.has(type) ? `${type}; charset=utf-8` : type;
+}
+async function sha256File(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+function toManifest(local) {
+  return {
+    files: local.files.map(({ path, sha256, size, contentType }) => ({
+      path,
+      sha256,
+      size,
+      contentType
+    }))
+  };
+}
+async function buildManifest(dir) {
+  let root;
+  try {
+    root = await realpath(dir);
+  } catch {
+    throw new CliError(`Folder not found: ${dir}`);
+  }
+  if (!(await stat2(root)).isDirectory()) throw new CliError(`Not a folder: ${dir}`);
+  const ig = await loadIgnore(root);
+  const warnings = [];
+  const found = [];
+  const visitedDirs = /* @__PURE__ */ new Set([root]);
+  const inside = (real) => real === root || real.startsWith(root + sep);
+  async function walk2(realDir, relDir) {
+    const entries = await readdir(realDir, { withFileTypes: true });
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || ALWAYS_SKIP.has(entry.name)) continue;
+      const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+      let abs = join2(realDir, entry.name);
+      let isDir = entry.isDirectory();
+      let isFile = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        let target;
+        try {
+          target = await realpath(abs);
+        } catch {
+          warnings.push(`Skipped broken symlink: ${rel}`);
+          continue;
+        }
+        if (!inside(target)) {
+          warnings.push(`Skipped symlink pointing outside the folder: ${rel}`);
+          continue;
+        }
+        const info = await stat2(target);
+        abs = target;
+        isDir = info.isDirectory();
+        isFile = info.isFile();
+      }
+      if (isDir) {
+        if (ig.ignores(`${rel}/`)) continue;
+        if (visitedDirs.has(abs)) continue;
+        visitedDirs.add(abs);
+        await walk2(abs, rel);
+      } else if (isFile) {
+        if (ig.ignores(rel)) continue;
+        const { size } = await stat2(abs);
+        found.push({ path: rel, absPath: abs, size });
+        if (found.length > MAX_FILES) {
+          throw new CliError(`Too many files: more than ${MAX_FILES} in ${dir}`, {
+            hint: `Add a ${IGNORE_FILE} to skip what the site does not need.`
+          });
+        }
+      }
+    }
+  }
+  await walk2(root, "");
+  if (found.length === 0) {
+    throw new CliError(
+      `Nothing to deploy: ${dir} has no files (dotfiles and node_modules are skipped)`
+    );
+  }
+  checkLimits(found, dir);
+  if (!found.some((f) => f.path === "index.html")) {
+    warnings.push(NO_INDEX_WARNING);
+  }
+  const files = await mapLimit(found, 16, async (f) => ({
+    ...f,
+    sha256: await sha256File(f.absPath),
+    contentType: contentTypeFor(f.path)
+  }));
+  return { root, files, totalBytes: files.reduce((n, f) => n + f.size, 0), warnings };
+}
+function checkLimits(files, dir) {
+  for (const f of files) {
+    if (f.path.length > MAX_PATH_LENGTH) {
+      throw new CliError(
+        `Path too long (max ${MAX_PATH_LENGTH} characters): ${f.path.slice(0, 80)}\u2026`
+      );
+    }
+    if (!isValidSitePath(f.path)) throw new CliError(`Unsupported file path: ${f.path}`);
+    if (f.size > MAX_FILE_BYTES) {
+      throw new CliError(
+        `${f.path} is ${formatBytes(f.size)}; the limit is ${formatBytes(MAX_FILE_BYTES)} per file`,
+        { hint: `Add it to ${IGNORE_FILE} if the site does not need it.` }
+      );
+    }
+  }
+  const total = files.reduce((n, f) => n + f.size, 0);
+  if (total > MAX_DEPLOY_BYTES) {
+    throw new CliError(
+      `${dir} is ${formatBytes(total)}; the limit is ${formatBytes(MAX_DEPLOY_BYTES)} per deploy`,
+      { hint: `Add a ${IGNORE_FILE} to skip what the site does not need.` }
+    );
+  }
+}
+var hasRootIndex = (local) => local.files.some((f) => f.path === "index.html");
+var htmlPages = (local) => local.files.filter((f) => isHtmlPath(f.path) && f.path !== "index.html");
+var TITLE_BYTES = 65536;
+async function readHead(file) {
+  if (file.content) return file.content.subarray(0, TITLE_BYTES).toString("utf8");
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of createReadStream(file.absPath, { end: TITLE_BYTES - 1 })) {
+    chunks.push(chunk);
+    size += chunk.length;
+  }
+  return Buffer.concat(chunks, size).toString("utf8");
+}
+async function withHtmlListing(local, siteName2) {
+  const pages = htmlPages(local);
+  const entries = await mapLimit(pages, 16, async (f) => ({
+    path: f.path,
+    title: extractHtmlTitle(await readHead(f))
+  }));
+  const content = Buffer.from(renderHtmlListing(siteName2, entries), "utf8");
+  const index = {
+    path: "index.html",
+    absPath: "",
+    content,
+    sha256: createHash("sha256").update(content).digest("hex"),
+    size: content.length,
+    contentType: contentTypeFor("index.html")
+  };
+  const files = [...local.files.filter((f) => f.path !== "index.html"), index].sort(
+    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+  );
+  return {
+    ...local,
+    files,
+    totalBytes: files.reduce((n, f) => n + f.size, 0),
+    warnings: local.warnings.filter((w) => w !== NO_INDEX_WARNING)
+  };
+}
+async function loadIgnore(root) {
+  const ig = ignore();
+  try {
+    ig.add(await readFile2(join2(root, IGNORE_FILE), "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return ig;
+}
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
+
+// src/naming.ts
+import { existsSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname, isAbsolute, relative, resolve, sep as sep2 } from "node:path";
+var PROJECT_MARKERS = ["package.json", "pyproject.toml", "Cargo.toml", "go.mod"];
+var BUILD_OUTPUT_DIRS = /* @__PURE__ */ new Set([
+  "dist",
+  "build",
+  "out",
+  "output",
+  "public",
+  "www",
+  "_site",
+  "site",
+  "html",
+  "static",
+  "export",
+  "target"
+]);
+var CONTAINER_DIRS = /* @__PURE__ */ new Set([
+  "apps",
+  "packages",
+  "src",
+  "sites",
+  "libs",
+  "projects",
+  "services"
+]);
+var BUILD_SUFFIX_RE = /[-_.](static|dist|build|out|output)$/i;
+var FALLBACK_NAME = "my-site";
+function findProjectRoot(dir, env = {}) {
+  const exists = env.exists ?? existsSync;
+  const home = resolve(env.home ?? homedir2());
+  const candidates = [];
+  for (let d = resolve(dir); d !== home && dirname(d) !== d; d = dirname(d)) candidates.push(d);
+  return candidates.find((d) => exists(`${d}${sep2}.git`)) ?? candidates.find((d) => PROJECT_MARKERS.some((m) => exists(`${d}${sep2}${m}`))) ?? null;
+}
+var isGeneric = (segment) => segment.startsWith(".") || BUILD_OUTPUT_DIRS.has(segment.toLowerCase());
+function nameParts(dir, env = {}) {
+  const abs = resolve(dir);
+  const root = findProjectRoot(abs, env);
+  if (!root) {
+    const fromHome = relative(resolve(env.home ?? homedir2()), abs);
+    if (fromHome === "") return [];
+    const underHome = fromHome && !fromHome.startsWith("..") && !isAbsolute(fromHome);
+    const segments = (underHome ? fromHome : abs).split(sep2).filter(Boolean);
+    const pick = [...segments].reverse().find((s) => !isGeneric(s)) ?? segments.at(-1);
+    return pick ? [pick] : [];
+  }
+  const parts = [basename(root)];
+  const rel = relative(root, abs);
+  for (const raw of rel ? rel.split(sep2) : []) {
+    if (isGeneric(raw) || CONTAINER_DIRS.has(raw.toLowerCase())) continue;
+    const segment = raw.replace(BUILD_SUFFIX_RE, "");
+    const slug = slugify(segment, 200);
+    if (!slug || slug === slugify(parts[0] ?? "", 200)) continue;
+    if (slug === slugify(parts.at(-1) ?? "", 200)) continue;
+    parts.push(segment);
+  }
+  return parts;
+}
+function fitName(parts) {
+  const slugs = parts.map((p) => slugify(p, 200)).filter(Boolean);
+  while (slugs.length > 2 && slugs.join("-").length > SITE_NAME_MAX) slugs.splice(1, 1);
+  let name = slugify(slugs.join("-"));
+  if (!name) return FALLBACK_NAME;
+  if (!isValidSiteName(name)) {
+    name = `${name.slice(0, SITE_NAME_MAX - 5).replace(/-+$/, "")}-site`;
+  }
+  return isValidSiteName(name) ? name : FALLBACK_NAME;
+}
+function defaultSiteName(dir, env = {}) {
+  return fitName(nameParts(dir, env));
+}
+
+// src/deploy.ts
+var NameTakenError = class extends CliError {
+  constructor(siteName2, suggestions, hint) {
+    super(
+      `The site name "${siteName2}" is taken by someone else` + (suggestions.length ? `. Free alternatives: ${suggestions.join(", ")}` : ""),
+      {
+        hint: hint ?? `Pass --name <name> to choose another${suggestions[0] ? `, e.g. --name ${suggestions[0]}` : ""}.`
+      }
+    );
+    this.siteName = siteName2;
+    this.suggestions = suggestions;
+    this.name = "NameTakenError";
+  }
+  code = "name_taken";
+};
+async function nameTakenError(client, name, body) {
+  const raw = body?.error?.suggestions;
+  let suggestions = Array.isArray(raw) ? raw.filter((s) => typeof s === "string") : [];
+  if (suggestions.length === 0) {
+    suggestions = await checkName(client, name).then((c) => c.suggestions).catch(() => []);
+  }
+  return new NameTakenError(name, suggestions);
+}
+var UPLOAD_CONCURRENCY = 8;
+var UPLOAD_RETRIES = 3;
+function resolveSiteName(dir, name) {
+  if (name !== void 0) {
+    if (!isValidSiteName(name)) {
+      throw new CliError(`Invalid site name "${name}"`, {
+        hint: `Use lowercase letters, digits and single hyphens, up to ${SITE_NAME_MAX} characters (e.g. "${slugify(name) || "my-site"}").`
+      });
+    }
+    return name;
+  }
+  const derived = defaultSiteName(dir);
+  if (!isValidSiteName(derived)) {
+    throw new CliError(`Could not derive a site name from "${dir}"`, {
+      hint: "Pass --name <name>."
+    });
+  }
+  return derived;
+}
+var defaultSleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function deploy(deps, opts) {
+  const name = resolveSiteName(opts.dir, opts.name);
+  const local = opts.manifest ?? await buildManifest(opts.dir);
+  const base = {
+    name,
+    fileCount: local.files.length,
+    totalBytes: local.totalBytes,
+    warnings: local.warnings
+  };
+  const path = `/api/sites/${encodeURIComponent(name)}/deploys`;
+  const res = await deps.client.request("POST", path, {
+    schema: DeployResponseSchema,
+    body: {
+      manifest: toManifest(local),
+      ...opts.spa !== void 0 ? { spa: opts.spa } : {},
+      ...opts.public ? { visibility: "public" } : {}
+    }
+  }).catch(async (error) => {
+    if (error instanceof CliApiError && error.status === 409 && error.code === "name_taken")
+      throw await nameTakenError(deps.client, name, error.body);
+    throw error;
+  });
+  if (res.status !== "upload") {
+    return {
+      ...base,
+      status: res.status,
+      url: res.site.url,
+      versionId: res.versionId,
+      site: res.site,
+      uploaded: 0
+    };
+  }
+  const byPath = new Map(local.files.map((f) => [f.path, f]));
+  const uploads = res.uploads.map((u) => {
+    const file = byPath.get(u.path);
+    if (!file) throw new CliError(`Server asked for a file that is not in the manifest: ${u.path}`);
+    return { ...u, file };
+  });
+  const totalBytes = uploads.reduce((n, u) => n + u.file.size, 0);
+  let done = 0;
+  let bytes = 0;
+  opts.onProgress?.({ uploaded: 0, total: uploads.length, bytes: 0, totalBytes });
+  await mapLimit(uploads, UPLOAD_CONCURRENCY, async (u) => {
+    await uploadWithRetry(deps, u.file, u.url, u.headers);
+    done++;
+    bytes += u.file.size;
+    opts.onProgress?.({ uploaded: done, total: uploads.length, bytes, totalBytes });
+  });
+  const fin = await deps.client.request(
+    "POST",
+    `${path}/${encodeURIComponent(res.versionId)}/finalize`,
+    { schema: FinalizeResponseSchema }
+  );
+  return {
+    ...base,
+    status: "live",
+    url: fin.site.url,
+    versionId: fin.versionId,
+    site: fin.site,
+    uploaded: uploads.length
+  };
+}
+async function uploadWithRetry(deps, file, url, headers) {
+  const sleep = deps.sleep ?? defaultSleep2;
+  const body = file.content ?? await readFile3(file.absPath);
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await putUpload(deps.fetch, url, headers, body);
+      return;
+    } catch (error) {
+      const retryable = error instanceof UploadError && error.retryable;
+      if (!retryable || attempt >= UPLOAD_RETRIES) {
+        throw new CliError(`Upload of ${file.path} failed: ${error.message}`, {
+          hint: retryable ? "Check your connection and run the deploy again." : void 0
+        });
+      }
+      await sleep(500 * 2 ** attempt);
+    }
+  }
+}
+
+// src/inputs.ts
+import { copyFile, mkdir as mkdir2, mkdtemp, readFile as readFile4, rm, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename as basename2, extname, join as join3, resolve as resolve2, sep as sep3 } from "node:path";
+import { unzipSync } from "fflate";
+function inputKind(path, isDirectory) {
+  if (isDirectory) return "folder";
+  const ext = extname(path).toLowerCase();
+  if (ext === ".html" || ext === ".htm") return "html";
+  if (ext === ".zip") return "zip";
+  return "file";
+}
+function fileSiteName(path) {
+  const file = basename2(path.replace(/\\/g, "/"));
+  const stem = file.slice(0, file.length - extname(file).length) || file;
+  return fitName([stem.replace(/\s*\(\d+\)$/, "")]);
+}
+function defaultNameFor(path, isDirectory) {
+  return isDirectory ? defaultSiteName(path) : fileSiteName(path);
+}
+async function tempFolder() {
+  const dir = await mkdtemp(join3(tmpdir(), "fling-"));
+  return { dir, cleanup: () => rm(dir, { recursive: true, force: true }) };
+}
+async function prepareInput(path) {
+  let info;
+  try {
+    info = await stat3(path);
+  } catch {
+    throw new CliError(`Not found: ${path}`);
+  }
+  const kind = inputKind(path, info.isDirectory());
+  const defaultName = defaultNameFor(path, info.isDirectory());
+  if (kind === "folder")
+    return { kind, source: path, dir: path, defaultName, cleanup: async () => {
+    } };
+  if (info.size > MAX_DEPLOY_BYTES)
+    throw new CliError(
+      `${basename2(path)} is ${formatBytes(info.size)}; the limit is ${formatBytes(MAX_DEPLOY_BYTES)}`
+    );
+  const tmp = await tempFolder();
+  try {
+    if (kind === "html") {
+      if (info.size > MAX_FILE_BYTES)
+        throw new CliError(
+          `${basename2(path)} is ${formatBytes(info.size)}; the limit is ${formatBytes(MAX_FILE_BYTES)} per file`
+        );
+      await copyFile(path, join3(tmp.dir, "index.html"));
+    } else if (kind === "zip") {
+      await extractZip(await readFile4(path), tmp.dir);
+    } else {
+      const name = basename2(path);
+      await copyFile(path, join3(tmp.dir, name));
+      await writeFile2(join3(tmp.dir, "index.html"), wrapperPage(name));
+    }
+  } catch (error) {
+    await tmp.cleanup();
+    throw error;
+  }
+  return { kind, source: path, dir: tmp.dir, defaultName, cleanup: tmp.cleanup };
+}
+var JUNK_FILES = /* @__PURE__ */ new Set(["thumbs.db", "desktop.ini"]);
+function zipEntryPath(name) {
+  const normalised = name.replace(/\\/g, "/");
+  if (normalised.includes("\0")) return "unsafe";
+  if (normalised.startsWith("/") || /^[a-zA-Z]:/.test(normalised)) return "unsafe";
+  const segments = normalised.split("/").filter((s) => s !== "" && s !== ".");
+  if (segments.includes("..")) return "unsafe";
+  if (normalised.endsWith("/") || segments.length === 0) return null;
+  if (segments[0] === "__MACOSX") return null;
+  if (segments.some((s) => s.startsWith("."))) return null;
+  if (JUNK_FILES.has((segments.at(-1) ?? "").toLowerCase())) return null;
+  return segments.join("/");
+}
+function unwrapSingleFolder(paths) {
+  let current = paths;
+  for (; ; ) {
+    const first = current[0]?.split("/")[0];
+    if (!first || !current.every((p) => p.includes("/") && p.split("/")[0] === first)) return current;
+    current = current.map((p) => p.slice(first.length + 1));
+  }
+}
+async function extractZip(data, dest) {
+  const unsafe = [];
+  let declared = 0;
+  let count = 0;
+  let entries;
+  try {
+    entries = unzipSync(data, {
+      filter: (file) => {
+        const path = zipEntryPath(file.name);
+        if (path === "unsafe") {
+          unsafe.push(file.name);
+          return false;
+        }
+        if (path === null) return false;
+        count++;
+        declared += file.originalSize;
+        if (file.originalSize > MAX_FILE_BYTES)
+          throw new CliError(
+            `${path} in the zip is ${formatBytes(file.originalSize)}; the limit is ${formatBytes(MAX_FILE_BYTES)} per file`
+          );
+        if (declared > MAX_DEPLOY_BYTES)
+          throw new CliError(
+            `The zip expands to more than ${formatBytes(MAX_DEPLOY_BYTES)}, the limit per deploy`
+          );
+        if (count > MAX_FILES) throw new CliError(`The zip has more than ${MAX_FILES} files`);
+        return true;
+      }
+    });
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw new CliError(`Could not read the zip: ${error.message}`);
+  }
+  if (unsafe.length)
+    throw new CliError(
+      `Refusing to extract the zip: it has paths that escape its folder (${unsafe.slice(0, 3).join(", ")})`
+    );
+  const names = Object.keys(entries);
+  const paths = /* @__PURE__ */ new Map();
+  const kept = names.map((n) => zipEntryPath(n));
+  const unwrapped = unwrapSingleFolder(kept);
+  names.forEach((n, i) => {
+    paths.set(n, unwrapped[i]);
+  });
+  if (names.length === 0) throw new CliError("The zip has no files to fling");
+  const root = resolve2(dest);
+  let total = 0;
+  const written = [];
+  for (const name of names) {
+    const content = entries[name];
+    total += content.length;
+    if (content.length > MAX_FILE_BYTES || total > MAX_DEPLOY_BYTES)
+      throw new CliError(`The zip expands to more than the limits allow`);
+    const rel = paths.get(name);
+    const target = resolve2(root, ...rel.split("/"));
+    if (!target.startsWith(root + sep3)) throw new CliError(`Unsafe path in the zip: ${name}`);
+    await mkdir2(join3(target, ".."), { recursive: true });
+    await writeFile2(target, content);
+    written.push(rel);
+  }
+  return written.sort();
+}
+var escapeHtml3 = (s) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+function wrapperPage(file) {
+  const href = escapeHtml3(encodeURIComponent(file));
+  const title = escapeHtml3(file);
+  const ext = extname(file).toLowerCase();
+  let body;
+  if (/^\.(png|jpe?g|gif|webp|avif|svg|bmp|ico)$/.test(ext))
+    body = `<img src="${href}" alt="${title}">`;
+  else if (ext === ".pdf") body = `<iframe src="${href}" title="${title}"></iframe>`;
+  else if (/^\.(mp4|webm|mov|m4v)$/.test(ext)) body = `<video src="${href}" controls></video>`;
+  else if (/^\.(mp3|wav|ogg|m4a|flac)$/.test(ext)) body = `<audio src="${href}" controls></audio>`;
+  else body = "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>
+  body { margin: 0; font: 16px/1.5 system-ui, sans-serif; display: flex; flex-direction: column; min-height: 100vh; }
+  header { padding: 12px 20px; border-bottom: 1px solid #ddd; display: flex; gap: 16px; align-items: baseline; }
+  main { flex: 1; display: flex; justify-content: center; align-items: center; padding: 20px; }
+  img, video { max-width: 100%; max-height: 85vh; }
+  iframe { width: 100%; height: 85vh; border: 0; }
+</style>
+</head>
+<body>
+<header><strong>${title}</strong> <a href="${href}" download>Download</a> <a href="${href}">Open</a></header>
+<main>${body}</main>
+</body>
+</html>
+`;
+}
+
+// src/locate.ts
+import { lstat, readdir as readdir2, readFile as readFile5, realpath as realpath2, stat as stat4 } from "node:fs/promises";
+import { posix, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+var DOWNLOADS_DIR_ENV = "FLING_DOWNLOADS_DIR";
+var FOUND_AS_GIVEN = "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "__MACOSX", "Library", "AppData", "$RECYCLE.BIN"]);
+var SESSION_SKIP_DIRS = /* @__PURE__ */ new Set(["skills-plugin", "rpm", "uploads", "memory"]);
+var SESSIONS_DEPTH = 4;
+var OUTPUTS_DEPTH = 4;
+var SANDBOX_PATH_RE = /^\/(mnt\/user-data|mnt\/data|sessions|home\/claude|tmp\/outputs)(\/|$)/;
+var nodeFs = {
+  async stat(path) {
+    try {
+      const s = await stat4(path);
+      return { isFile: s.isFile(), isDirectory: s.isDirectory(), mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      return null;
+    }
+  },
+  async readdir(path) {
+    try {
+      const entries = await readdir2(path, { withFileTypes: true });
+      const out = [];
+      for (const e of entries) {
+        if (e.isSymbolicLink()) {
+          const s = await stat4(`${path}/${e.name}`).catch(() => null);
+          out.push({ name: e.name, isFile: Boolean(s?.isFile()), isDirectory: false });
+        } else out.push({ name: e.name, isFile: e.isFile(), isDirectory: e.isDirectory() });
+      }
+      return out;
+    } catch {
+      return [];
+    }
+  },
+  async realpath(path) {
+    return realpath2(path).catch(() => null);
+  },
+  async readText(path) {
+    try {
+      if (!(await lstat(path)).isFile()) return null;
+      return await readFile5(path, "utf8");
+    } catch {
+      return null;
+    }
+  }
+};
+var pathFor = (platform) => platform === "win32" ? win32 : posix;
+var usable = (value) => Boolean(value?.trim()) && !value?.trim().startsWith("${");
+async function xdgUserDir(key, opts, fs) {
+  const fromEnv2 = opts.env[`XDG_${key}_DIR`];
+  if (usable(fromEnv2)) return fromEnv2;
+  const configHome = opts.env.XDG_CONFIG_HOME || posix.join(opts.home, ".config");
+  const text = await fs.readText(posix.join(configHome, "user-dirs.dirs"));
+  const match = text?.match(new RegExp(`^XDG_${key}_DIR="([^"]*)"`, "m"));
+  if (!match?.[1]) return void 0;
+  return match[1].replace(/^\$HOME(?=\/|$)/, opts.home);
+}
+async function searchRoots(opts) {
+  const fs = opts.fs ?? nodeFs;
+  const p = pathFor(opts.platform);
+  const { home, env, platform } = opts;
+  const userHome = platform === "win32" && usable(env.USERPROFILE) ? env.USERPROFILE : home;
+  const roots = [];
+  const add = (label, path, depth, sessions = false) => {
+    if (!path) return;
+    const norm = p.resolve(path);
+    if (roots.some((r) => r.path === norm)) return;
+    roots.push({ label, path: norm, depth, ...sessions ? { sessions } : {} });
+  };
+  const cwd = p.resolve(opts.cwd);
+  if (cwd !== p.parse(cwd).root && cwd !== p.resolve(userHome)) add("current folder", cwd, 4);
+  const configured = usable(opts.downloadsDir) ? opts.downloadsDir : usable(env[DOWNLOADS_DIR_ENV]) ? env[DOWNLOADS_DIR_ENV] : void 0;
+  const defaultDownloads = platform === "linux" ? await xdgUserDir("DOWNLOAD", opts, fs) ?? p.join(home, "Downloads") : p.join(userHome, "Downloads");
+  add("Downloads", configured ? expandHome(configured, home, platform) : defaultDownloads, 3);
+  add("Downloads", defaultDownloads, 3);
+  const desktop = platform === "linux" ? await xdgUserDir("DESKTOP", opts, fs) ?? p.join(home, "Desktop") : p.join(userHome, "Desktop");
+  add("Desktop", desktop, 3);
+  if (platform === "win32" && usable(env.OneDrive))
+    add("Desktop", p.join(env.OneDrive, "Desktop"), 3);
+  const documents = platform === "linux" ? await xdgUserDir("DOCUMENTS", opts, fs) ?? p.join(home, "Documents") : p.join(userHome, "Documents");
+  add("Documents/Claude", p.join(documents, "Claude"), 4);
+  add("~/Claude", p.join(userHome, "Claude"), 4);
+  const claudeConfig = platform === "darwin" ? p.join(home, "Library", "Application Support", "Claude") : platform === "win32" ? p.join(
+    usable(env.APPDATA) ? env.APPDATA : p.join(userHome, "AppData", "Roaming"),
+    "Claude"
+  ) : p.join(env.XDG_CONFIG_HOME || p.join(home, ".config"), "Claude");
+  add(
+    "Claude Desktop outputs",
+    p.join(claudeConfig, "local-agent-mode-sessions"),
+    SESSIONS_DEPTH,
+    true
+  );
+  if (!fs.realpath) return roots;
+  const real = [];
+  for (const root of roots) {
+    const path = await fs.realpath(root.path) ?? root.path;
+    if (!real.some((r) => r.path === path)) real.push({ ...root, path });
+  }
+  return real;
+}
+function expandHome(input, home, platform) {
+  if (input === "~") return home;
+  if (input.startsWith("~/") || platform === "win32" && input.startsWith("~\\"))
+    return pathFor(platform).join(home, input.slice(2));
+  return input;
+}
+async function walk(roots, opts, visit) {
+  const fs = opts.fs ?? nodeFs;
+  const p = pathFor(opts.platform);
+  const now = opts.now ?? Date.now;
+  const deadline = now() + (opts.timeBudgetMs ?? 4e3);
+  let budget = opts.entryBudget ?? 6e4;
+  const skip = (name) => name.startsWith(".") || SKIP_DIRS.has(name);
+  const expanded = [];
+  for (const root of roots) {
+    if (!root.sessions) {
+      expanded.push(root);
+      continue;
+    }
+    let level = [root.path];
+    for (let depth = 0; depth < root.depth && level.length; depth++) {
+      const next = [];
+      for (const dir of level) {
+        for (const e of await fs.readdir(dir)) {
+          if (!e.isDirectory || skip(e.name) || SESSION_SKIP_DIRS.has(e.name)) continue;
+          const child = p.join(dir, e.name);
+          if (e.name === "outputs")
+            expanded.push({ label: root.label, path: child, depth: OUTPUTS_DEPTH });
+          else next.push(child);
+        }
+      }
+      level = next;
+    }
+  }
+  for (const root of expanded) {
+    let level = [root.path];
+    for (let depth = 0; depth <= root.depth && level.length; depth++) {
+      const next = [];
+      for (const dir of level) {
+        if (now() > deadline || budget <= 0) return { complete: false };
+        const entries = await fs.readdir(dir);
+        budget -= entries.length;
+        for (const entry of entries) {
+          if (entry.name.startsWith(".")) continue;
+          const path = p.join(dir, entry.name);
+          const result = await visit({ root, path, entry, siblings: entries });
+          if (entry.isDirectory && !skip(entry.name) && result !== "skip" && depth < root.depth)
+            next.push(path);
+        }
+      }
+      level = next;
+    }
+  }
+  return { complete: true };
+}
+function withoutDuplicateSuffix(name) {
+  return name.replace(/ \(\d+\)(?=\.[^.]+$|$)/, "");
+}
+function namesMatch(candidate, wanted) {
+  const a = candidate.toLowerCase();
+  const b = wanted.toLowerCase();
+  return a === b || withoutDuplicateSuffix(a) === withoutDuplicateSuffix(b);
+}
+var splitSegments = (path) => path.split(/[\\/]+/).filter((s) => s !== "" && s !== "." && s !== "~");
+function suffixScore(path, wanted) {
+  const have = splitSegments(path);
+  let score = 1;
+  for (let i = 2; i <= Math.min(have.length, wanted.length); i++) {
+    if (have[have.length - i]?.toLowerCase() !== wanted[wanted.length - i]?.toLowerCase()) break;
+    score++;
+  }
+  return score;
+}
+var looksLikeSandboxPath = (input) => SANDBOX_PATH_RE.test(input.replace(/\\/g, "/"));
+function normaliseInput(raw, opts) {
+  let input = raw.trim().replace(/^(["'])(.*)\1$/, "$2");
+  if (input.startsWith("file://")) {
+    try {
+      input = fileURLToPath(input, { windows: opts.platform === "win32" });
+    } catch {
+      input = decodeURIComponent(input.slice("file://".length));
+    }
+  }
+  return expandHome(input, opts.home, opts.platform);
+}
+async function resolveInput(input, opts) {
+  const fs = opts.fs ?? nodeFs;
+  const p = pathFor(opts.platform);
+  const given = normaliseInput(input, opts);
+  if (!given) throw new CliError("No path given");
+  const direct = p.isAbsolute(given) ? p.normalize(given) : p.resolve(opts.cwd, given);
+  const directStat = await fs.stat(direct);
+  if (directStat && (directStat.isFile || directStat.isDirectory)) {
+    return {
+      path: direct,
+      foundIn: FOUND_AS_GIVEN,
+      isDirectory: directStat.isDirectory,
+      alternatives: []
+    };
+  }
+  const wanted = splitSegments(given);
+  const name = wanted.at(-1);
+  const roots = await searchRoots(opts);
+  if (!name) throw notFound(input, roots);
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  await walk(roots, opts, async ({ root, path, entry }) => {
+    if (!(entry.isFile || entry.isDirectory) || !namesMatch(entry.name, name)) return;
+    if (seen.has(path)) return;
+    seen.add(path);
+    const s = await fs.stat(path);
+    if (!s) return;
+    found.push({
+      path,
+      foundIn: root.label,
+      kind: s.isDirectory ? "folder" : "file",
+      modified: new Date(s.mtimeMs).toISOString(),
+      size: s.size,
+      score: suffixScore(path, wanted),
+      mtimeMs: s.mtimeMs,
+      isDirectory: s.isDirectory
+    });
+    return void 0;
+  });
+  if (found.length === 0) throw notFound(input, roots);
+  found.sort((a, b) => b.score - a.score || b.mtimeMs - a.mtimeMs);
+  const strip = ({ score: _s, mtimeMs: _m, isDirectory: _d, ...c }) => c;
+  const [best, ...rest] = found;
+  return {
+    path: best.path,
+    foundIn: best.foundIn,
+    isDirectory: best.isDirectory,
+    alternatives: rest.slice(0, 5).map(strip)
+  };
+}
+function notFound(input, roots) {
+  const where = roots.map((r) => `${r.label} (${r.path})`).join(", ");
+  const sandbox = looksLikeSandboxPath(input) ? " That looks like a path inside Claude\u2019s sandbox, which this computer cannot see: publish the content inline with fling_publish, or save/download the file to this computer first." : "";
+  return new CliError(`Could not find "${input}". Looked for it by name in: ${where}.${sandbox}`, {
+    hint: "Pass the full path, or save the file to your Downloads folder and use just its name."
+  });
+}
+var LISTED_EXT = /\.(html?|zip)$/i;
+async function findFiles(opts, find = {}) {
+  const fs = opts.fs ?? nodeFs;
+  const p = pathFor(opts.platform);
+  const now = (opts.now ?? Date.now)();
+  const since = now - (find.days ?? 14) * 24 * 60 * 60 * 1e3;
+  const query = find.query?.trim().toLowerCase();
+  const roots = await searchRoots(opts);
+  const found = /* @__PURE__ */ new Map();
+  const rootPaths = new Set(roots.map((r) => r.path));
+  const { complete } = await walk(roots, opts, async ({ root, path, entry }) => {
+    if (entry.isDirectory) {
+      if (rootPaths.has(path)) return;
+      const index = (await fs.readdir(path)).find((e) => e.isFile && /^index\.html?$/i.test(e.name));
+      if (!index) return;
+      const s2 = await fs.stat(p.join(path, index.name));
+      if (s2 && s2.mtimeMs >= since && (!query || entry.name.toLowerCase().includes(query)))
+        found.set(path, {
+          path,
+          foundIn: root.label,
+          kind: "folder",
+          modified: new Date(s2.mtimeMs).toISOString(),
+          size: s2.size,
+          mtimeMs: s2.mtimeMs
+        });
+      return "skip";
+    }
+    if (!entry.isFile || !LISTED_EXT.test(entry.name)) return;
+    if (query && !entry.name.toLowerCase().includes(query)) return;
+    const s = await fs.stat(path);
+    if (!s || s.mtimeMs < since || found.has(path)) return;
+    found.set(path, {
+      path,
+      foundIn: root.label,
+      kind: "file",
+      modified: new Date(s.mtimeMs).toISOString(),
+      size: s.size,
+      mtimeMs: s.mtimeMs
+    });
+    return void 0;
+  });
+  const files = [...found.values()].sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, find.limit ?? 20).map(({ mtimeMs: _m, ...c }) => c);
+  return { files, searched: roots, complete };
+}
+
+// src/commands/deploy.ts
+async function runDeploy(ctx, input, opts) {
+  const client = requireClient(ctx);
+  const ask = ctx.interactive && !opts.yes;
+  const base = ask ? await discoverSitesBase(client) : sitesBaseFor(client.serverUrl);
+  const located = await resolveInput(input ?? ".", ctx.locate ?? systemLocateOptions());
+  if (located.foundIn !== FOUND_AS_GIVEN) {
+    ctx.log.info(`Found in ${located.foundIn}: ${located.path}`);
+    if (located.alternatives.length)
+      ctx.log.hint(
+        `Also found (older): ${located.alternatives.map((a) => a.path).join(", ")} \u2014 pass the full path to fling another.`
+      );
+  }
+  const prepared = await prepareInput(located.path);
+  try {
+    await deployPrepared(ctx, client, base, prepared, opts, ask);
+  } finally {
+    await prepared.cleanup();
+  }
+}
+async function deployPrepared(ctx, client, base, prepared, opts, ask) {
+  let local = await buildManifest(prepared.dir);
+  let name = opts.name !== void 0 ? resolveSiteName(prepared.dir, opts.name) : prepared.defaultName;
+  if (opts.name === void 0 && ask) name = await confirmSiteName(ctx, client, name, base);
+  if (!hasRootIndex(local)) {
+    const pages = htmlPages(local).length;
+    const root = base ? siteUrlFor(name, base) : "the site root";
+    const warning = `No index.html at the root \u2014 ${root} will show a 404.`;
+    const choice = opts.listHtml === true ? "list" : opts.listHtml === false ? "fling" : ask ? await askNoIndex(ctx, pages) : pages > 0 ? "list" : "fling";
+    if (choice === "list") {
+      local = await withHtmlListing(local, name);
+      ctx.log.info(`Generated index.html listing ${pages} HTML page${pages === 1 ? "" : "s"}`);
+    } else ctx.log.warn(warning);
+  }
+  let progressShown = false;
+  const result = await deploy(
+    { client, fetch: ctx.fetch },
+    {
+      dir: prepared.dir,
+      name,
+      manifest: local,
+      spa: opts.spa ? true : void 0,
+      public: opts.public,
+      onProgress: (p) => {
+        if (p.total === 0) return;
+        progressShown = true;
+        ctx.progress(
+          `${chalk5.cyan("fling")} uploading ${p.uploaded}/${p.total} files \xB7 ${formatBytes(p.bytes)}/${formatBytes(p.totalBytes)}`
+        );
+      }
+    }
+  ).finally(() => {
+    if (progressShown) ctx.progress(null);
+  });
+  for (const warning of result.warnings) if (warning !== NO_INDEX_WARNING) ctx.log.warn(warning);
+  const summary = `${result.fileCount} files, ${formatBytes(result.totalBytes)}`;
+  if (result.status === "unchanged") ctx.log.info(`Unchanged ${chalk5.dim(`(${summary})`)}`);
+  else if (result.status === "repointed")
+    ctx.log.success(`Restored version ${result.versionId} ${chalk5.dim(`(${summary})`)}`);
+  else
+    ctx.log.success(
+      `Deployed ${result.name} ${chalk5.dim(`(${summary}; uploaded ${result.uploaded}, version ${result.versionId})`)}`
+    );
+  const ready = result.status === "unchanged" ? true : (await waitWithSpinner(
+    ctx.waitReady,
+    result.url,
+    local.files.map((f) => f.path),
+    { progress: ctx.progress, warn: (m) => ctx.log.warn(m) }
+  )).ready;
+  ctx.out.data({ status: result.status, site: result.site, ready }, () => {
+    const lines = [chalk5.bold(result.url)];
+    if (result.site.visibility === "private")
+      lines.push(
+        chalk5.dim(
+          `Private: Nearform sign-in required. Share publicly with \`${ctx.binName} share ${result.name}\`.`
+        )
+      );
+    return lines.join("\n");
+  });
+}
+async function askNoIndex(ctx, pages) {
+  const question = pages > 0 ? "No index.html at the root. [L]ist the HTML pages on a generated index page / [f]ling anyway (the root will 404) / [a]bort " : "No index.html at the root (and no HTML pages to list). [f]ling anyway (the root will 404) / [A]bort ";
+  for (; ; ) {
+    const answer = (await ctx.prompt(question)).trim().toLowerCase();
+    if (pages > 0 && (answer === "" || answer === "l" || answer === "list")) return "list";
+    if (answer === "f" || answer === "fling") return "fling";
+    if (answer === "a" || answer === "abort" || answer === "n" || answer === "no" || answer === "")
+      throw new CliError("Not flung: no index.html at the root", {
+        hint: "Fling the folder that contains index.html (your build output, e.g. ./dist), or pass --list-html / --no-list-html."
+      });
+  }
+}
+async function confirmSiteName(ctx, client, generated, base) {
+  const where = (n) => base ? ` \u2192 ${siteUrlFor(n, base)}` : "";
+  const describe = (n, note) => ctx.log.info(`Site name: ${chalk5.bold(n)}${where(n)}  ${chalk5.dim(`(${note})`)}`);
+  let candidate = generated;
+  for (; ; ) {
+    const check = await checkName(client, candidate);
+    let proposal;
+    if (check.status === "available" || check.status === "yours") {
+      proposal = candidate;
+      describe(candidate, check.status === "yours" ? "updates your existing site" : "new");
+    } else {
+      const why = check.status === "taken" ? "is taken" : "is not a valid site name";
+      const alternatives = check.suggestions.length ? ` Suggestions: ${check.suggestions.join(", ")}` : "";
+      ctx.log.warn(`${candidate} ${why}.${alternatives}`);
+      proposal = check.suggestions[0];
+      if (proposal) describe(proposal, "new");
+    }
+    for (; ; ) {
+      const question = proposal ? `Use "${proposal}"? [Y/n or type another name] ` : "Type a site name (or n to abort): ";
+      const answer = (await ctx.prompt(question)).trim();
+      if (proposal && (answer === "" || /^y(es)?$/i.test(answer))) return proposal;
+      if (/^no?$/i.test(answer))
+        throw new CliError("Aborted \u2014 nothing was flung", {
+          hint: "Pass --name <name> to choose the site name up front."
+        });
+      if (answer === "") continue;
+      if (!isValidSiteName(answer)) {
+        ctx.log.warn(
+          `"${answer}" is not a valid site name: use lowercase letters, digits and single hyphens (max ${SITE_NAME_MAX}); some names are reserved.`
+        );
+        continue;
+      }
+      candidate = answer;
+      break;
+    }
+  }
+}
+
+// src/commands/sites.ts
+import chalk6 from "chalk";
+async function runList(ctx, opts) {
+  const sites = await listSites(requireClient(ctx), opts);
+  ctx.out.data(
+    { sites },
+    () => renderTable(sites, [
+      { header: "NAME", value: (s) => s.name },
+      { header: "URL", value: (s) => s.url },
+      {
+        header: "VISIBILITY",
+        value: (s) => s.archived ? `${s.visibility} (archived)` : s.visibility
+      },
+      { header: "SHARE", value: (s) => s.shareUrl },
+      { header: "UPDATED", value: (s) => formatDate(s.updatedAt) }
+    ])
+  );
+}
+function describeSite(site) {
+  const row = (label, value) => `${chalk6.bold(`${label}:`.padEnd(12))}${value}`;
+  return [
+    row("Name", site.name),
+    row("URL", site.url),
+    row("Visibility", site.visibility + (site.archived ? chalk6.yellow(" (archived)") : "")),
+    row("SPA", site.spa ? "yes" : "no"),
+    row("Share link", site.shareUrl ?? "-"),
+    row("Version", site.currentVersionId ?? "-"),
+    ...filesRow(site, row),
+    row("Created", formatDate(site.createdAt)),
+    row("Updated", formatDate(site.updatedAt))
+  ];
+}
+function filesRow(site, row) {
+  const current = site.versions?.find((v) => v.id === site.currentVersionId);
+  if (!current) return [];
+  const n = current.fileCount;
+  return [row("Files", `${n} file${n === 1 ? "" : "s"}, ${formatBytes(current.totalBytes)}`)];
+}
+async function runInfo(ctx, name) {
+  const site = await getSite(requireClient(ctx), name);
+  ctx.out.data(
+    site,
+    () => [
+      ...describeSite(site),
+      "",
+      chalk6.dim(
+        `${site.versions.length} version(s) \u2014 \`fling versions ${name}\`; files \u2014 \`fling files ${name}\``
+      )
+    ].join("\n")
+  );
+}
+async function runVersions(ctx, name) {
+  const site = await getSite(requireClient(ctx), name);
+  ctx.out.data(
+    { name: site.name, currentVersionId: site.currentVersionId, versions: site.versions },
+    () => renderTable(site.versions, [
+      { header: "", value: (v) => v.id === site.currentVersionId ? "*" : " " },
+      { header: "VERSION", value: (v) => v.id },
+      { header: "FILES", value: (v) => v.fileCount },
+      { header: "SIZE", value: (v) => formatBytes(v.totalBytes) },
+      { header: "CREATED", value: (v) => formatDate(v.createdAt) }
+    ])
+  );
+}
+async function runFiles(ctx, name, versionId) {
+  const result = await versionFiles(requireClient(ctx), name, versionId);
+  if (!result.files.some((f) => f.path === "index.html")) {
+    ctx.log.warn("No index.html at the root \u2014 the site root URL will 404");
+  }
+  ctx.out.data(result, () => {
+    const n = result.files.length;
+    const header = chalk6.dim(
+      `${result.versionId}${result.current ? " (current)" : " (not served)"} \u2014 ${n} file${n === 1 ? "" : "s"}, ${formatBytes(result.totalBytes)}${result.generatedIndex ? ", generated index.html" : ""}`
+    );
+    const table = renderTable(result.files, [
+      { header: "PATH", value: (f) => f.path },
+      { header: "SIZE", value: (f) => formatBytes(f.size) },
+      { header: "TYPE", value: (f) => f.contentType }
+    ]);
+    return `${header}
+${table}`;
+  });
+}
+async function runRollback(ctx, name, versionId) {
+  const site = await rollback(requireClient(ctx), name, versionId);
+  ctx.log.success(`${name} now serves version ${site.currentVersionId ?? versionId}`);
+  ctx.out.data(site, () => site.url);
+}
+async function runShare(ctx, name, opts) {
+  if (opts.refresh && opts.revoke) throw new CliError("Use either --refresh or --revoke, not both");
+  const client = requireClient(ctx);
+  const result = await share(client, name, opts);
+  let ready;
+  if (result.action === "created" || result.action === "refreshed") {
+    const files = ctx.waitReady ? await versionFiles(client, name).catch(() => null) : null;
+    ready = (await waitWithSpinner(ctx.waitReady, result.shareUrl, files?.files.map((f) => f.path) ?? [], {
+      progress: ctx.progress,
+      warn: (m) => ctx.log.warn(m)
+    })).ready;
+  }
+  if (result.action === "revoked") ctx.log.success(`Share link for ${name} revoked`);
+  else if (result.action === "refreshed")
+    ctx.log.success("New share link \u2014 the old one no longer works");
+  else if (result.action === "created")
+    ctx.log.success("Share link created \u2014 anyone with it can view the site");
+  ctx.out.data(
+    ready === void 0 ? result : { ...result, ready },
+    () => result.shareUrl ? result.shareUrl : chalk6.dim("(no share link)")
+  );
+}
+async function runVisibility(ctx, name, visibility) {
+  if (visibility !== "private" && visibility !== "public") {
+    throw new CliError(`Visibility must be "private" or "public", not "${visibility}"`);
+  }
+  const site = await setVisibility(requireClient(ctx), name, visibility);
+  ctx.log.success(
+    site.visibility === "public" ? `${name} is public \u2014 no sign-in needed` : `${name} is private \u2014 Nearform sign-in required`
+  );
+  ctx.out.data(site, () => site.url);
+}
+async function runArchive(ctx, name, unarchive = false) {
+  const site = await archiveSite(requireClient(ctx), name, { unarchive });
+  ctx.log.success(
+    unarchive ? `${name} restored` : `${name} archived \u2014 it 404s until \`fling unarchive ${name}\``
+  );
+  if (ctx.json) ctx.out.data(site, () => "");
+  else if (unarchive) ctx.out.text(site.url);
+}
+async function runRemove(ctx, name, opts) {
+  if (!opts.yes) {
+    if (!ctx.interactive) {
+      throw new CliError(`Refusing to delete ${name} without confirmation`, {
+        hint: "Pass --yes to delete."
+      });
+    }
+    const ok = await ctx.confirm(`Delete ${name} and every version of it? This cannot be undone.`);
+    if (!ok) throw new CliError("Cancelled");
+  }
+  const result = await deleteSite(requireClient(ctx), name);
+  ctx.log.success(`${name} deleted`);
+  if (ctx.json) ctx.out.data(result, () => "");
+}
+
+// src/mcp.ts
+import { mkdir as mkdir3, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename as basename3, dirname as dirname2, join as join4 } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z7 } from "zod";
+var LOGIN_HINT = `Not logged in to Fling. Call fling_login (it opens the browser to sign in with Nearform Google), or ask the user to run \`${NPX_COMMAND} login\` in a terminal (in Claude Code: \`! ${NPX_COMMAND} login\`), then try again.`;
+var MCP_LOCAL_INSTRUCTIONS = [
+  "Fling publishes static sites (HTML/CSS/JS, images, documents) for Nearform staff at https://<name>.fling.labs.nearform.com. This server runs on the user's computer.",
+  "Content you created in this conversation (an HTML page, a report, a small app): call fling_publish with every file inline (text as utf8, binary as base64). Never pass file paths from your sandbox (e.g. /mnt/user-data/outputs/\u2026, /sessions/\u2026) \u2014 this computer cannot see them \u2014 and never curl or upload from the sandbox.",
+  'A file or folder the user has on this computer (a downloaded .html, a .zip, a build folder): call fling_deploy with its path, or just its file name (e.g. "Pitch Deck.html") \u2014 it is looked up in Downloads, Desktop, Documents/Claude and Claude Desktop output folders. Use fling_find_files to see recent candidates when unsure which file the user means.',
+  "Confirm the site name with the user before publishing (fling_check_name shows whether it is free and, for a path, the generated name). Names are global, first come first served; when one is taken, offer the suggestions.",
+  "When there is no index.html but there are HTML pages, fling_deploy and fling_publish do not publish: ask the user whether to generate an index page listing the pages (`listHtml: true`) or publish without one (`listHtml: false`, the root URL 404s), then retry.",
+  "Not logged in? Call fling_login, let the user finish signing in in the browser, then retry.",
+  "Sites are private (Nearformers only) by default; only make one public if asked. Use fling_share for a link people outside Nearform can open. Always give the user the URL that comes back."
+].join("\n\n");
+var toolDef = (def) => ({
+  title: def.title,
+  description: def.description,
+  inputSchema: def.inputSchema,
+  annotations: def.annotations
+});
+function createMcpServer(deps = {}) {
+  const store = deps.store ?? createConfigStore();
+  const fetchImpl = deps.fetch ?? ((input, init) => fetch(input, init));
+  const cwd = deps.cwd ?? process.cwd();
+  const locate = deps.locate ?? { ...systemLocateOptions(), cwd };
+  const waitReady = deps.waitReady ?? createReadyWaiter();
+  async function edgeReady(url, paths) {
+    const r = await waitReady(url, paths).catch(() => ({ ready: false, waitedMs: 0 }));
+    return {
+      ready: r.ready,
+      note: r.ready ? "" : `
+Not reachable yet at ${url}: ${NOT_READY_NOTE}.`
+    };
+  }
+  async function client() {
+    const config = await store.resolve({ serverUrl: deps.server });
+    if (!config.apiKey) throw new CliError("Not logged in", { exitCode: EXIT_NOT_LOGGED_IN });
+    return createApiClient({ serverUrl: config.serverUrl, apiKey: config.apiKey, fetch: fetchImpl });
+  }
+  async function run(op) {
+    try {
+      const { summary, data } = await op(await client());
+      return { content: [{ type: "text", text: `${summary}
+
+${JSON.stringify(data, null, 2)}` }] };
+    } catch (error) {
+      return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+    }
+  }
+  async function deployFolder(c, dir, opts) {
+    let local = await buildManifest(dir);
+    let generatedIndex = false;
+    if (!hasRootIndex(local)) {
+      const pages = htmlPages(local).map((f) => f.path);
+      if (pages.length > 0 && opts.listHtml === void 0) {
+        const shown = pages.slice(0, 20);
+        return {
+          kind: "needs_decision",
+          summary: `Not published yet: there is no index.html at the root, but there ${pages.length === 1 ? "is 1 HTML page" : `are ${pages.length} HTML pages`}. Ask the user whether to generate an index.html listing them (call again with \`listHtml: true\`) or to publish without one (\`listHtml: false\` \u2014 the root URL will 404, the pages still work at their own paths). Then call ${opts.retryWith} again with the same arguments plus \`listHtml\`.`,
+          data: {
+            status: "needs_decision",
+            htmlPages: shown,
+            ...pages.length > shown.length ? { moreHtmlPages: pages.length - shown.length } : {},
+            fileCount: local.files.length
+          }
+        };
+      }
+      if (opts.listHtml) {
+        local = await withHtmlListing(local, opts.name);
+        generatedIndex = true;
+      }
+    }
+    const result = await deploy(
+      { client: c, fetch: fetchImpl },
+      { dir, name: opts.name, manifest: local, spa: opts.spa, public: opts.public }
+    ).catch((error) => {
+      if (!(error instanceof NameTakenError)) throw error;
+      const how = opts.nameGiven ? "" : ` (generated from ${opts.nameFrom ?? "the folder"})`;
+      const pick = error.suggestions.length ? ` Free alternatives: ${error.suggestions.join(", ")}.` : "";
+      throw new CliError(
+        `Not deployed: the site name "${error.siteName}"${how} is taken by someone else.${pick} Ask the user which name to use (one of these or their own), then call ${opts.retryWith} again with \`name\`.`
+      );
+    });
+    const what = result.status === "unchanged" ? "Unchanged \u2014 already live" : result.status === "repointed" ? `Restored version ${result.versionId}` : `Deployed ${result.fileCount} files (uploaded ${result.uploaded})`;
+    const warnings = result.warnings.length ? `
+Warnings:
+- ${result.warnings.join("\n- ")}` : "";
+    const edge = result.status === "unchanged" ? { ready: true, note: "" } : await edgeReady(
+      result.url,
+      local.files.map((f) => f.path)
+    );
+    return {
+      kind: "deployed",
+      summary: `${what}: ${result.url} (${result.site.visibility})${generatedIndex ? " \u2014 with a generated index.html listing the HTML pages" : ""}${warnings}${edge.note}
+To check exactly which files the site has, call fling_files with name "${result.name}".`,
+      data: {
+        status: result.status,
+        ready: edge.ready,
+        name: result.name,
+        nameGenerated: !opts.nameGiven,
+        versionId: result.versionId,
+        site: result.site,
+        generatedIndex,
+        warnings: result.warnings
+      }
+    };
+  }
+  const server = new McpServer(
+    { name: "fling", version: VERSION },
+    { instructions: MCP_LOCAL_INSTRUCTIONS }
+  );
+  const { listHtml: listHtml2, spa: spa2, public: isPublic2 } = mcpTools.publish.inputSchema;
+  server.registerTool(
+    "fling_deploy",
+    {
+      title: "Deploy a file or folder from this computer",
+      description: 'Fling something that is on the user\'s computer and return its stable URL (https://<name>.fling.labs.nearform.com): a folder of static files (e.g. a build output like dist/), a single .html file (served as the site\'s index.html), a .zip of a site (extracted; a single top-level folder is unwrapped), or any other single file (.pdf, .svg, .png\u2026, served next to a generated page that shows it). `path` can be absolute, relative to the working directory, or just a file name ("Pitch Deck.html"): names are looked up, newest first, in Downloads, Desktop, Documents/Claude and Claude Desktop output folders, and the result says where the file was found. Never pass paths from your own sandbox (/mnt/user-data/\u2026, /sessions/\u2026): for content you created, use fling_publish. Without `name`, a name is generated: from the file name for files ("Pitch Deck (1).html" \u2192 pitch-deck), from the project and folder for folders (~/work/rocketpod/docs \u2192 rocketpod-docs). Site names are one global namespace, first come first served \u2014 confirm the name with the user first (fling_check_name with `path` shows the generated one). If the name is taken it fails with free suggestions \u2014 ask the user to pick one, then retry with `name`. If there is no index.html but there are HTML pages, it does not deploy: ask the user whether to generate an index page listing them (`listHtml: true`) or deploy without one (`listHtml: false`), then retry. Re-deploying identical content is a no-op. Sites are private to signed-in Nearformers unless `public` is set.',
+      inputSchema: {
+        path: z7.string().min(1).describe(
+          "File or folder on this computer: absolute, relative to the working directory, or just its name (looked up in Downloads, Desktop and Claude output folders)"
+        ),
+        name: z7.string().optional().describe(
+          "Site name (lowercase letters, digits, single hyphens; max 50). Defaults to a name generated from the file or folder"
+        ),
+        spa: spa2,
+        public: isPublic2,
+        listHtml: listHtml2
+      },
+      annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    (args) => run(async (c) => {
+      const located = await resolveInput(args.path, locate);
+      const prepared = await prepareInput(located.path);
+      try {
+        const name = args.name !== void 0 ? resolveSiteName(prepared.dir, args.name) : prepared.defaultName;
+        const outcome = await deployFolder(c, prepared.dir, {
+          name,
+          nameGiven: args.name !== void 0,
+          nameFrom: prepared.kind === "folder" ? "the folder" : "the file name",
+          spa: args.spa,
+          public: args.public,
+          listHtml: args.listHtml,
+          retryWith: "fling_deploy"
+        });
+        const where = located.foundIn === FOUND_AS_GIVEN ? "" : `Found "${basename3(located.path)}" in ${located.foundIn}: ${located.path}
+`;
+        return {
+          summary: `${where}${outcome.summary}`,
+          data: {
+            ...outcome.data,
+            source: {
+              path: located.path,
+              foundIn: located.foundIn,
+              kind: prepared.kind,
+              ...located.alternatives.length ? { alternatives: located.alternatives } : {}
+            }
+          }
+        };
+      } finally {
+        await prepared.cleanup();
+      }
+    })
+  );
+  server.registerTool(
+    "fling_find_files",
+    {
+      title: "Find files to fling",
+      description: "List recent things on this computer that could be flung, newest first: .html/.htm and .zip files, and folders containing an index.html, from the working directory, Downloads, Desktop, Documents/Claude, ~/Claude and Claude Desktop output folders. Each has its path, where it was found, size and modified time. Use it when the user refers to a file they downloaded or that Claude Desktop saved, then pass the chosen path (or name) to fling_deploy.",
+      inputSchema: {
+        query: z7.string().optional().describe('Only names containing this text (case-insensitive), e.g. "deck"'),
+        limit: z7.number().int().min(1).max(100).optional().describe("Max results (default 20)"),
+        days: z7.number().int().min(1).max(3650).optional().describe("Only things modified in the last N days (default 14)")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async (args) => {
+      try {
+        const { files, searched, complete } = await findFiles(locate, args);
+        const lines = files.map(
+          (f) => `- ${f.path} (${f.kind}, ${f.foundIn}, ${formatBytes(f.size)}, modified ${f.modified})`
+        );
+        const summary = files.length ? `${files.length} recent item(s), newest first:
+${lines.join("\n")}` : `Nothing found from the last ${args.days ?? 14} days${args.query ? ` matching "${args.query}"` : ""}.`;
+        const data = {
+          files,
+          searched: searched.map((r) => ({ label: r.label, path: r.path })),
+          ...complete ? {} : { truncated: true }
+        };
+        return {
+          content: [{ type: "text", text: `${summary}
+
+${JSON.stringify(data, null, 2)}` }]
+        };
+      } catch (error) {
+        return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+      }
+    }
+  );
+  const publishDef = mcpTools.publish;
+  server.registerTool(
+    publishDef.name,
+    {
+      ...toolDef(publishDef),
+      // This server has no chunked upload tools; big sites go through fling_deploy instead.
+      description: publishDef.description.replace(
+        /\(whole site, up to [^;]*; bigger sites: fling_upload_begin \/ fling_upload_file \/ fling_upload_finish\)/,
+        "(whole site; for a big site that is already on this computer, use fling_deploy with its folder)"
+      )
+    },
+    (args) => run(async (c) => {
+      const name = resolveSiteName(".", args.name);
+      const tmp = await mkdtemp2(join4(tmpdir2(), "fling-publish-"));
+      try {
+        await writeInlineFiles(tmp, args.files);
+        const outcome = await deployFolder(c, tmp, {
+          name,
+          nameGiven: true,
+          spa: args.spa,
+          public: args.public,
+          listHtml: args.listHtml,
+          retryWith: "fling_publish"
+        });
+        return outcome;
+      } finally {
+        await rm2(tmp, { recursive: true, force: true });
+      }
+    })
+  );
+  server.registerTool(
+    "fling_check_name",
+    {
+      ...toolDef(mcpTools.checkName),
+      description: `${mcpTools.checkName.description} Pass \`path\` instead of \`name\` to see the name fling_deploy would generate for a file or folder on this computer (same lookup as fling_deploy), so you can confirm it with the user.`,
+      inputSchema: {
+        name: z7.string().min(1).max(200).optional().describe("Site name to check"),
+        path: z7.string().optional().describe("File or folder whose generated default name to check (path or file name)")
+      }
+    },
+    (args) => run(async (c) => {
+      if (args.name === void 0 && args.path === void 0)
+        throw new CliError("Pass `name` or `path`");
+      let name = args.name;
+      let source;
+      if (name === void 0) {
+        source = await resolveInput(args.path, locate);
+        name = defaultNameFor(source.path, source.isDirectory);
+      }
+      const check = await checkName(c, name);
+      const base = check.status === "invalid" ? null : await discoverSitesBase(c);
+      const url = base ? siteUrlFor(name, base) : null;
+      const suggestions = check.suggestions.length ? ` Suggestions: ${check.suggestions.join(", ")}.` : "";
+      const summary = {
+        available: `"${name}" is available${url ? ` \u2192 ${url}` : ""}.`,
+        yours: `"${name}" is the user's existing site${url ? ` (${url})` : ""} \u2014 deploying updates it.`,
+        taken: `"${name}" is taken by someone else.${suggestions}`,
+        invalid: `"${name}" is not a valid site name.${suggestions}`
+      }[check.status];
+      return {
+        summary,
+        data: {
+          ...check,
+          url,
+          ...source ? { generated: true, source: { path: source.path, foundIn: source.foundIn } } : {}
+        }
+      };
+    })
+  );
+  let pendingLogin;
+  server.registerTool(
+    "fling_login",
+    {
+      title: "Sign in to Fling",
+      description: "Sign the user in to Fling: opens their browser at the Fling sign-in page (Nearform Google account) and stores the key on this computer (shared with the fling CLI). Waits up to ~30 seconds; if sign-in is not finished by then, it keeps waiting in the background for up to 5 minutes \u2014 tell the user to finish signing in in the browser, then retry what you were doing. Call it when another tool says the user is not logged in.",
+      inputSchema: {},
+      annotations: { readOnlyHint: false, openWorldHint: true }
+    },
+    async () => {
+      try {
+        const config = await store.resolve({ serverUrl: deps.server });
+        if (config.apiKey && !pendingLogin) {
+          const me = await whoami(
+            createApiClient({
+              serverUrl: config.serverUrl,
+              apiKey: config.apiKey,
+              fetch: fetchImpl
+            })
+          ).catch(() => null);
+          if (me) return textResult(`Already signed in to ${config.serverUrl} as ${me.email}.`);
+        }
+        if (!pendingLogin) {
+          const login = {
+            done: Promise.resolve()
+          };
+          login.done = loginFlow({
+            serverUrl: config.serverUrl,
+            store,
+            log: silentLogger,
+            open: deps.open ?? (async (url) => (await import("open")).default(url)),
+            fetch: fetchImpl,
+            timeoutMs: deps.loginTimeoutMs,
+            onAuthUrl: (url) => {
+              login.url = url;
+            }
+          });
+          login.done.catch(() => {
+          }).finally(() => {
+            if (pendingLogin === login) pendingLogin = void 0;
+          });
+          pendingLogin = login;
+        }
+        const current = pendingLogin;
+        const waited = await Promise.race([
+          current.done.then(
+            (r) => ({ ok: true, r }),
+            (e) => ({ ok: false, e })
+          ),
+          new Promise((r) => setTimeout(() => r(null), deps.loginWaitMs ?? 3e4).unref?.())
+        ]);
+        if (waited === null)
+          return textResult(
+            `Finish signing in in your browser, then try again. (The sign-in page is open; if it did not open, visit: ${current.url ?? "the Fling site"} \u2014 this stays valid for 5 minutes.)`
+          );
+        if (!waited.ok) throw waited.e;
+        return textResult(`Signed in as ${waited.r.user.email} (${waited.r.serverUrl}).`);
+      } catch (error) {
+        return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+      }
+    }
+  );
+  const t = mcpTools;
+  server.registerTool(
+    t.list.name,
+    toolDef(t.list),
+    (args) => run(async (c) => {
+      const sites = await listSites(c, { archived: args.archived });
+      return { summary: `${sites.length} site(s)`, data: { sites } };
+    })
+  );
+  server.registerTool(
+    t.info.name,
+    toolDef(t.info),
+    (args) => run(async (c) => {
+      const site = await getSite(c, args.name);
+      return { summary: `${site.name}: ${site.url}`, data: site };
+    })
+  );
+  server.registerTool(
+    t.files.name,
+    toolDef(t.files),
+    (args) => run(async (c) => {
+      const result = await versionFiles(c, args.name, args.versionId);
+      return {
+        summary: describeVersionFiles(result.name, result, {
+          current: result.current,
+          url: result.url
+        }),
+        data: result
+      };
+    })
+  );
+  server.registerTool(
+    t.share.name,
+    toolDef(t.share),
+    (args) => run(async (c) => {
+      if (args.refresh && args.revoke) throw new CliError("Use either refresh or revoke, not both");
+      const result = await share(c, args.name, args);
+      if (result.action === "revoked")
+        return { summary: `Share link for ${args.name} revoked`, data: result };
+      let edge = { ready: true, note: "" };
+      if (result.action !== "existing") {
+        const files = await versionFiles(c, args.name).catch(() => null);
+        edge = await edgeReady(result.shareUrl, files?.files.map((f) => f.path) ?? []);
+      }
+      return {
+        summary: `Share link (${result.action}): ${result.shareUrl} \u2014 anyone with it can view the site${edge.note}`,
+        data: { ...result, ready: edge.ready }
+      };
+    })
+  );
+  server.registerTool(
+    t.setVisibility.name,
+    toolDef(t.setVisibility),
+    (args) => run(async (c) => {
+      const site = await setVisibility(c, args.name, args.visibility);
+      return { summary: `${site.name} is now ${site.visibility}: ${site.url}`, data: site };
+    })
+  );
+  server.registerTool(
+    t.archive.name,
+    toolDef(t.archive),
+    (args) => run(async (c) => {
+      const site = await archiveSite(c, args.name, { unarchive: args.unarchive });
+      return { summary: `${site.name} ${args.unarchive ? "restored" : "archived"}`, data: site };
+    })
+  );
+  server.registerTool(
+    t.delete.name,
+    toolDef(t.delete),
+    (args) => run(async (c) => {
+      const result = await deleteSite(c, args.name);
+      return { summary: `${args.name} deleted`, data: result };
+    })
+  );
+  server.registerTool(
+    t.rollback.name,
+    toolDef(t.rollback),
+    (args) => run(async (c) => {
+      const site = await rollback(c, args.name, args.versionId);
+      return {
+        summary: `${site.name} now serves version ${site.currentVersionId}: ${site.url}`,
+        data: site
+      };
+    })
+  );
+  server.registerTool(
+    t.whoami.name,
+    toolDef(t.whoami),
+    () => run(async (c) => {
+      const me = await whoami(c);
+      const base = await discoverSitesBase(c);
+      return {
+        summary: `Signed in as ${me.email} (sites are served at ${sitesPattern(base)})`,
+        data: me
+      };
+    })
+  );
+  return server;
+}
+var textResult = (text) => ({ content: [{ type: "text", text }] });
+async function writeInlineFiles(dir, files) {
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0;
+  for (const f of files) {
+    const path = f.path.replace(/^(\.\/)+/, "").replace(/^\/+/, "");
+    if (!isValidSitePath(path)) throw new CliError(`Invalid file path: "${f.path}"`);
+    if (seen.has(path)) throw new CliError(`"${path}" is listed twice`);
+    seen.add(path);
+    const bytes = Buffer.from(f.content, f.encoding === "base64" ? "base64" : "utf8");
+    total += bytes.length;
+    if (total > MAX_DEPLOY_BYTES)
+      throw new CliError(`The site is larger than ${formatBytes(MAX_DEPLOY_BYTES)}`);
+    const target = join4(dir, ...path.split("/"));
+    await mkdir3(dirname2(target), { recursive: true });
+    await writeFile3(target, bytes);
+  }
+}
+function describeError(error) {
+  if (error instanceof CliError && error.exitCode === EXIT_NOT_LOGGED_IN) return LOGIN_HINT;
+  if (error instanceof CliApiError && error.status === 401) return LOGIN_HINT;
+  if (error instanceof CliError)
+    return error.hint ? `${error.message}
+${error.hint}` : error.message;
+  return error instanceof Error ? error.message : String(error);
+}
+async function runMcpServer(deps = {}) {
+  const server = createMcpServer(deps);
+  await server.connect(new StdioServerTransport());
+}
+
+// src/cli.ts
+var program = new Command();
+program.name(BIN_NAME).description("Fling a folder of static files at Fling and get a link back").version(VERSION).option(
+  "--server <url>",
+  `server URL (default: $${ENV.url} or config, else ${DEFAULT_SERVER_URL})`
+).option("--json", "print JSON instead of human output", false).showHelpAfterError().addHelpText(
+  "after",
+  `
+Examples:
+  $ ${BIN_NAME} login
+  $ ${BIN_NAME} ./dist --name my-app     deploy \u2192 https://my-app.fling.labs.nearform.com
+  $ ${BIN_NAME} ./dist --yes             no prompts (CI): use the generated name, fail if it is taken
+  $ ${BIN_NAME} "Pitch Deck.html"        a single page; found in Downloads if it is not here
+  $ ${BIN_NAME} site.zip                 a zip of a site
+  $ ${BIN_NAME} share my-app             public link for people outside Nearform
+
+Exit codes: 0 ok \xB7 1 error \xB7 2 not logged in \xB7 3 forbidden
+Env:        ${ENV.apiKey} \xB7 ${ENV.url} \xB7 ${ENV.configDir} \xB7 ${ENV.debug}`
+);
+function action(handler) {
+  return async (...args) => {
+    const command = args.at(-1);
+    const globals = command.optsWithGlobals();
+    let ctx;
+    try {
+      ctx = await createContext({ server: globals.server, json: globals.json });
+      await handler(ctx, ...args.slice(0, -1));
+    } catch (error) {
+      report(error, ctx);
+      process.exitCode = exitCodeFor(error);
+    }
+  };
+}
+function report(error, ctx) {
+  const log = ctx?.log ?? createLogger();
+  const message = error instanceof Error ? error.message : String(error);
+  log.error(message);
+  if (error instanceof CliError && error.hint) log.hint(error.hint);
+  if (ctx?.config.debug && error instanceof Error && error.stack) log.hint(error.stack);
+  if (ctx?.json) {
+    const code = error.code;
+    process.stdout.write(
+      `${formatJson({ error: { message, exitCode: exitCodeFor(error), ...typeof code === "string" ? { code } : {} } })}
+`
+    );
+  }
+}
+program.command("deploy [path]", { isDefault: true }).description(
+  "deploy a folder (default: .), a single .html file, a .zip or any file \u2014 the default command, so `fling ./dist` works. A path that does not exist is looked up by name in Downloads, Desktop and Claude output folders"
+).option(
+  "-n, --name <name>",
+  "site name \u2014 names are global, first come first served (default: generated from the project and folder, e.g. rocketpod-docs; you confirm it on a terminal)"
+).option("--spa", "single-page app: serve index.html for unknown paths").option("--public", "make the site public (default: Nearform sign-in required)").option(
+  "-y, --yes",
+  "never prompt: accept the generated name; without index.html, list the HTML pages (or fling anyway if there are none)"
+).option("--list-html", "no index.html at the root: generate one listing the HTML pages").option("--no-list-html", "no index.html at the root: fling anyway (the root will 404)").action(
+  action(
+    (ctx, path, opts) => runDeploy(ctx, path, opts)
+  )
+);
+program.command("login").description("sign in through the browser and store an API key").action(action((ctx) => runLogin(ctx)));
+program.command("logout").description("remove the stored API key").action(action((ctx) => runLogout(ctx)));
+program.command("whoami").description("show the signed-in user").action(action((ctx) => runWhoami(ctx)));
+program.command("ls").alias("list").description("list your sites").option("--archived", "list archived sites").action(action((ctx, opts) => runList(ctx, opts)));
+program.command("info <name>").description("show a site").action(action((ctx, name) => runInfo(ctx, name)));
+program.command("versions <name>").description("list a site's versions (* = live)").action(action((ctx, name) => runVersions(ctx, name)));
+program.command("files <name> [versionId]").description("list the files in a site's live version (or in versionId)").action(
+  action((ctx, name, versionId) => runFiles(ctx, name, versionId))
+);
+program.command("rollback <name> <versionId>").description("serve an earlier version again").action(action((ctx, name, versionId) => runRollback(ctx, name, versionId)));
+program.command("share <name>").description("print (or create) a public share link \u2014 anyone with it can view the site").option("--refresh", "replace the link; the old one stops working").option("--revoke", "remove the link").action(
+  action(
+    (ctx, name, opts) => runShare(ctx, name, opts)
+  )
+);
+program.command("visibility <name> <visibility>").description("private (Nearform sign-in) or public (anyone)").action(action((ctx, name, visibility) => runVisibility(ctx, name, visibility)));
+program.command("archive <name>").description("take a site offline (404) but keep its files; undo with unarchive").action(action((ctx, name) => runArchive(ctx, name)));
+program.command("unarchive <name>").description("bring an archived site back").action(action((ctx, name) => runArchive(ctx, name, true)));
+program.command("rm <name>").alias("delete").description("delete a site and all its versions (asks first unless --yes)").option("-y, --yes", "do not ask for confirmation").action(action((ctx, name, opts) => runRemove(ctx, name, opts)));
+program.command("mcp").description("run the MCP server on stdio (used by the Claude Code plugin)").action(async (_opts, command) => {
+  const globals = command.optsWithGlobals();
+  await runMcpServer({ server: globals.server });
+});
+program.parseAsync(process.argv);
+//# sourceMappingURL=cli.js.map