@drop2run/mcp 0.6.0 → 0.8.0

package/README.md

@@ -1,6 +1,6 @@
 # @drop2run/mcp
 
-An MCP server that lets Claude — or any MCP client — publish what it made to
+An MCP server that lets any MCP client — Claude, Cursor, VS Code, Codex, Gemini CLI — publish what it made to
 [Drop2Run](https://dropto.run): an HTML page, a markdown note, a folder of documents or a built site. It
 returns a live HTTPS URL.
 
@@ -35,11 +35,29 @@ add this to `claude_desktop_config.json` and restart the app:
 That file is at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS, and
 `%APPDATA%\Claude\claude_desktop_config.json` on Windows.
 
+**Cursor** — the same `mcpServers` block with `"type": "stdio"` added, in `~/.cursor/mcp.json` (or `.cursor/mcp.json` for one
+project). **Gemini CLI** — the same block, in `~/.gemini/settings.json`.
+
+**VS Code** — one command:
+
+```bash
+code --add-mcp '{"name":"drop2run","command":"npx","args":["-y","@drop2run/mcp"]}'
+```
+
+**Codex** — one command:
+
+```bash
+codex mcp add drop2run -- npx -y @drop2run/mcp
+```
+
+Zed and the rest: [dropto.run/docs/agents](https://dropto.run/docs/agents) has the file and the shape
+for each client.
+
 Nothing is installed globally either way — `npx` fetches the package when the client starts it.
 
 ## Sign in
 
-Ask for a publish. If there is no token yet, Claude calls the `login` tool, a browser tab opens, you
+Ask for a publish. If there is no token yet, the agent calls the `login` tool, a browser tab opens, you
 approve the sign-in, and the publish carries on. Nothing to install, nothing to paste.
 
 The token lands in `~/.config/drop2run/config.json` with mode `0600` — the same file the `drop2run`
@@ -47,9 +65,9 @@ CLI uses, so signing in once covers both. It is read on every call rather than a
 effect without restarting the client.
 
 **No browser on this machine?** In a container, over SSH, on a remote host, `login_code` gives a short
-code to enter at <https://dropto.run/device> from any other device.
+code to enter at <https://app.dropto.run/device> from any other device.
 
-**Or set a token yourself.** Create one at <https://dropto.run/account/tokens> and either put it in
+**Or set a token yourself.** Create one at <https://app.dropto.run/account/tokens> and either put it in
 `~/.config/drop2run/config.json` as `{"token": "d2r_..."}`, which needs no restart, or set
 `DROP2RUN_TOKEN` in the environment the client starts the server in. The environment takes precedence
 over the file — and because it is read once at startup, setting it in a shell afterwards changes
@@ -67,6 +85,7 @@ lose it.
 | `publish_files` | Publishes files Claude wrote — a page, a markdown note, several files together |
 | `publish_dir` | Publishes a folder, given its absolute path |
 | `list_sites` | Lists the sites on the account |
+| `list_folders` | Lists the account's folders, each with the path `folder` accepts |
 | `delete_site` | Deletes a site permanently, subdomain included — requires the subdomain repeated as `confirm` |
 
 Both publish tools take an optional `site` — a subdomain or site id to publish over. Leave it out and a
@@ -78,6 +97,11 @@ afterwards, and a site made under a guessed one has to be deleted by hand. `site
 opposites — one publishes over a site that exists, the other creates one that does not — so passing both
 is refused rather than resolved.
 
+And both take an optional `folder`, which files the new site in one of the account's dashboard folders —
+by path such as `Clients/Acme`, or by the id `list_folders` shows. Like `subdomain` it only describes a new
+site, so it cannot be combined with `site`. It never creates a folder: one that does not exist is refused
+with the list of those that do, and nothing is published.
+
 Both sign-in tools answer "not approved yet" rather than failing while they wait, and calling them
 again keeps waiting on the same sign-in. Neither replaces a token that is already stored unless asked
 to with `replace`.

package/dist/index.js

@@ -8,64 +8,13 @@ import { createServer as createServer$1 } from "node:http";
 import { realpath, readdir, stat, readFile } from "node:fs/promises";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-async function call(credentials, path, init = {}) {
-  const response = await fetch(`${credentials.apiBaseUrl}/${path}`, {
-    ...init,
-    headers: {
-      ...init.headers,
-      Authorization: `Bearer ${credentials.token}`,
-      ...init.body === void 0 ? {} : { "Content-Type": "application/json" }
-    }
-  });
-  if (!response.ok) {
-    const problem = await response.json().catch(() => null);
-    throw new Error(problem?.detail ?? `The API answered ${response.status}.`);
-  }
-  return await response.json();
-}
-async function findSite(credentials, site) {
-  const wanted = site.trim().toLowerCase();
-  const found = (await listSites(credentials)).find(
-    (candidate) => candidate.siteId.toLowerCase() === wanted || candidate.subdomain.toLowerCase() === wanted
-  );
-  if (found === void 0) {
-    throw new Error(`No site of yours is called "${site}". \`drop2run ls\` shows what exists.`);
-  }
-  return found;
-}
-async function deleteSite(credentials, siteId) {
-  const response = await fetch(`${credentials.apiBaseUrl}/sites/${encodeURIComponent(siteId)}`, {
-    method: "DELETE",
-    headers: { Authorization: `Bearer ${credentials.token}` }
-  });
-  if (!response.ok) {
-    const problem = await response.json().catch(() => null);
-    throw new Error(problem?.detail ?? `The API answered ${response.status}.`);
-  }
-}
-async function listSites(credentials) {
-  const body = await call(credentials, "sites");
-  return body.sites;
-}
-async function createSite(credentials, subdomain) {
-  const created = await call(
-    credentials,
-    "sites",
-    {
-      method: "POST",
-      // An absent field rather than a null one, because the API reads null, empty and missing the
-      // same way and a body carrying only what was asked for is the one that reads correctly in a
-      // log.
-      body: JSON.stringify(subdomain === void 0 ? {} : { subdomain })
-    }
-  );
-  return { ...created, name: null };
-}
 const TOKEN_VARIABLE = "DROP2RUN_TOKEN";
 function configPath() {
   return join(homedir(), ".config", "drop2run", "config.json");
 }
 const DEFAULT_API_BASE_URL = "https://dropto.run/api";
