@drop2run/mcp 0.7.0 → 0.9.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
@@ -69,6 +87,11 @@ lose it.
 | `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` |
+| `get_site` | Reads a site's settings, whether it is paused, and its versions with the live one marked |
+| `update_site` | Changes a site's name, serving mode, password, forms, scheduled takedown or folder |
+| `pause_site` | Takes a site off the air, keeping its files, versions and subdomain |
+| `resume_site` | Puts a paused site back on the air |
+| `rollback_site` | Serves an earlier version again, by its id from `get_site` |
 
 Both publish tools take an optional `site` — a subdomain or site id to publish over. Leave it out and a
 new site is created.
@@ -84,6 +107,12 @@ by path such as `Clients/Acme`, or by the id `list_folders` shows. Like `subdoma
 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.
 
+`update_site` changes only the settings it is given. An empty `name`, `password` or `expiresAt` clears
+that setting, and `folder: "root"` moves the site back to the top level. A takedown pauses the site by
+default; `expiryAction: "delete"` removes it instead, and asks for the subdomain as `confirm` the way
+`delete_site` does. Settings your plan does not include are refused with the reason, and `get_site` says
+which ones those are.
+
 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

@@ -13,6 +13,8 @@ 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 {
@@ -36,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 = {};
@@ -63,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_..."}`
   ];
@@ -102,7 +105,9 @@ async function call(credentials, path, init = {}) {
 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.`);
+    throw new Error(
+      `No site of yours is called "${site}". \`drop2run ls\` or the list_sites tool shows what exists.`
+    );
   }
   return found;
 }
@@ -139,6 +144,115 @@ async function deleteSite(credentials, siteId) {
     throw new Error(problem?.detail ?? `The API answered ${response.status}.`);
   }
 }
+async function promoteDeploy(credentials, siteId, deployId) {
+  return await call(
+    credentials,
+    `sites/${encodeURIComponent(siteId)}/deploys/${encodeURIComponent(deployId)}/promote`,
+    { method: "POST" }
+  );
+}
+function enumName(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function actionOf(expiresAt, action) {
+  return expiresAt === null ? null : enumName(action);
+}
+async function readInvitedOnly(credentials, siteId) {
+  try {
+    const page = await call(
+      credentials,
+      `sites/${encodeURIComponent(siteId)}/viewers?pageSize=1`
+    );
+    return typeof page.invitedOnly === "boolean" ? page.invitedOnly : null;
+  } catch {
+    return null;
+  }
+}
+async function folderFromListing(credentials, siteId, subdomain) {
+  const { sites } = await call(
+    credentials,
+    `sites?pageSize=${SITES_PER_REQUEST}&q=${encodeURIComponent(subdomain)}`
+  );
+  return sites.find((candidate) => candidate.siteId === siteId)?.folderId ?? null;
+}
+async function getSite(credentials, siteId) {
+  const [site, invitedOnly] = await Promise.all([
+    call(
+      credentials,
+      `sites/${encodeURIComponent(siteId)}`
+    ),
+    readInvitedOnly(credentials, siteId)
+  ]);
+  const folderId = site.folderId !== void 0 ? site.folderId : await folderFromListing(credentials, site.siteId, site.subdomain);
+  return {
+    siteId: site.siteId,
+    subdomain: site.subdomain,
+    url: site.url,
+    name: site.name,
+    status: enumName(site.status),
+    invitedOnly,
+    liveDeployId: site.liveDeployId,
+    spaMode: site.spaMode,
+    docsMode: site.docsMode,
+    modeIsManual: site.modeIsManual,
+    passwordProtected: site.passwordProtected,
+    passwordProtectionAvailable: site.passwordProtectionAvailable,
+    formsEnabled: site.formsEnabled,
+    formsAvailable: site.formsAvailable,
+    expiresAt: site.expiresAt,
+    expiryAction: actionOf(site.expiresAt, site.expiryAction ?? ""),
+    scheduledExpiryAvailable: site.scheduledExpiryAvailable,
+    folderId,
+    deploys: site.deploys.map((deploy2) => ({
+      deployId: deploy2.deployId,
+      status: deploy2.status,
+      fileCount: deploy2.fileCount,
+      totalBytes: deploy2.totalBytes,
+      createdAt: deploy2.createdAt,
+      completedAt: deploy2.completedAt,
+      filesKept: deploy2.filesKept
+    }))
+  };
+}
+async function updateSiteSettings(credentials, siteId, change) {
+  const body = {};
+  if (change.name !== void 0) body.name = change.name;
+  if (change.mode !== void 0) {
+    body.spaMode = change.mode === "spa";
+    body.docsMode = change.mode === "docs";
+  }
+  if (change.password !== void 0) body.password = change.password;
+  if (change.expiresAt !== void 0) body.expiresAt = change.expiresAt;
+  if (change.expiryAction !== void 0) body.expiryAction = change.expiryAction;
+  if (change.formsEnabled !== void 0) body.formsEnabled = change.formsEnabled;
+  if (change.folderId !== void 0) body.folderId = change.folderId;
+  if (Object.keys(body).length === 0) throw new Error("Nothing to change — name a setting.");
+  const wasInvitedOnly = change.password !== void 0 && change.password !== "" ? await readInvitedOnly(credentials, siteId) : null;
+  const settings = await call(credentials, `sites/${encodeURIComponent(siteId)}`, {
+    method: "PATCH",
+    body: JSON.stringify(body)
+  });
+  const invitedOnly = typeof settings.invitedOnly === "boolean" ? settings.invitedOnly : null;
+  return {
+    ...settings,
+    expiryAction: actionOf(settings.expiresAt, settings.expiryAction ?? ""),
+    invitedOnly,
+    replacedInviteOnly: wasInvitedOnly === true && invitedOnly === false
+  };
+}
+async function setSitePaused(credentials, siteId, action) {
+  const state = await call(
+    credentials,
+    `sites/${encodeURIComponent(siteId)}/${action}`,
+    { method: "POST" }
+  );
+  return {
+    siteId: state.siteId,
+    subdomain: state.subdomain,
+    status: enumName(state.status),
+    ownerPaused: state.ownerPaused
+  };
+}
 const SITES_PER_REQUEST = 100;
 async function listSites(credentials) {
   const body = await call(
@@ -209,6 +323,46 @@ async function resolveFolder(credentials, folder) {
     `No folder of yours is called "${folder}". Your folders: ${listed.join(", ")}${more > 0 ? `, and ${more} more` : ""}.`
   );
 }
+const ROOT_FOLDER = "root";
+async function resolveFolderTarget(credentials, folder) {
+  return folder.trim().toLowerCase() === ROOT_FOLDER ? ROOT_FOLDER : await resolveFolder(credentials, folder);
+}
+const VERSIONS_LISTED = 10;
+function servingModeOf$1(site) {
+  if (site.spaMode) return "spa";
+  if (site.docsMode) return "docs";
+  return "static";
+}
+function accessOf(site) {
+  if (site.passwordProtected) return "password";
+  if (site.invitedOnly === true) return "invite-only";
+  if (site.invitedOnly === false) return "public";
+  return "no password (whether it is invite-only could not be read)";
+}
+function describeSite(site, folderPath) {
+  const unavailable = (available) => available ? "" : " (not on this plan)";
+  const versions = site.deploys.slice(0, VERSIONS_LISTED).map((deploy2) => {
+    const live = deploy2.deployId === site.liveDeployId ? " ← served" : "";
+    const kept = deploy2.filesKept ? "" : ", files collected — cannot be rolled back to";
+    return `  ${deploy2.deployId}  ${deploy2.createdAt}  ${deploy2.status}, ${deploy2.fileCount} files${kept}${live}`;
+  });
+  const more = site.deploys.length - versions.length;
+  return [
+    `${site.subdomain} — ${site.url}`,
+    `  name      ${site.name ?? "(none)"}`,
+    `  status    ${site.status}`,
+    `  access    ${accessOf(site)}`,
+    `  mode      ${servingModeOf$1(site)}${site.modeIsManual ? "" : " (detected on each publish)"}`,
+    `  password  ${site.passwordProtected ? "on" : "off"}${unavailable(site.passwordProtectionAvailable)}`,
+    `  forms     ${site.formsEnabled ? "on" : "off"}${unavailable(site.formsAvailable)}`,
+    `  takedown  ${site.expiresAt === null ? "none" : `${site.expiresAt} (${site.expiryAction})`}${unavailable(site.scheduledExpiryAvailable)}`,
+    `  folder    ${site.folderId === null ? "(top level)" : folderPath ?? site.folderId}`,
+    "",
+    site.deploys.length === 0 ? "No versions yet." : "Versions, newest first:",
+    ...versions,
+    ...more > 0 ? [`  … and ${more} older`] : []
+  ].join("\n");
+}
 function newAttempt() {
   const verifier = randomBytes(32).toString("base64url");
   return {
@@ -344,6 +498,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
@@ -380,20 +540,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) };
 }
@@ -403,31 +598,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);
@@ -926,17 +1155,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",
@@ -946,7 +1187,11 @@ const IGNORED_DIRECTORIES = [
   ".hg",
   ".idea",
   ".vscode",
-  ".claude"
+  ".claude",
+  ".agents",
+  ".cursor",
+  ".codex",
+  ".gemini"
 ];
 function shouldIgnore(path) {
   const segments = path.split("/");
@@ -981,6 +1226,24 @@ function canPublish(paths) {
   if (isImageFolder(paths)) return true;
   return paths.length === 1 && paths[0] !== void 0 && isViewablePath(paths[0]);
 }
+function servingModeOf(flags) {
+  if (flags.docsMode) return "docs";
+  if (flags.spaMode) return "spa";
+  return "static";
+}
+function predictedModeOf(paths) {
+  if (paths.some((path) => path === REQUIRED_INDEX)) return "static";
+  if (paths.some(isDocumentPath)) return "docs";
+  if (isImageFolder(paths)) return "docs";
+  if (paths.length === 1 && paths[0] !== void 0 && isViewablePath(paths[0])) return "docs";
+  return "static";
+}
+function nestedIndexOf(paths) {
+  if (predictedModeOf(paths) !== "docs") return null;
+  const suffix = `/${REQUIRED_INDEX}`;
+  const folders = paths.filter((path) => path.endsWith(suffix)).map((path) => path.slice(0, -suffix.length)).sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b));
+  return folders[0] ?? null;
+}
 function renameOfLoneHtmlPage(paths) {
   if (paths.length !== 1) return null;
   const [only] = paths;
@@ -1008,7 +1271,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;
@@ -1049,13 +1312,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)
@@ -1087,7 +1361,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 = [
@@ -1096,10 +1370,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"
@@ -1141,46 +1461,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) {
@@ -1192,39 +1571,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);
@@ -1238,9 +1700,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.",
@@ -1249,7 +1719,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);
@@ -1265,6 +1739,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,
@@ -1274,11 +1763,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(
@@ -1286,9 +1777,15 @@ 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 });
+    onProgress({
+      type: "done",
+      url: completed.url,
+      name: completed.name,
+      mode: servingModeOf(completed),
+      modeIsManual: completed.modeIsManual
+    });
   } catch (error) {
     const failure = asDeployError(error);
     onProgress({
@@ -1341,6 +1838,15 @@ function escapesRoot(root, candidate) {
   const inside = relative(root, candidate);
   return inside === "" || inside.startsWith("..");
 }
+function describeMode(result) {
+  if (result.mode === null) return null;
+  if (result.nestedIndex !== null) {
+    return `Served as documents: there is no index.html at the top, but ${result.nestedIndex}/index.html is there. To publish the website, publish the ${result.nestedIndex} folder instead.`;
+  }
+  if (result.mode === "docs") return "Served as documents, in the documents reader.";
+  if (result.mode === "spa") return "Served as a single-page app.";
+  return "Served as a static site.";
+}
 async function resolveSite(credentials, site, newSite) {
   const { subdomain, folder } = newSite;
   if (site !== void 0 && subdomain !== void 0) {
@@ -1350,7 +1856,7 @@ async function resolveSite(credentials, site, newSite) {
   }
   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."
+      "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 with `drop2run set folder` or the `update_site` tool's `folder`."
     );
   }
   if (site === void 0) {
@@ -1370,6 +1876,8 @@ async function publish(credentials, source, site, onProgress, newSite = {}) {
   let files = 0;
   let url = target.url;
   let unchanged = false;
+  let mode = null;
+  let paths = [];
   let failure = null;
   let failureDetail;
   const record = (event) => {
@@ -1378,13 +1886,21 @@ async function publish(credentials, source, site, onProgress, newSite = {}) {
       unchanged = true;
       url = event.url || target.url;
     }
-    if (event.type === "done") url = event.url;
+    if (event.type === "done") {
+      url = event.url;
+      mode = event.mode;
+    }
     if (event.type === "error") {
       failure = event.message;
       failureDetail = event.detail;
     }
   };
-  await deploy(source, target.siteId, record, void 0, {
+  const watched = async (signal, onRead) => {
+    const collected = await source(signal, onRead);
+    paths = collected.map((file) => file.path);
+    return collected;
+  };
+  await deploy(watched, target.siteId, record, void 0, {
     baseUrl: credentials.apiBaseUrl,
     token: credentials.token
   }).catch((error) => {
@@ -1394,7 +1910,15 @@ async function publish(credentials, source, site, onProgress, newSite = {}) {
     thrown.detail = failureDetail ?? error?.detail;
     throw thrown;
   });
-  return { url, siteId: target.siteId, subdomain: target.subdomain, files, unchanged };
+  return {
+    url,
+    siteId: target.siteId,
+    subdomain: target.subdomain,
+    files,
+    unchanged,
+    mode,
+    nestedIndex: mode === "docs" ? nestedIndexOf(paths) : null
+  };
 }
 async function publishDirectory(credentials, directory, site, onProgress, newSite = {}) {
   const found = await stat(directory).catch(() => null);
@@ -1603,7 +2127,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.7.0";
+const SERVER_VERSION = "0.9.0";
 const CREDENTIAL_WRITE = {
   readOnlyHint: false,
   destructiveHint: false,
@@ -1635,6 +2159,83 @@ const REMOVES_A_SITE = {
   idempotentHint: false,
   openWorldHint: true
 };
+const CHANGES_A_SITE = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: true
+};
+const RESTORES_A_SITE = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+const SITE_INPUT = z.string().min(1).describe("Subdomain or site id, from list_sites.");
+const VERSION_OUTPUT = z.object({
+  deployId: z.string().describe("Identifier of the version, which rollback_site takes."),
+  status: z.string().describe(
+    "`live` for the one being served, `superseded` for one served before, `ready` for one that finished but was never served, `failed`, or a stage still under way. Whether it can be rolled back to is `filesKept`, not this."
+  ),
+  fileCount: z.number().int().describe("How many files it carries."),
+  createdAt: z.string().describe("When it was published, ISO 8601."),
+  filesKept: z.boolean().describe(
+    "Whether its files are still stored; a version without them cannot be rolled back to."
+  ),
+  live: z.boolean().describe("Whether this is the version being served.")
+});
+const SETTINGS_OUTPUT = {
+  siteId: z.string().describe("Identifier of the site."),
+  name: z.string().nullable().describe("What it is called, or null."),
+  mode: z.enum(["static", "spa", "docs"]).describe("How it serves its files."),
+  passwordProtected: z.boolean().describe("Whether visitors must type a password."),
+  invitedOnly: z.boolean().nullable().describe(
+    "Whether only invited people can open it, or null when that could not be read. Null does not mean public."
+  ),
+  formsEnabled: z.boolean().describe("Whether it accepts form submissions."),
+  expiresAt: z.string().nullable().describe("When it is scheduled to come down, or null."),
+  expiryAction: z.string().nullable().describe("What the takedown does: `pause` or `delete`, or null when none is scheduled."),
+  folderId: z.string().nullable().describe("The folder it is filed in, or null at the top level.")
+};
+const PAUSE_OUTPUT = {
+  siteId: z.string().describe("Identifier of the site."),
+  subdomain: z.string().describe("Its subdomain."),
+  status: z.string().describe("`active` or `paused` afterwards."),
+  ownerPaused: z.boolean().describe("Whether the pause is the owner's own.")
+};
+async function folderPathOf(credentials, folderId) {
+  if (folderId === null) return void 0;
+  return (await listFolders(credentials)).find((folder) => folder.folderId === folderId)?.path;
+}
+function structuredSite(site) {
+  return {
+    siteId: site.siteId,
+    subdomain: site.subdomain,
+    url: site.url,
+    name: site.name,
+    status: site.status,
+    mode: servingModeOf$1(site),
+    passwordProtected: site.passwordProtected,
+    invitedOnly: site.invitedOnly,
+    formsEnabled: site.formsEnabled,
+    expiresAt: site.expiresAt,
+    expiryAction: site.expiryAction,
+    folderId: site.folderId,
+    available: {
+      password: site.passwordProtectionAvailable,
+      forms: site.formsAvailable,
+      scheduledTakedown: site.scheduledExpiryAvailable
+    },
+    versions: site.deploys.map((deploy2) => ({
+      deployId: deploy2.deployId,
+      status: deploy2.status,
+      fileCount: deploy2.fileCount,
+      createdAt: deploy2.createdAt,
+      filesKept: deploy2.filesKept,
+      live: deploy2.deployId === site.liveDeployId
+    }))
+  };
+}
 const SITE_OUTPUT = z.object({
   siteId: z.string().describe("Identifier of the site."),
   subdomain: z.string().describe("Its subdomain, which is what `site` accepts."),
@@ -1648,7 +2249,7 @@ const FOLDER_OUTPUT = z.object({
   )
 });
 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."
+  "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 update_site's `folder`. 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 } : {} };
@@ -1671,11 +2272,13 @@ async function attempt(work) {
 }
 function describe(result) {
   const what = result.unchanged ? "Already live — every file matched what the site already serves, so no new version was published." : `Published ${result.files.toLocaleString()} ${result.files === 1 ? "file" : "files"}.`;
+  const mode = describeMode(result);
   return [
     what,
     "",
     result.url,
     "",
+    ...mode === null ? [] : [mode, ""],
     `Site ${result.subdomain} (${result.siteId}). Reaching every edge takes up to about a minute.`
   ].join("\n");
 }
@@ -1715,7 +2318,14 @@ function createServer() {
         "",
         "delete_site is permanent and frees the subdomain for anybody to claim. Ask the person for",
         "the subdomain and pass what they say as `confirm` — do not fill it in from what you already",
-        "know, because being told it is the point of the step."
+        "know, because being told it is the point of the step.",
+        "",
+        "An existing site's settings are read with get_site and changed with update_site: its name,",
+        "serving mode (static, spa, docs), a password, whether forms accept submissions, a scheduled",
+        "takedown, and its folder. pause_site and resume_site take it off the air and back without",
+        "deleting anything, and rollback_site serves an earlier version from get_site's list. Use",
+        "a password or a date only when the person gave one, and scheduling a deletion asks for",
+        "`confirm` the way delete_site does."
       ].join("\n")
     }
   );
@@ -1866,6 +2476,171 @@ function createServer() {
       return report(text, { folders: folders.map((folder) => ({ ...folder })) });
     })
   );
+  server.registerTool(
+    "get_site",
+    {
+      title: "Read a site's settings",
+      description: "Reads one site's settings and state — serving mode, password, forms, scheduled takedown, folder, whether it is paused — and its versions, newest first, with the one being served marked. Also says which settings the account's plan does not include.",
+      inputSchema: { site: SITE_INPUT },
+      outputSchema: {
+        ...SETTINGS_OUTPUT,
+        subdomain: z.string().describe("Its subdomain."),
+        url: z.string().describe("Its live URL."),
+        status: z.string().describe("`active`, `paused`, or a state the platform put it in."),
+        available: z.object({
+          password: z.boolean(),
+          forms: z.boolean(),
+          scheduledTakedown: z.boolean()
+        }).describe("Which settings the account's plan includes."),
+        versions: z.array(VERSION_OUTPUT).describe("Its versions, newest first.")
+      },
+      annotations: READS_ONLY
+    },
+    ({ site }) => withCredentials(async (credentials) => {
+      const found = await findSite(credentials, site);
+      const detail = await getSite(credentials, found.siteId);
+      return report(
+        describeSite(detail, await folderPathOf(credentials, detail.folderId)),
+        structuredSite(detail)
+      );
+    })
+  );
+  server.registerTool(
+    "update_site",
+    {
+      title: "Change a site's settings",
+      description: "Changes one or more settings of an existing site; anything left out stays as it is. Takes effect on every edge within about a minute, without publishing again. Settings the plan does not include are refused with the reason. Only change what the person asked for — never invent a password or a date.",
+      inputSchema: {
+        site: SITE_INPUT,
+        name: z.string().optional().describe("What to call the site in the dashboard. An empty string clears it."),
+        mode: z.enum(["static", "spa", "docs"]).optional().describe(
+          "How the site serves: `static` answers 404 for a missing path, `spa` falls back to index.html for a client-side router, `docs` reads documents through the viewer. Setting it stops the mode being detected on each publish."
+        ),
+        password: z.string().optional().describe(
+          "A password visitors must type before seeing the site, as the person gave it. An empty string removes the password. On an invite-only site a password replaces invite-only and shuts out everyone on its list, so check get_site's `invitedOnly` and ask first."
+        ),
+        forms: z.boolean().optional().describe("Whether the site's forms (marked data-drop2run) accept submissions."),
+        expiresAt: z.string().optional().describe(
+          "When the site should come down, as an ISO 8601 instant in the future such as 2026-12-01T09:00:00Z. An empty string cancels a scheduled takedown."
+        ),
+        expiryAction: z.enum(["pause", "delete"]).optional().describe(
+          "What the takedown does, read only with `expiresAt`: `pause` (the default) keeps the files and can be resumed; `delete` removes the site and frees its subdomain, and needs `confirm`."
+        ),
+        folder: z.string().optional().describe(
+          "Folder to move the site to — a path such as Clients/Acme or an id from list_folders — or `root` for the top level. Never creates a folder."
+        ),
+        confirm: z.string().optional().describe(
+          "Required only with `expiryAction: delete`: the site's subdomain, repeated exactly as the person said it. Ask for it rather than filling it in."
+        )
+      },
+      outputSchema: SETTINGS_OUTPUT,
+      annotations: CHANGES_A_SITE
+    },
+    ({ site, name, mode, password, forms, expiresAt, expiryAction, folder, confirm }) => withCredentials(async (credentials) => {
+      const found = await findSite(credentials, site);
+      if (expiryAction !== void 0 && expiresAt === void 0) {
+        throw new Error("`expiryAction` only applies with `expiresAt` — send the date too.");
+      }
+      if (expiryAction === "delete" && expiresAt !== "" && confirm?.trim().toLowerCase() !== found.subdomain.toLowerCase()) {
+        throw new Error(
+          `Refusing to schedule ${found.subdomain} for deletion: \`confirm\` said "${confirm ?? ""}". Repeat the subdomain exactly to go ahead, or use \`expiryAction: pause\`, which keeps the files.`
+        );
+      }
+      const change = {
+        name,
+        mode,
+        password,
+        expiresAt,
+        // Dropped on a cancellation: the API reads an action only with a date, and sending
+        // `delete` alongside an empty date would still run its owner-only check for nothing.
+        expiryAction: expiresAt === "" ? void 0 : expiryAction,
+        formsEnabled: forms,
+        folderId: folder === void 0 ? void 0 : await resolveFolderTarget(credentials, folder)
+      };
+      const settings = await updateSiteSettings(credentials, found.siteId, change);
+      const lines = [
+        `Updated ${found.subdomain}.`,
+        `  access    ${accessOf(settings)}`,
+        `  mode      ${servingModeOf$1(settings)}`,
+        `  forms     ${settings.formsEnabled ? "on" : "off"}`,
+        `  takedown  ${settings.expiresAt === null ? "none" : `${settings.expiresAt} (${settings.expiryAction})`}`,
+        ...settings.replacedInviteOnly ? [
+          "The password replaced invite-only: the people on its list can no longer get in without it. The list is kept for switching back in the dashboard."
+        ] : [],
+        ...settings.live ? ["Reaching every edge takes up to about a minute."] : ["Nothing is published yet, so this applies from the first publish."]
+      ];
+      return report(lines.join("\n"), {
+        siteId: settings.siteId,
+        name: settings.name,
+        mode: servingModeOf$1(settings),
+        passwordProtected: settings.passwordProtected,
+        invitedOnly: settings.invitedOnly,
+        formsEnabled: settings.formsEnabled,
+        expiresAt: settings.expiresAt,
+        expiryAction: settings.expiryAction,
+        folderId: settings.folderId
+      });
+    })
+  );
+  server.registerTool(
+    "pause_site",
+    {
+      title: "Pause a site",
+      description: "Takes a site off the air without deleting anything: visitors see that it is paused, and its files, versions and subdomain are kept. resume_site puts it back.",
+      inputSchema: { site: SITE_INPUT },
+      outputSchema: PAUSE_OUTPUT,
+      annotations: CHANGES_A_SITE
+    },
+    ({ site }) => withCredentials(async (credentials) => {
+      const found = await findSite(credentials, site);
+      const state = await setSitePaused(credentials, found.siteId, "pause");
+      return report(
+        state.status === "paused" ? `Paused ${state.subdomain}. Its files and subdomain are kept; resume_site puts it back.` : `${state.subdomain} is ${state.status}, not paused by its owner, so resume_site cannot bring it back. The pause is recorded and applies if that is lifted.`,
+        { ...state }
+      );
+    })
+  );
+  server.registerTool(
+    "resume_site",
+    {
+      title: "Resume a paused site",
+      description: "Puts a paused site back on the air. Refused, with the reason, when the plan has no room for another active site, the account is past due, or the site was suspended by Drop2Run.",
+      inputSchema: { site: SITE_INPUT },
+      outputSchema: PAUSE_OUTPUT,
+      annotations: RESTORES_A_SITE
+    },
+    ({ site }) => withCredentials(async (credentials) => {
+      const found = await findSite(credentials, site);
+      const state = await setSitePaused(credentials, found.siteId, "resume");
+      return report(`${state.subdomain} is back on the air.
+${found.url}`, { ...state });
+    })
+  );
+  server.registerTool(
+    "rollback_site",
+    {
+      title: "Roll a site back",
+      description: "Serves an earlier version of a site again, without publishing anything. get_site lists the versions; one whose files were collected cannot be rolled back to.",
+      inputSchema: {
+        site: SITE_INPUT,
+        deployId: z.string().min(1).describe("The version to serve, from get_site's `versions`.")
+      },
+      outputSchema: {
+        deployId: z.string().describe("The version now being served."),
+        url: z.string().describe("The URL it is served on.")
+      },
+      annotations: CHANGES_A_SITE
+    },
+    ({ site, deployId }) => withCredentials(async (credentials) => {
+      const found = await findSite(credentials, site);
+      const promoted = await promoteDeploy(credentials, found.siteId, deployId);
+      return report(
+        `${found.subdomain} is back on ${promoted.deployId}. Reaching every edge takes up to about a minute.
+${promoted.url}`,
+        { deployId: promoted.deployId, url: promoted.url }
+      );
+    })
+  );
   return server;
 }
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drop2run/mcp",
-	"version": "0.7.0",
+	"version": "0.9.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",
@@ -46,14 +46,14 @@
 		"build:mcpb": "node scripts/build-mcpb.mjs"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.30.0",
+		"@modelcontextprotocol/sdk": "^1.32.1",
 		"zod": "^4.1.12"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.11",
 		"@types/node": "^26.4.0",
 		"typescript": "^5.9.3",
-		"vitest": "^4.1.11",
-		"vite": "^7.2.1"
+		"vite": "^7.2.1",
+		"vitest": "^4.1.11"
 	}
 }