+const PRODUCTION_SITE_ORIGIN = "https://dropto.run";
+const PRODUCTION_DASHBOARD_ORIGIN = "https://app.dropto.run";
 function loadCredentials(env = process.env, read = (path) => readFileSync(path, "utf8")) {
   let stored = {};
   try {
@@ -89,7 +38,8 @@ function resolveApiBaseUrl(env = process.env, read = (path) => readFileSync(path
   return url.replace(/\/+$/, "");
 }
 function dashboardUrlFor(apiBaseUrl) {
-  return apiBaseUrl.replace(/\/+$/, "").replace(/\/api$/, "");
+  const origin = apiBaseUrl.replace(/\/+$/, "").replace(/\/api$/, "");
+  return origin === PRODUCTION_SITE_ORIGIN ? PRODUCTION_DASHBOARD_ORIGIN : origin;
 }
 function saveToken(token, path = configPath()) {
   let existing = {};
@@ -116,14 +66,14 @@ function missingCredentialsMessage(surface = "cli") {
   ] : ["Run `drop2run login` to sign in through a browser, which stores one for you."];
   const byHand = surface === "mcp" ? [
     "To set one without signing in here, create a token at",
-    "https://dropto.run/account/tokens and either:",
+    "https://app.dropto.run/account/tokens and either:",
     `  - put it in ${configPath()} as {"token": "d2r_..."}, which this`,
     "    server reads on every call and needs no restart, or",
     `  - set ${TOKEN_VARIABLE} in the environment and restart this server, since it reads`,
     "    the environment it was started in."
   ] : [
     "For CI, or where no browser can be opened, create a token at",
-    "https://dropto.run/account/tokens and either:",
+    "https://app.dropto.run/account/tokens and either:",
     `  - set ${TOKEN_VARIABLE} in the environment, or`,
     `  - put it in ${configPath()} as {"token": "d2r_..."}`
   ];
@@ -137,6 +87,131 @@ function missingCredentialsMessage(surface = "cli") {
     "The token is shown once when it is created and cannot be recovered afterwards."
   ].join("\n");
 }
+async function call(credentials, path, init = {}) {
+  const response = await fetch(`${credentials.apiBaseUrl}/${path}`, {
+    ...init,
+    headers: {
+      ...init.headers,
+      Authorization: `Bearer ${credentials.token}`,
+      ...init.body === void 0 ? {} : { "Content-Type": "application/json" }
+    }
+  });
+  if (!response.ok) {
+    const problem = await response.json().catch(() => null);
+    throw new Error(problem?.detail ?? `The API answered ${response.status}.`);
+  }
+  return await response.json();
+}
+async function findSite(credentials, site) {
+  const found = await lookUpSite(credentials, site);
+  if (found === void 0) {
+    throw new Error(`No site of yours is called "${site}". \`drop2run ls\` shows what exists.`);
+  }
+  return found;
+}
+const SITE_ID_SHAPE = /^[0-9a-z]{26}$/i;
+async function lookUpSite(credentials, site) {
+  const wanted = site.trim().toLowerCase();
+  if (wanted === "") return void 0;
+  const { sites } = await call(
+    credentials,
+    `sites?pageSize=${SITES_PER_REQUEST}&q=${encodeURIComponent(wanted)}`
+  );
+  const bySubdomain = sites.find((candidate) => candidate.subdomain.toLowerCase() === wanted);
+  if (bySubdomain !== void 0) return bySubdomain;
+  if (!SITE_ID_SHAPE.test(wanted)) return void 0;
+  const response = await fetch(
+    `${credentials.apiBaseUrl}/sites/${encodeURIComponent(wanted.toUpperCase())}`,
+    { headers: { Authorization: `Bearer ${credentials.token}` } }
+  );
+  if (response.status === 404) return void 0;
+  if (!response.ok) {
+    const problem = await response.json().catch(() => null);
+    throw new Error(problem?.detail ?? `The API answered ${response.status}.`);
+  }
+  const detail = await response.json();
+  return { siteId: detail.siteId, subdomain: detail.subdomain, url: detail.url, name: detail.name };
+}
+async function deleteSite(credentials, siteId) {
+  const response = await fetch(`${credentials.apiBaseUrl}/sites/${encodeURIComponent(siteId)}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${credentials.token}` }
+  });
+  if (!response.ok) {
+    const problem = await response.json().catch(() => null);
+    throw new Error(problem?.detail ?? `The API answered ${response.status}.`);
+  }
+}
+const SITES_PER_REQUEST = 100;
+async function listSites(credentials) {
+  const body = await call(
+    credentials,
+    `sites?pageSize=${SITES_PER_REQUEST}`
+  );
+  return { sites: body.sites, total: body.total };
+}
+async function createSite(credentials, subdomain, folderId) {
+  const created = await call(
+    credentials,
+    "sites",
+    {
+      method: "POST",
+      // Absent fields rather than null ones, because the API reads null, empty and missing the same
+      // way and a body carrying only what was asked for is the one that reads correctly in a log.
+      body: JSON.stringify({
+        ...subdomain === void 0 ? {} : { subdomain },
+        ...folderId === void 0 ? {} : { folderId }
+      })
+    }
+  );
+  return { ...created, name: null };
+}
+async function listFolders(credentials) {
+  const body = await call(credentials, "site-folders");
+  const byId = new Map(body.folders.map((folder) => [folder.folderId, folder]));
+  const pathOf = (folderId) => {
+    const names = [];
+    let cursor = byId.get(folderId);
+    while (cursor !== void 0 && names.length <= byId.size) {
+      names.unshift(cursor.name);
+      cursor = cursor.parentId === null ? void 0 : byId.get(cursor.parentId);
+    }
+    return names.join("/");
+  };
+  return body.folders.map((folder) => ({ folderId: folder.folderId, path: pathOf(folder.folderId) })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function comparablePath(path) {
+  return path.split("/").map((name) => name.trim()).filter((name) => name !== "").join("/").toLowerCase();
+}
+const FOLDERS_LISTED_ON_MISS = 20;
+async function resolveFolder(credentials, folder) {
+  const wanted = comparablePath(folder);
+  if (wanted === "") {
+    throw new Error(
+      `"${folder}" does not name a folder. Leave the folder out to put the site at the top level.`
+    );
+  }
+  const folders = await listFolders(credentials);
+  const byId = folders.find((candidate) => candidate.folderId.toLowerCase() === wanted);
+  if (byId !== void 0) return byId.folderId;
+  const matches = folders.filter((candidate) => comparablePath(candidate.path) === wanted);
+  if (matches.length === 1 && matches[0] !== void 0) return matches[0].folderId;
+  if (matches.length > 1) {
+    throw new Error(
+      `More than one folder is at "${folder}", because a folder name can contain "/". Name it by id instead: ${matches.map((match) => match.folderId).join(", ")}.`
+    );
+  }
+  if (folders.length === 0) {
+    throw new Error(
+      `No folder of yours is called "${folder}" — this account has no folders yet. Make one in the dashboard at ${dashboardUrlFor(credentials.apiBaseUrl)}, or leave the folder out.`
+    );
+  }
+  const listed = folders.slice(0, FOLDERS_LISTED_ON_MISS).map((candidate) => candidate.path);
+  const more = folders.length - listed.length;
+  throw new Error(
+    `No folder of yours is called "${folder}". Your folders: ${listed.join(", ")}${more > 0 ? `, and ${more} more` : ""}.`
+  );
+}
 function newAttempt() {
   const verifier = randomBytes(32).toString("base64url");
   return {
@@ -272,6 +347,12 @@ async function exchange(apiBaseUrl, code, verifier) {
   const body = await response.json();
   return { token: body.token, name: body.name, email: body.email };
 }
+function sizeOf(content) {
+  return ArrayBuffer.isView(content) ? content.byteLength : content.size;
+}
+async function bytesOf(content) {
+  return ArrayBuffer.isView(content) ? content : new Uint8Array(await content.arrayBuffer());
+}
 class DeployError extends Error {
   /**
    * @param code Stable code, either an API error type (`quota_exceeded`, `unsafe_path`, …) or one of
@@ -308,20 +389,55 @@ const ClientErrorCode = {
   /** The user cancelled. */
   Cancelled: "cancelled",
   /** An upload kept failing after every retry. */
-  UploadFailed: "upload_failed"
+  UploadFailed: "upload_failed",
+  /**
+   * The browser could not hold what was dropped in memory. Raised when allocating the buffer for a
+   * large zip or file fails, which a browser reports as a `RangeError` rather than as anything that
+   * names memory.
+   */
+  OutOfMemory: "out_of_memory",
+  /**
+   * A dropped file could not be read when it came to be hashed. Files from a folder stay on disk until
+   * then, so one moved, deleted or changed after the drop fails here rather than at the drop.
+   */
+  ReadFailed: "read_failed",
+  /**
+   * A control-plane call got no answer: the connection failed before a response arrived, or the
+   * request timeout passed. Distinct from an HTTP error, which is an answer — this one says nothing
+   * about whether the server acted, which is why only an idempotent call may retry on it.
+   */
+  NetworkFailed: "network_failed"
 };
+function describeError(error) {
+  const parts = [];
+  let current = error;
+  for (let depth = 0; depth < 5 && current !== void 0 && current !== null; depth++) {
+    if (current instanceof Error) {
+      const code = current.code;
+      parts.push(typeof code === "string" ? `${current.message} (${code})` : current.message);
+      current = current.cause;
+    } else {
+      parts.push(String(current));
+      break;
+    }
+  }
+  return parts.join(" ← ");
+}
 const ACCOUNT_HEADER = "X-Drop2Run-Account";
 const CLAIM_TOKEN_HEADER = "X-Claim-Token";
+const DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+const COMPLETE_RETRY_DELAYS_MS = [1e3, 4e3];
 async function prepareDeploy(siteId, files, options, signal) {
   const manifest = files.map((file) => ({
     path: file.path,
     sha256: file.sha256,
-    size: file.bytes.length
+    size: sizeOf(file.bytes)
   }));
   const prepared = await request(
     `sites/${encodeURIComponent(siteId)}/deploys/prepare`,
     { files: manifest },
-    options
+    options,
+    signal
   );
   return { ...prepared, uploadUrl: absolute(prepared.uploadUrl, options.baseUrl) };
 }
@@ -331,31 +447,65 @@ function absolute(uploadUrl, baseUrl) {
   return new URL(uploadUrl, baseUrl).toString();
 }
 async function completeDeploy(siteId, deployId, options, signal, name) {
-  return request(
-    `sites/${encodeURIComponent(siteId)}/deploys/${encodeURIComponent(deployId)}/complete`,
-    // A bodyless POST when there is no name to send, which is what this call has always been. The
-    // server treats an absent body and an absent field identically, so nothing depends on which of
-    // the two a client picks.
-    name === null || name === void 0 ? void 0 : { name },
-    options
-  );
+  const path = `sites/${encodeURIComponent(siteId)}/deploys/${encodeURIComponent(deployId)}/complete`;
+  const body = name === null || name === void 0 ? void 0 : { name };
+  const delay = options.delay ?? wait;
+  for (let attempt2 = 0; ; attempt2++) {
+    try {
+      return await request(path, body, options, signal);
+    } catch (error) {
+      const unanswered = error instanceof DeployError && error.code === ClientErrorCode.NetworkFailed;
+      if (!unanswered || attempt2 >= COMPLETE_RETRY_DELAYS_MS.length || signal?.aborted) throw error;
+      await delay(COMPLETE_RETRY_DELAYS_MS[attempt2] ?? 1e3);
+    }
+  }
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function request(path, body, options, signal) {
   const doFetch = options.fetch ?? globalFetch$1();
   const base = options.baseUrl ?? "/api";
+  const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const headers = {};
   if (body !== void 0) headers["Content-Type"] = "application/json";
   if (options.claimToken) headers[CLAIM_TOKEN_HEADER] = options.claimToken;
   if (options.token) headers.Authorization = `Bearer ${options.token}`;
   if (options.accountId) headers[ACCOUNT_HEADER] = options.accountId;
-  const response = await doFetch(`${base}/${path}`, {
-    method: "POST",
-    headers,
-    ...body === void 0 ? {} : { body: JSON.stringify(body) },
-    ...{}
-  });
-  if (!response.ok) throw await problemToError(response);
-  return await response.json();
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const response = await doFetch(`${base}/${path}`, {
+      method: "POST",
+      headers,
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: controller.signal
+    });
+    if (!response.ok) throw await problemToError(response);
+    return await response.json();
+  } catch (error) {
+    if (error instanceof DeployError || signal?.aborted) throw error;
+    if (timedOut) {
+      throw new DeployError(
+        ClientErrorCode.NetworkFailed,
+        `The server did not answer within ${Math.round(timeoutMs / 1e3)} seconds.`,
+        { path, cause: describeError(error) }
+      );
+    }
+    if (error instanceof TypeError) {
+      throw new DeployError(ClientErrorCode.NetworkFailed, "Could not reach the server.", {
+        path,
+        cause: describeError(error)
+      });
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
 }
 function globalFetch$1() {
   return globalThis.fetch.bind(globalThis);
@@ -854,17 +1004,29 @@ function extensionOf(path) {
   return dot <= 0 ? "" : name.slice(dot).toLowerCase();
 }
 async function sha256Hex(bytes) {
-  const digest = await crypto.subtle.digest("SHA-256", bytes.slice().buffer);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
   return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 async function hashAll(files, onProgress, signal) {
   const hashed = [];
   for (const [index, file] of files.entries()) {
-    hashed.push({ ...file, sha256: await sha256Hex(file.bytes) });
+    hashed.push({ ...file, sha256: await sha256Hex(await readForHash(file)) });
     onProgress?.(index + 1, files.length);
   }
   return hashed;
 }
+async function readForHash(file) {
+  try {
+    return await bytesOf(file.bytes);
+  } catch (error) {
+    if (error instanceof RangeError) throw error;
+    throw new DeployError(
+      ClientErrorCode.ReadFailed,
+      `Could not read ${file.path}. It may have been moved, renamed or changed since you dropped it — drop the folder again.`,
+      { path: file.path, cause: describeError(error) }
+    );
+  }
+}
 const IGNORED_EXACT = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", "desktop.ini", ".gitignore", ".gitkeep"]);
 const IGNORED_DIRECTORIES = [
   "__MACOSX",
@@ -874,7 +1036,11 @@ const IGNORED_DIRECTORIES = [
   ".hg",
   ".idea",
   ".vscode",
-  ".claude"
+  ".claude",
+  ".agents",
+  ".cursor",
+  ".codex",
+  ".gemini"
 ];
 function shouldIgnore(path) {
   const segments = path.split("/");
@@ -936,7 +1102,7 @@ function checkLimits(files, limits) {
     );
   }
   const refusal = sizeRefusal(
-    files.map((file) => ({ path: file.path, size: file.bytes.length })),
+    files.map((file) => ({ path: file.path, size: sizeOf(file.bytes) })),
     limits
   );
   if (refusal) throw refusal;
@@ -977,13 +1143,24 @@ const HEAD_BYTES = 64 * 1024;
 const TITLE_SEPARATORS = ["|", "·", "—", "–", " - "];
 function suggestSiteName(files) {
   const index = files.find((file) => file.path === "index.html");
-  if (index === void 0) return null;
+  if (index === void 0 || !ArrayBuffer.isView(index.bytes)) return null;
   try {
     return nameFromHtml(decodeHead(index.bytes));
   } catch {
     return null;
   }
 }
+async function readSiteName(files) {
+  const index = files.find((file) => file.path === "index.html");
+  if (index === void 0) return null;
+  if (ArrayBuffer.isView(index.bytes)) return suggestSiteName(files);
+  try {
+    const head = new Uint8Array(await index.bytes.slice(0, HEAD_BYTES).arrayBuffer());
+    return suggestSiteName([{ path: index.path, bytes: head }]);
+  } catch {
+    return null;
+  }
+}
 function decodeHead(bytes) {
   return new TextDecoder("utf-8", { fatal: false }).decode(
     bytes.subarray(0, HEAD_BYTES)
@@ -1015,7 +1192,7 @@ function matchTag(html, tag) {
   const match = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}\\s*>`, "i").exec(
     html
   );
-  return match?.[1] ?? null;
+  return match?.[1] === void 0 ? null : decodeEntities(match[1]);
 }
 function matchOgSiteName(html) {
   const patterns = [
@@ -1024,10 +1201,56 @@ function matchOgSiteName(html) {
   ];
   for (const pattern of patterns) {
     const match = pattern.exec(html);
-    if (match?.[1] !== void 0) return match[1];
+    if (match?.[1] !== void 0) return decodeEntities(match[1]);
   }
   return null;
 }
+const LATIN1_ENTITIES = "nbsp iexcl cent pound curren yen brvbar sect uml copy ordf laquo not shy reg macr deg plusmn sup2 sup3 acute micro para middot cedil sup1 ordm raquo frac14 frac12 frac34 iquest Agrave Aacute Acirc Atilde Auml Aring AElig Ccedil Egrave Eacute Ecirc Euml Igrave Iacute Icirc Iuml ETH Ntilde Ograve Oacute Ocirc Otilde Ouml times Oslash Ugrave Uacute Ucirc Uuml Yacute THORN szlig agrave aacute acirc atilde auml aring aelig ccedil egrave eacute ecirc euml igrave iacute icirc iuml eth ntilde ograve oacute ocirc otilde ouml divide oslash ugrave uacute ucirc uuml yacute thorn yuml".split(" ");
+const NAMED_ENTITIES = new Map([
+  ...LATIN1_ENTITIES.map((name, index) => [name, 160 + index]),
+  ["amp", 38],
+  ["lt", 60],
+  ["gt", 62],
+  ["quot", 34],
+  ["apos", 39],
+  ["ensp", 8194],
+  ["emsp", 8195],
+  ["thinsp", 8201],
+  ["ndash", 8211],
+  ["mdash", 8212],
+  ["lsquo", 8216],
+  ["rsquo", 8217],
+  ["sbquo", 8218],
+  ["ldquo", 8220],
+  ["rdquo", 8221],
+  ["bdquo", 8222],
+  ["dagger", 8224],
+  ["Dagger", 8225],
+  ["bull", 8226],
+  ["hellip", 8230],
+  ["prime", 8242],
+  ["lsaquo", 8249],
+  ["rsaquo", 8250],
+  ["euro", 8364],
+  ["trade", 8482],
+  ["larr", 8592],
+  ["rarr", 8594],
+  ["hearts", 9829]
+]);
+function decodeEntities(text) {
+  return text.replace(
+    /&(?:#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6})|([a-zA-Z][a-zA-Z0-9]{1,31}));/g,
+    (whole, decimal, hex, name) => {
+      if (name !== void 0) {
+        const code2 = NAMED_ENTITIES.get(name);
+        return code2 === void 0 ? whole : String.fromCodePoint(code2);
+      }
+      const code = decimal !== void 0 ? Number(decimal) : Number.parseInt(hex ?? "", 16);
+      const valid = code > 0 && code <= 1114111 && (code < 55296 || code > 57343);
+      return String.fromCodePoint(valid ? code : 65533);
+    }
+  );
+}
 const INVISIBLE = new RegExp(
   `[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}${String.fromCharCode(8203)}-${String.fromCharCode(8207)}${String.fromCharCode(8232)}-${String.fromCharCode(8238)}${String.fromCharCode(8288)}-${String.fromCharCode(8292)}${String.fromCharCode(8294)}-${String.fromCharCode(8303)}${String.fromCharCode(65279)}]`,
   "g"
@@ -1069,46 +1292,105 @@ function trimSuffix(title) {
   return title;
 }
 const DEFAULT_CONCURRENCY = 8;
+const DEFAULT_BYTES_IN_FLIGHT = 64 * 1024 * 1024;
 const DEFAULT_RETRIES = 3;
 const BACKOFF_MS = [1e3, 2e3, 4e3];
-async function uploadAll(targets, uploadUrl, files, onProgress, signal, deps = {}) {
-  const doFetch = deps.fetch ?? globalFetch();
+const DEFAULT_STALL_MS = 3e4;
+const PROGRESS_INTERVAL_MS = 200;
+class StalledError extends Error {
+  /** @param seconds How long nothing moved. */
+  constructor(seconds) {
+    super(`No data moved for ${seconds}s.`);
+    this.name = "StalledError";
+  }
+}
+async function uploadAll(targets, uploadUrl, files, onProgress, signal, deps = {}, onRetry) {
+  const put = deps.put ?? defaultTransport(deps.fetch);
   const delay = deps.delay ?? defaultDelay;
   const concurrency = deps.concurrency ?? DEFAULT_CONCURRENCY;
   const retries = deps.retries ?? DEFAULT_RETRIES;
+  const stallMs = deps.stallMs ?? DEFAULT_STALL_MS;
+  const now = deps.now ?? Date.now;
+  const maxBytesInFlight = deps.maxBytesInFlight ?? DEFAULT_BYTES_IN_FLIGHT;
   const byPath = new Map(files.map((file) => [file.path, file]));
   let nextIndex = 0;
   let done = 0;
-  let uploadedBytes = 0;
+  let failed = false;
+  let reserved = 0;
+  let waiting = [];
+  const acquire = async (size) => {
+    while (reserved > 0 && reserved + size > maxBytesInFlight) {
+      await new Promise((resolve) => waiting.push(resolve));
+    }
+    reserved += size;
+  };
+  const release = (size) => {
+    reserved -= size;
+    const woken = waiting;
+    waiting = [];
+    for (const wake of woken) wake();
+  };
+  let landedBytes = 0;
+  const inFlight = /* @__PURE__ */ new Map();
+  let lastReport = Number.NEGATIVE_INFINITY;
+  const report2 = (path) => {
+    if (onProgress === void 0) return;
+    const at = now();
+    if (path === void 0 && at - lastReport < PROGRESS_INTERVAL_MS) return;
+    lastReport = at;
+    let bytes = landedBytes;
+    for (const sent of inFlight.values()) bytes += sent;
+    onProgress(done, targets.length, bytes, path);
+  };
   const worker = async () => {
     for (; ; ) {
+      if (failed) return;
       const index = nextIndex++;
       const target = targets[index];
       if (target === void 0) return;
       const file = byPath.get(target.path);
       if (file === void 0) {
+        failed = true;
         throw new DeployError(
           ClientErrorCode.UploadFailed,
           `The server asked for ${target.path}, which is not in the manifest.`,
           { path: target.path }
         );
       }
-      await uploadOne(target, file, {
-        doFetch,
-        delay,
-        retries,
-        signal,
-        uploadUrl
-      });
+      const size = sizeOf(file.bytes);
+      await acquire(size);
+      try {
+        if (failed) return;
+        signal?.throwIfAborted();
+        await uploadOne(target, file, {
+          put,
+          delay,
+          retries,
+          signal,
+          uploadUrl,
+          stallMs,
+          onSent: (sent) => {
+            inFlight.set(index, sent);
+            report2();
+          },
+          onRetry: (attempt2, stalled) => {
+            inFlight.set(index, 0);
+            onRetry?.(target.path, attempt2, retries + 1, stalled);
+          }
+        });
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        release(size);
+      }
+      inFlight.delete(index);
       done += 1;
-      uploadedBytes += file.bytes.length;
-      onProgress?.(done, targets.length, uploadedBytes, file.path);
+      landedBytes += size;
+      report2(file.path);
     }
   };
-  const workers = Array.from(
-    { length: Math.min(concurrency, targets.length) },
-    worker
-  );
+  const workers = Array.from({ length: Math.min(concurrency, targets.length) }, worker);
   try {
     await Promise.all(workers);
   } catch (error) {
@@ -1120,39 +1402,122 @@ async function uploadOne(target, file, context) {
   for (let attempt2 = 0; attempt2 <= context.retries; attempt2++) {
     context.signal?.throwIfAborted();
     if (attempt2 > 0) {
+      context.onRetry(attempt2 + 1, lastError instanceof StalledError);
       await context.delay(BACKOFF_MS[attempt2 - 1] ?? BACKOFF_MS.at(-1) ?? 1e3);
       context.signal?.throwIfAborted();
     }
     try {
-      const response = await context.doFetch(context.uploadUrl, {
-        method: "PUT",
-        body: new Blob([file.bytes.slice().buffer]),
-        // The permit is the whole request. `Content-Length` is required by the Worker and cannot
-        // be set here — it is a forbidden header name — but the browser derives it from the body,
-        // which is exactly the length the token names.
-        headers: { Authorization: `Bearer ${target.token}` },
-        ...context.signal ? { signal: context.signal } : {}
+      const status = await context.put({
+        url: context.uploadUrl,
+        token: target.token,
+        body: untyped(file.bytes),
+        signal: context.signal,
+        onSent: context.onSent,
+        stallMs: context.stallMs
       });
-      if (response.ok) return;
-      if (response.status === 401 || response.status === 403 || response.status === 429) {
+      if (status >= 200 && status < 300) return;
+      if (status === 401 || status === 403 || status === 429) {
         throw new DeployError(
           ClientErrorCode.UploadFailed,
           `Upload of ${target.path} was refused. The upload window may have expired — try deploying again.`,
-          { path: target.path, status: response.status }
+          { path: target.path, status }
         );
       }
-      lastError = new Error(`HTTP ${response.status}`);
+      if (status === 413) {
+        throw new DeployError(
+          ClientErrorCode.UploadFailed,
+          `${target.path} is too large to upload in one request. Make it smaller, or leave it out of this publish.`,
+          { path: target.path, status }
+        );
+      }
+      lastError = new Error(`HTTP ${status}`);
     } catch (error) {
       if (error instanceof DeployError) throw error;
       if (isAbort(error)) throw cancelled();
       lastError = error;
     }
   }
-  throw new DeployError(
-    ClientErrorCode.UploadFailed,
-    `Could not upload ${target.path} after ${context.retries + 1} attempts.`,
-    { path: target.path, cause: String(lastError) }
-  );
+  const message = lastError instanceof StalledError ? `Upload of ${target.path} stopped moving and did not recover after ${context.retries + 1} attempts. Check your connection and try again.` : `Could not upload ${target.path} after ${context.retries + 1} attempts.`;
+  throw new DeployError(ClientErrorCode.UploadFailed, message, {
+    path: target.path,
+    cause: describeError(lastError)
+  });
+}
+function untyped(content) {
+  if (ArrayBuffer.isView(content) || content.type === "") return content;
+  return content.slice(0, content.size);
+}
+function defaultTransport(doFetch) {
+  if (doFetch !== void 0) return fetchTransport(doFetch);
+  const Xhr = globalThis.XMLHttpRequest;
+  return Xhr === void 0 ? fetchTransport(globalFetch()) : xhrTransport(Xhr);
+}
+function fetchTransport(doFetch) {
+  return async ({ url, token, body, signal }) => {
+    const response = await doFetch(url, {
+      method: "PUT",
+      // The view, not a copy. Wrapping it in `new Blob([body.slice().buffer])` made two extra
+      // full-size copies of every file in flight — eight at once, so up to 400 MB on a drop of
+      // 50 MB files. `fetch` sends exactly the range a view covers. The cast is TypeScript's
+      // SharedArrayBuffer distinction again; see `sha256Hex`. A `Blob` goes as it is, and the runtime
+      // streams it from disk.
+      body,
+      // The permit is the whole request. `Content-Length` is required by the Worker and cannot be
+      // set here — it is a forbidden header name — but the runtime derives it from the body, which
+      // is exactly the length the token names.
+      headers: { Authorization: `Bearer ${token}` },
+      ...signal ? { signal } : {}
+    });
+    return response.status;
+  };
+}
+function xhrTransport(Xhr) {
+  return ({ url, token, body, signal, onSent, stallMs }) => new Promise((resolve, reject) => {
+    const xhr = new Xhr();
+    let settled = false;
+    let timer;
+    const settle = (finish) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      finish();
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        xhr.abort();
+        settle(() => reject(new StalledError(Math.round(stallMs / 1e3))));
+      }, stallMs);
+    };
+    function onAbort() {
+      xhr.abort();
+      settle(() => reject(abortReason(signal)));
+    }
+    if (signal?.aborted) {
+      reject(abortReason(signal));
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    xhr.open("PUT", url);
+    xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+    xhr.upload.onprogress = (event) => {
+      arm();
+      onSent(event.loaded);
+    };
+    xhr.onprogress = arm;
+    xhr.onload = () => settle(() => resolve(xhr.status));
+    xhr.onerror = () => settle(() => reject(new TypeError("Network error during upload.")));
+    arm();
+    xhr.send(body);
+  });
+}
+function abortReason(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof Error) return reason;
+  const error = new Error("Aborted.");
+  error.name = "AbortError";
+  return error;
 }
 function globalFetch() {
   return globalThis.fetch.bind(globalThis);
@@ -1166,9 +1531,17 @@ function isAbort(error) {
 function cancelled() {
   return new DeployError(ClientErrorCode.Cancelled, "Deploy cancelled.");
 }
+function outOfMemory(detail) {
+  return new DeployError(
+    ClientErrorCode.OutOfMemory,
+    "This browser ran out of memory reading what you dropped. Drop the unzipped folder instead, or try again in a desktop browser with fewer tabs open.",
+    detail
+  );
+}
 function asDeployError(error) {
   if (error instanceof DeployError) return error;
   if (isAbort(error)) return cancelled();
+  if (error instanceof RangeError) return outOfMemory(error.message);
   return new DeployError(
     ClientErrorCode.UploadFailed,
     error instanceof Error ? error.message : "Upload failed.",
@@ -1177,7 +1550,11 @@ function asDeployError(error) {
 }
 async function deploy(source, siteId, onProgress, signal, options = {}) {
   try {
-    const collected = await source(signal);
+    onProgress({ type: "reading", bytes: 0, total: 0 });
+    const collected = await source(
+      signal,
+      (bytes, total) => onProgress({ type: "reading", bytes, total })
+    );
     onProgress({ type: "collecting", files: collected.length });
     const rename = renameOfLoneHtmlPage(collected.map((file) => file.path));
     const files = rename === null ? collected : collected.map((file) => file.path === rename ? { ...file, path: "index.html" } : file);
@@ -1193,6 +1570,21 @@ async function deploy(source, siteId, onProgress, signal, options = {}) {
       onProgress({ type: "unchanged", url: prepared.url ?? "" });
       return;
     }
+    const sizes = new Map(hashed.map((file) => [file.path, sizeOf(file.bytes)]));
+    const totalBytes = prepared.upload.reduce(
+      (sum, target) => sum + (sizes.get(target.path) ?? 0),
+      0
+    );
+    if (prepared.upload.length > 0) {
+      onProgress({
+        type: "uploading",
+        done: prepared.reused,
+        total: prepared.total,
+        bytes: 0,
+        totalBytes,
+        reused: prepared.reused
+      });
+    }
     await uploadAll(
       prepared.upload,
       prepared.uploadUrl,
@@ -1202,11 +1594,13 @@ async function deploy(source, siteId, onProgress, signal, options = {}) {
         done: prepared.reused + done,
         total: prepared.total,
         bytes,
+        totalBytes,
         reused: prepared.reused,
-        path
+        ...path === void 0 ? {} : { path }
       }),
       signal,
-      options.upload
+      options.upload,
+      (path, attempt2, attempts, stalled) => onProgress({ type: "retrying", path, attempt: attempt2, attempts, stalled })
     );
     onProgress({ type: "completing", reused: prepared.reused });
     const completed = await completeDeploy(
@@ -1214,7 +1608,7 @@ async function deploy(source, siteId, onProgress, signal, options = {}) {
       prepared.deployId,
       options,
       signal,
-      suggestSiteName(files)
+      await readSiteName(files)
     );
     onProgress({ type: "done", url: completed.url, name: completed.name });
   } catch (error) {
@@ -1269,20 +1663,23 @@ function escapesRoot(root, candidate) {
   const inside = relative(root, candidate);
   return inside === "" || inside.startsWith("..");
 }
-async function resolveSite(credentials, site, subdomain) {
-  if (subdomain !== void 0) {
-    if (site !== void 0) {
-      throw new Error(
-        "Give either an existing site or a subdomain for a new one, not both: publishing over a site and creating one are different requests."
-      );
-    }
-    return await createSite(credentials, subdomain);
+async function resolveSite(credentials, site, newSite) {
+  const { subdomain, folder } = newSite;
+  if (site !== void 0 && subdomain !== void 0) {
+    throw new Error(
+      "Give either an existing site or a subdomain for a new one, not both: publishing over a site and creating one are different requests."
+    );
   }
-  if (site === void 0) return await createSite(credentials);
-  const wanted = site.trim().toLowerCase();
-  const found = (await listSites(credentials)).find(
-    (candidate) => candidate.siteId.toLowerCase() === wanted || candidate.subdomain.toLowerCase() === wanted
-  );
+  if (site !== void 0 && folder !== void 0) {
+    throw new Error(
+      "A folder only says where a new site goes, so it cannot be given with an existing site. Leave the site out to create one in that folder, or move the existing site from the dashboard."
+    );
+  }
+  if (site === void 0) {
+    const folderId = folder === void 0 ? void 0 : await resolveFolder(credentials, folder);
+    return await createSite(credentials, subdomain, folderId);
+  }
+  const found = await lookUpSite(credentials, site);
   if (found === void 0) {
     throw new Error(
       `No site of yours is called "${site}". Leave the site out to publish to a new one, or list your sites to see what exists.`
@@ -1290,8 +1687,8 @@ async function resolveSite(credentials, site, subdomain) {
   }
   return found;
 }
-async function publish(credentials, source, site, onProgress, subdomain) {
-  const target = await resolveSite(credentials, site, subdomain);
+async function publish(credentials, source, site, onProgress, newSite = {}) {
+  const target = await resolveSite(credentials, site, newSite);
   let files = 0;
   let url = target.url;
   let unchanged = false;
@@ -1321,11 +1718,11 @@ async function publish(credentials, source, site, onProgress, subdomain) {
   });
   return { url, siteId: target.siteId, subdomain: target.subdomain, files, unchanged };
 }
-async function publishDirectory(credentials, directory, site, onProgress, subdomain) {
+async function publishDirectory(credentials, directory, site, onProgress, newSite = {}) {
   const found = await stat(directory).catch(() => null);
   if (found === null) throw new Error(`There is no folder at ${directory}.`);
   if (!found.isDirectory()) throw new Error(`${directory} is a file, not a folder to publish.`);
-  return await publish(credentials, directorySource(directory), site, onProgress, subdomain);
+  return await publish(credentials, directorySource(directory), site, onProgress, newSite);
 }
 function cleanPath(path) {
   const cleaned = path.trim().replaceAll("\\", "/").replace(/^\.?\//, "");
@@ -1339,7 +1736,7 @@ function cleanPath(path) {
   }
   return cleaned;
 }
-async function publishFiles(credentials, files, site, subdomain) {
+async function publishFiles(credentials, files, site, newSite = {}) {
   const encoder = new TextEncoder();
   const collected = files.map((file) => ({
     path: cleanPath(file.path),
@@ -1350,7 +1747,7 @@ async function publishFiles(credentials, files, site, subdomain) {
     if (seen.has(file.path)) throw new Error(`Two files were given the same path: ${file.path}`);
     seen.add(file.path);
   }
-  return publish(credentials, async () => collected, site, void 0, subdomain);
+  return publish(credentials, async () => collected, site, void 0, newSite);
 }
 const DEFAULT_WAIT_SECONDS = 120;
 const MAX_WAIT_SECONDS = 240;
@@ -1528,7 +1925,7 @@ async function signInWithCode(waitSeconds, replace = false) {
     "Call this tool again to keep waiting. Nothing has been changed yet."
   ].join("\n");
 }
-const SERVER_VERSION = "0.6.0";
+const SERVER_VERSION = "0.8.0";
 const CREDENTIAL_WRITE = {
   readOnlyHint: false,
   destructiveHint: false,
@@ -1566,6 +1963,15 @@ const SITE_OUTPUT = z.object({
   url: z.string().describe("Its live URL."),
   name: z.string().nullable().describe("What it is called, or null when it has no name.")
 });
+const FOLDER_OUTPUT = z.object({
+  folderId: z.string().describe("Identifier of the folder, which `folder` accepts."),
+  path: z.string().describe(
+    "Every name from the top level down to it, joined with /, which `folder` accepts too."
+  )
+});
+const FOLDER_INPUT = z.string().optional().describe(
+  "Folder to file the new site in, when the person asked for one: its path of names such as Clients/Acme, or its id from list_folders. Only for a new site — do not pass it together with `site`; moving an existing site is done in the dashboard. It never creates a folder: a folder that does not exist is refused with the list of those that do, and nothing is published."
+);
 function say(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
 }
@@ -1613,6 +2019,10 @@ function createServer() {
         "be deleted by hand. `site` and `subdomain` are opposites: one publishes over a site that",
         "exists, the other creates one that does not. Never pass both.",
         "",
+        "A new site goes at the top level of the dashboard unless `folder` files it somewhere. Pass",
+        "it when the person named a folder, as its path (Clients/Acme) or its id; list_folders shows",
+        "what exists. Like `subdomain`, it only describes a new site, so never pass it with `site`.",
+        "",
         "A site needs an index.html at its top level, or at least one document (.md, .markdown,",
         ".pdf, .docx, .xlsx or .epub), which publishes as a documents site and is read through a",
         "viewer. So one page goes at index.html, and a single note is a whole publish that needs",
@@ -1674,13 +2084,14 @@ function createServer() {
         site: z.string().optional().describe("Subdomain or site id to publish over. Omit to create a new site."),
         subdomain: z.string().optional().describe(
           "Subdomain to create the new site under, when the person asked for a particular address. Only for a new site: leave it out to publish over an existing one, and do not pass it together with `site`. Ask rather than inventing one — the name is the URL somebody will be given, it cannot be changed afterwards, and an unused site made under a guessed name has to be deleted by hand."
-        )
+        ),
+        folder: FOLDER_INPUT
       },
       outputSchema: PUBLISH_OUTPUT,
       annotations: REPLACES_A_SITE
     },
-    ({ files, site, subdomain }) => withCredentials(async (credentials) => {
-      const result = await publishFiles(credentials, files, site, subdomain);
+    ({ files, site, subdomain, folder }) => withCredentials(async (credentials) => {
+      const result = await publishFiles(credentials, files, site, { subdomain, folder });
       return report(describe(result), { ...result });
     })
   );
@@ -1694,13 +2105,17 @@ function createServer() {
         site: z.string().optional().describe("Subdomain or site id to publish over. Omit to create a new site."),
         subdomain: z.string().optional().describe(
           "Subdomain to create the new site under, when the person asked for a particular address. Only for a new site: leave it out to publish over an existing one, and do not pass it together with `site`. Ask rather than inventing one — the name is the URL somebody will be given, it cannot be changed afterwards, and an unused site made under a guessed name has to be deleted by hand."
-        )
+        ),
+        folder: FOLDER_INPUT
       },
       outputSchema: PUBLISH_OUTPUT,
       annotations: REPLACES_A_SITE
     },
-    ({ path, site, subdomain }) => withCredentials(async (credentials) => {
-      const result = await publishDirectory(credentials, path, site, void 0, subdomain);
+    ({ path, site, subdomain, folder }) => withCredentials(async (credentials) => {
+      const result = await publishDirectory(credentials, path, site, void 0, {
+        subdomain,
+        folder
+      });
       return report(describe(result), { ...result });
     })
   );
@@ -1741,15 +2156,36 @@ function createServer() {
       title: "List sites",
       description: "Lists the sites on this account, so a publish can go to one of them.",
       inputSchema: {},
-      outputSchema: { sites: z.array(SITE_OUTPUT).describe("Every site on this account.") },
+      outputSchema: {
+        sites: z.array(SITE_OUTPUT).describe("The account's sites, newest first — every one unless `total` is larger."),
+        total: z.number().int().describe("How many sites the account holds. Larger than `sites` only past 100.")
+      },
       annotations: READS_ONLY
     },
     () => withCredentials(async (credentials) => {
-      const sites = await listSites(credentials);
+      const { sites, total } = await listSites(credentials);
       const text = sites.length === 0 ? "No sites on this account yet. Publishing without a `site` creates one." : sites.map(
         (site) => `${site.subdomain} — ${site.url}${site.name ? ` — ${site.name}` : ""}`
-      ).join("\n");
-      return report(text, { sites: sites.map((site) => ({ ...site })) });
+      ).join("\n") + (total > sites.length ? `
+… and ${total - sites.length} more; these are the newest ${sites.length} of ${total}.` : "");
+      return report(text, { sites: sites.map((site) => ({ ...site })), total });
+    })
+  );
+  server.registerTool(
+    "list_folders",
+    {
+      title: "List folders",
+      description: "Lists the folders on this account, each with the path a publish's `folder` accepts. Folders are made and rearranged in the dashboard; no tool here creates one.",
+      inputSchema: {},
+      outputSchema: {
+        folders: z.array(FOLDER_OUTPUT).describe("Every folder on this account, ordered by path.")
+      },
+      annotations: READS_ONLY
+    },
+    () => withCredentials(async (credentials) => {
+      const folders = await listFolders(credentials);
+      const text = folders.length === 0 ? "No folders on this account. A new site goes at the top level; folders are made in the dashboard." : folders.map((folder) => `${folder.path} — ${folder.folderId}`).join("\n");
+      return report(text, { folders: folders.map((folder) => ({ ...folder })) });
     })
   );
   return server;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drop2run/mcp",
-	"version": "0.6.0",
+	"version": "0.8.0",
 	"description": "MCP server that publishes what an AI made — a page, a document or a whole site — to Drop2Run and returns a live URL.",
 	"mcpName": "run.dropto/drop2run",
 	"license": "MIT",