drivethrough-cli 0.1.0 → 0.1.1

package/dist/main.mjs

@@ -956,7 +956,8 @@ var init_config = __esm({
 var api_exports = {};
 __export(api_exports, {
   ApiError: () => ApiError,
-  api: () => api
+  api: () => api,
+  apiBytes: () => apiBytes
 });
 async function api(method, pathname, options = {}) {
   const headers = {};
@@ -1007,6 +1008,40 @@ async function api(method, pathname, options = {}) {
   }
   return json;
 }
+async function apiBytes(pathname) {
+  const t2 = token();
+  if (!t2) {
+    throw new ApiError(401, {
+      error: {
+        code: "not_logged_in",
+        message: "You are not logged in on this machine.",
+        next: "Run `drivethrough login` first."
+      }
+    });
+  }
+  let res;
+  try {
+    res = await fetch(`${apiUrl()}${pathname}`, { headers: { Authorization: `Bearer ${t2}` } });
+  } catch (cause) {
+    throw new ApiError(0, {
+      error: {
+        code: "network_error",
+        message: `Could not reach the Drivethrough API at ${apiUrl()}: ${cause.message}`,
+        next: "Check your connection (or, in local dev, that `pnpm dev` is running)."
+      }
+    });
+  }
+  if (!res.ok) {
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = { error: { code: "http_error", message: `API request failed (${res.status}).` } };
+    }
+    throw new ApiError(res.status, body);
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
 var ApiError;
 var init_api = __esm({
   "src/api.ts"() {
@@ -1576,8 +1611,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path5, errorMaps, issueData } = params;
-      const fullPath = [...path5, ...issueData.path || []];
+      const { data, path: path8, errorMaps, issueData } = params;
+      const fullPath = [...path8, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -1885,11 +1920,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path5, key) {
+      constructor(parent, value, path8, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path5;
+        this._path = path8;
         this._key = key;
       }
       get path() {
@@ -5282,16 +5317,28 @@ function parseSiteConfig(input) {
   }
   return { ok: true, config: result.data };
 }
-var FieldSpec, RateLimit, TypeConfig, IndexDecl, SiteConfig;
+var FieldSpec, RateLimit, TYPE_NAME, TypeConfig, IndexDecl, SiteConfig;
 var init_site_config = __esm({
   "../schema/src/site-config.ts"() {
     "use strict";
     init_zod();
     FieldSpec = external_exports.enum(["string", "string?", "number", "number?", "boolean", "boolean?"]);
     RateLimit = external_exports.string().regex(/^\d+\/(minute|hour|day)$/, 'rate_limit must look like "5/hour"');
+    TYPE_NAME = external_exports.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/, "type names are lowercase letters, numbers, hyphens and underscores").max(64);
     TypeConfig = external_exports.object({
-      /** Who may create rows of this type. Defaults to owner-only. */
-      write: external_exports.enum(["public", "viewers", "owner"]).default("owner"),
+      /**
+       * Who may create rows of this type. Absent means owner-only — see
+       * `effectiveWrite`. Left optional rather than `.default("owner")` so
+       * `effectiveRead` can tell "the author said owner" from "the author said
+       * nothing", which are the same for writes and must not be for reads.
+       */
+      write: external_exports.enum(["public", "viewers", "owner"]).optional(),
+      /**
+       * Who may read rows of this type. Omitted → `effectiveRead` decides from
+       * `write`: owner-authored content stays readable, collected submissions do
+       * not. Set explicitly to publish submissions (a public guestbook).
+       */
+      read: external_exports.enum(["public", "viewers", "owner"]).optional(),
       fields: external_exports.record(FieldSpec).default({}),
       /** "session" → an RSVP edits itself, not duplicates (upsert per viewer session). */
       unique_per: external_exports.enum(["session"]).optional(),
@@ -5309,7 +5356,11 @@ var init_site_config = __esm({
       site: external_exports.string().regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/, "site is lowercase letters, numbers and hyphens").optional(),
       /** Human title, shown on the share interstitial ("Tim shared *Trip to Japan 2027*"). */
       title: external_exports.string().min(1).max(120).optional(),
-      types: external_exports.record(TypeConfig).default({}),
+      // Type names are constrained, not free-form: they become part of generated
+      // index names and — for unique_per — of a partial index predicate that
+      // cannot be parameterised. Keeping them to this alphabet is what makes that
+      // interpolation safe, rather than relying on escaping at each use.
+      types: external_exports.record(TYPE_NAME, TypeConfig).default({}),
       indexes: external_exports.array(IndexDecl).default([]),
       /** Pro (§3): additive custom-schema SQL applied to the site database. */
       schema: external_exports.string().max(2e4).optional()
@@ -5436,7 +5487,75 @@ var init_bundle2 = __esm({
   "src/bundle.ts"() {
     "use strict";
     init_src();
-    IGNORED = /* @__PURE__ */ new Set(["node_modules", ".git", ".DS_Store", "drivethrough.json", ".dev.vars", ".env"]);
+    IGNORED = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".DS_Store",
+      "drivethrough.json",
+      ".dev.vars",
+      ".env",
+      // Local sync state (state.ts) — never part of the site.
+      ".drivethrough"
+    ]);
+  }
+});
+
+// src/state.ts
+var state_exports = {};
+__export(state_exports, {
+  hashLocalFiles: () => hashLocalFiles,
+  readState: () => readState,
+  writeState: () => writeState
+});
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+function statePath(dir) {
+  return path3.join(path3.resolve(dir), ".drivethrough", "state.json");
+}
+function readState(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync3(statePath(dir), "utf8"));
+    return typeof parsed.site_id === "string" && Number.isInteger(parsed.version) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeState(dir, state) {
+  mkdirSync2(path3.dirname(statePath(dir)), { recursive: true });
+  writeFileSync2(statePath(dir), JSON.stringify(state, null, 2) + "\n");
+}
+function hashLocalFiles(assetDir) {
+  const files = /* @__PURE__ */ new Map();
+  if (!existsSync2(assetDir)) return files;
+  const walk = (current, prefix) => {
+    for (const entry of readdirSync2(current, { withFileTypes: true })) {
+      if (IGNORED2.has(entry.name)) continue;
+      const full = path3.join(current, entry.name);
+      const rel = `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) walk(full, rel);
+      else if (entry.isFile()) {
+        const bytes = readFileSync3(full);
+        files.set(rel, { sha256: sha256(bytes), size: bytes.length });
+      }
+    }
+  };
+  walk(assetDir, "");
+  return files;
+}
+var IGNORED2;
+var init_state = __esm({
+  "src/state.ts"() {
+    "use strict";
+    init_bundle2();
+    IGNORED2 = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".DS_Store",
+      "drivethrough.json",
+      ".dev.vars",
+      ".env",
+      ".drivethrough"
+    ]);
   }
 });
 
@@ -5648,10 +5767,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5900,11 +6019,11 @@ function aborted(x3, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -9568,11 +9687,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path5) {
-  if (path5.length === 0) {
+function getDotPath(path8) {
+  if (path8.length === 0) {
     return "object root";
   }
-  return path5.reduce((acc, seg, index) => {
+  return path8.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -17750,8 +17869,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path5) {
-      let input = path5;
+    function removeDotSegments(path8) {
+      let input = path8;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -18003,8 +18122,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path5, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
+        const [path8, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path8 && path8 !== "/" ? path8 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -23181,6 +23300,7 @@ var init_stdio2 = __esm({
 
 // ../mcp-tools/src/api.ts
 function apiErrorBody(error2) {
+  if (typeof error2 !== "object" || error2 === null) return null;
   const body = error2.body;
   if (body && typeof body === "object" && body.error && typeof body.error.message === "string") {
     return body;
@@ -23202,8 +23322,108 @@ var init_api3 = __esm({
   }
 });
 
+// ../mcp-tools/src/edits.ts
+function escapeRegex2(s2) {
+  return s2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function nearMatch(content, find) {
+  const parts = find.split(/\s+/).filter(Boolean).map(escapeRegex2);
+  if (parts.length === 0) return null;
+  let pattern;
+  try {
+    pattern = new RegExp(parts.join("\\s+"));
+  } catch {
+    return null;
+  }
+  const match = pattern.exec(content);
+  if (!match || match[0].length > NEAR_MATCH_CAP) return null;
+  return match[0];
+}
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let index = haystack.indexOf(needle);
+  while (index !== -1) {
+    count += 1;
+    index = haystack.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+function applyEdit(content, edit, label) {
+  if (edit.find === "") {
+    return {
+      ok: false,
+      problem: {
+        code: "edit_invalid",
+        message: `${label}: \`find\` is empty \u2014 there is nothing to locate in ${edit.path}.`,
+        next: "Pass the exact text currently in the file as `find`."
+      }
+    };
+  }
+  if (edit.find === edit.replace) {
+    return {
+      ok: false,
+      problem: {
+        code: "edit_invalid",
+        message: `${label}: \`find\` and \`replace\` are identical \u2014 the edit would change nothing in ${edit.path}.`,
+        next: "Make `replace` the new text you want, or drop this edit."
+      }
+    };
+  }
+  const count = countOccurrences(content, edit.find);
+  if (count === 0) {
+    const near = nearMatch(content, edit.find);
+    if (near !== null) {
+      return {
+        ok: false,
+        problem: {
+          code: "edit_not_found",
+          message: `${label}: no exact match in ${edit.path}, but the deployed file has a near match that differs only in whitespace/line breaks. The exact deployed text is in \`found\`.`,
+          next: "Retry with `find` set to the `found` text verbatim.",
+          found: near
+        }
+      };
+    }
+    return {
+      ok: false,
+      problem: {
+        code: "edit_not_found",
+        message: `${label}: the \`find\` text does not occur in ${edit.path} as deployed.`,
+        next: `The live file may differ from what you have in context. Call get_site with paths ["${edit.path}"] and copy the exact text \u2014 whitespace included \u2014 then retry. Nothing was deployed.`
+      }
+    };
+  }
+  if (count > 1 && !edit.replace_all) {
+    return {
+      ok: false,
+      problem: {
+        code: "edit_ambiguous",
+        message: `${label}: the \`find\` text occurs ${count} times in ${edit.path} \u2014 unclear which one to change.`,
+        next: `Include more surrounding context in \`find\` to pin down one occurrence, or set replace_all: true to change all ${count}. Nothing was deployed.`
+      }
+    };
+  }
+  if (edit.replace_all) {
+    return { ok: true, content: content.split(edit.find).join(edit.replace), replacements: count };
+  }
+  const index = content.indexOf(edit.find);
+  return {
+    ok: true,
+    content: content.slice(0, index) + edit.replace + content.slice(index + edit.find.length),
+    replacements: 1
+  };
+}
+var NEAR_MATCH_CAP;
+var init_edits = __esm({
+  "../mcp-tools/src/edits.ts"() {
+    "use strict";
+    NEAR_MATCH_CAP = 600;
+  }
+});
+
 // ../mcp-tools/src/inline-files.ts
 function decode(file) {
+  if (file.bytes) return file.bytes;
+  if (file.content === void 0) return null;
   if (file.encoding === "base64") {
     try {
       return Uint8Array.from(atob(file.content.replace(/\s/g, "")), (c3) => c3.charCodeAt(0));
@@ -23213,27 +23433,82 @@ function decode(file) {
   }
   return new TextEncoder().encode(file.content);
 }
+function configText(file) {
+  if (file.content !== void 0 && file.encoding !== "base64") return file.content;
+  const bytes = decode(file);
+  return bytes === null ? null : new TextDecoder().decode(bytes);
+}
 function assembleInlineBundle(files, maxMb) {
+  const maxBase64Chars = Math.ceil(MAX_INLINE_BASE64_MB * 1024 * 1024 * 4 / 3) + 4;
   const form = new FormData();
+  const seen = /* @__PURE__ */ new Set();
   let config2 = null;
   let totalBytes = 0;
   let fileCount = 0;
   for (const file of files) {
-    const path5 = file.path.startsWith("/") ? file.path : `/${file.path}`;
-    if (path5.includes("..")) {
+    const path8 = file.path.startsWith("/") ? file.path : `/${file.path}`;
+    if (path8.includes("..") || !SAFE_PATH.test(path8)) {
       return {
         ok: false,
         problem: {
           code: "invalid_file_path",
           message: `File path "${file.path}" is not allowed.`,
-          next: 'Paths must be site-relative like "/index.html" with no "..".'
+          next: `Paths must be site-relative like "/index.html" \u2014 letters, digits, and ._~!$&'()*+,;=:@%- only, no "..".`
         }
       };
     }
-    if (path5 === "/drivethrough.json") {
+    if (seen.has(path8)) {
+      return {
+        ok: false,
+        problem: {
+          code: "duplicate_file_path",
+          message: `File path "${path8}" appears more than once in this deploy.`,
+          next: "Send each path exactly once \u2014 which copy wins would otherwise be arbitrary."
+        }
+      };
+    }
+    seen.add(path8);
+    if (file.upload_id !== void 0 || file.from_path !== void 0) {
+      if (path8 === "/drivethrough.json") {
+        return {
+          ok: false,
+          problem: {
+            code: "invalid_drivethrough_json",
+            message: "drivethrough.json is the site's config and can't come from an upload or a copy.",
+            next: "Send drivethrough.json as inline text content."
+          }
+        };
+      }
+      if (file.upload_id !== void 0) form.append(`upload:${path8}`, file.upload_id);
+      else form.append(`copy:${path8}`, file.from_path.startsWith("/") ? file.from_path : `/${file.from_path}`);
+      fileCount += 1;
+      continue;
+    }
+    if (file.encoding === "base64" && file.content !== void 0 && file.content.length > maxBase64Chars) {
+      return {
+        ok: false,
+        problem: {
+          code: "inline_file_too_large",
+          message: `"${path8}" is ~${(file.content.length * 3 / 4 / 1024 / 1024).toFixed(1)} MB of base64 \u2014 inline base64 content is capped at ${MAX_INLINE_BASE64_MB} MB per file.`,
+          next: "Inline base64 is only for tiny pasted assets (a favicon). If the file is on the public web, pass {path, source_url} \u2014 the platform fetches it. If it's a local file, call create_upload for a signed URL the user uploads it to, then reference it as {path, upload_id}."
+        }
+      };
+    }
+    if (path8 === "/drivethrough.json") {
+      const text = configText(file);
+      if (text === null) {
+        return {
+          ok: false,
+          problem: {
+            code: "invalid_file_encoding",
+            message: `File "${path8}" is marked base64 but its content is not valid base64.`,
+            next: 'Base64-encode binary files; send text files with encoding "utf8" (the default).'
+          }
+        };
+      }
       let parsed;
       try {
-        parsed = JSON.parse(file.content);
+        parsed = JSON.parse(text);
       } catch {
         return {
           ok: false,
@@ -23252,7 +23527,8 @@ function assembleInlineBundle(files, maxMb) {
         };
       }
       config2 = result.config;
-      form.append("drivethrough.json", file.content);
+      totalBytes += new TextEncoder().encode(text).length;
+      form.append("drivethrough.json", text);
       continue;
     }
     const bytes = decode(file);
@@ -23261,16 +23537,16 @@ function assembleInlineBundle(files, maxMb) {
         ok: false,
         problem: {
           code: "invalid_file_encoding",
-          message: `File "${path5}" is marked base64 but its content is not valid base64.`,
+          message: `File "${path8}" is marked base64 but its content is not valid base64.`,
           next: 'Base64-encode binary files; send text files with encoding "utf8" (the default).'
         }
       };
     }
     totalBytes += bytes.length;
     fileCount += 1;
-    form.append(`file:${path5}`, new Blob([bytes]), path5.split("/").pop() ?? "file");
+    form.append(`file:${path8}`, new Blob([bytes]), path8.split("/").pop() ?? "file");
   }
-  if (fileCount === 0) {
+  if (fileCount === 0 && config2 === null) {
     return {
       ok: false,
       problem: {
@@ -23292,31 +23568,312 @@ function assembleInlineBundle(files, maxMb) {
   }
   return { ok: true, bundle: { form, fileCount, totalBytes, config: config2 } };
 }
+var SAFE_PATH, MAX_INLINE_BASE64_MB;
 var init_inline_files = __esm({
   "../mcp-tools/src/inline-files.ts"() {
     "use strict";
     init_src();
+    SAFE_PATH = /^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]+$/;
+    MAX_INLINE_BASE64_MB = 1;
+  }
+});
+
+// ../mcp-tools/src/remote-assets.ts
+function isPrivateIpv4(host) {
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!match) return false;
+  const [a2, b4] = [Number(match[1]), Number(match[2])];
+  if (a2 === 0 || a2 === 10 || a2 === 127) return true;
+  if (a2 === 169 && b4 === 254) return true;
+  if (a2 === 172 && b4 >= 16 && b4 <= 31) return true;
+  if (a2 === 192 && b4 === 168) return true;
+  if (a2 === 100 && b4 >= 64 && b4 <= 127) return true;
+  if (a2 === 192 && b4 === 0) return true;
+  if (a2 === 198 && (b4 === 18 || b4 === 19)) return true;
+  return a2 >= 224;
+}
+function isBlockedHost(hostname2) {
+  const host = hostname2.toLowerCase().replace(/\.$/, "");
+  if (host === "localhost" || host === "" || BLOCKED_HOST_SUFFIXES.some((s2) => host.endsWith(s2))) return true;
+  if (isPrivateIpv4(host)) return true;
+  if (host.includes(":") || host.startsWith("[")) {
+    const v6 = host.replace(/^\[|\]$/g, "");
+    return !/^[23][0-9a-f]{3}:/i.test(v6);
+  }
+  return false;
+}
+async function resolveViaDoh(hostname2) {
+  const addresses = [];
+  for (const type of ["A", "AAAA"]) {
+    const res = await fetch(
+      `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(hostname2)}&type=${type}`,
+      { headers: { Accept: "application/dns-json" }, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }
+    );
+    if (!res.ok) throw new Error(`DNS lookup returned HTTP ${res.status}`);
+    const body = await res.json();
+    for (const answer of body.Answer ?? []) {
+      if (answer.type === 1 || answer.type === 28) addresses.push(answer.data);
+    }
+  }
+  return addresses;
+}
+async function resolutionProblem(hostname2) {
+  const host = hostname2.toLowerCase().replace(/\.$/, "");
+  if (IP_LITERAL.test(host) || host.includes(":") || host.startsWith("[")) return null;
+  let addresses;
+  try {
+    addresses = await resolveAddresses(host);
+  } catch (error2) {
+    return `its address couldn't be verified (${error2 instanceof Error ? error2.message : String(error2)})`;
+  }
+  if (addresses.length === 0) return "it doesn't resolve to any address";
+  const blocked = addresses.find((address) => isBlockedHost(address));
+  if (blocked) return `it resolves to a private or reserved address (${blocked})`;
+  return null;
+}
+function urlProblem(url, why) {
+  return {
+    code: "invalid_source_url",
+    message: `source_url ${JSON.stringify(url)} is not fetchable: ${why}`,
+    next: "Use a public http(s) URL. For anything not publicly reachable, pass the bytes inline as base64 `content`."
+  };
+}
+function checkUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return { ok: false, problem: urlProblem(raw, "not a valid absolute URL") };
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    return { ok: false, problem: urlProblem(raw, `scheme "${url.protocol}" is not allowed`) };
+  }
+  if (isBlockedHost(url.hostname)) {
+    return { ok: false, problem: urlProblem(raw, "the host is private or internal") };
+  }
+  return { ok: true, url };
+}
+async function fetchRemote(path8, raw, budget) {
+  const maxBytes = budget.maxBytes;
+  const capMessage = budget.whole ? `it would take this deploy past the ${MAX_BUNDLE_TOTAL_MB} MB bundle limit` : `source_url files are capped at ${MAX_REMOTE_FILE_MB} MB`;
+  const capNext = budget.whole ? 'Deploy the rest in a follow-up mode:"patch" call \u2014 unchanged files carry forward.' : "Use a smaller asset (resize/compress images before hosting them).";
+  let current = raw;
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const checked = checkUrl(current);
+    if (!checked.ok) return checked;
+    const unresolvable = await resolutionProblem(new URL(checked.url).hostname);
+    if (unresolvable) return { ok: false, problem: urlProblem(current, unresolvable) };
+    let res;
+    try {
+      res = await fetch(checked.url, {
+        redirect: "manual",
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+      });
+    } catch (error2) {
+      return {
+        ok: false,
+        problem: {
+          code: "source_url_fetch_failed",
+          message: `Fetching ${JSON.stringify(current)} for "${path8}" failed: ${error2 instanceof Error ? error2.message : String(error2)}`,
+          next: "Check the URL is reachable, or pass the bytes inline as base64 `content`."
+        }
+      };
+    }
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (!location) return { ok: false, problem: urlProblem(current, `redirect (${res.status}) with no Location`) };
+      current = new URL(location, checked.url).toString();
+      continue;
+    }
+    if (!res.ok) {
+      return {
+        ok: false,
+        problem: {
+          code: "source_url_fetch_failed",
+          message: `Fetching ${JSON.stringify(current)} for "${path8}" returned HTTP ${res.status}.`,
+          next: "Check the URL serves the asset publicly (no auth), or pass the bytes inline as base64 `content`."
+        }
+      };
+    }
+    const declared = Number(res.headers.get("content-length") ?? 0);
+    if (declared > maxBytes) {
+      return {
+        ok: false,
+        problem: {
+          code: "source_url_too_large",
+          message: `"${path8}" is ${(declared / 1024 / 1024).toFixed(1)} MB; ${capMessage}.`,
+          next: capNext
+        }
+      };
+    }
+    const tooLarge = {
+      ok: false,
+      problem: {
+        code: "source_url_too_large",
+        message: `"${path8}" is too large \u2014 ${capMessage}.`,
+        next: capNext
+      }
+    };
+    const emptyBody = {
+      ok: false,
+      problem: {
+        code: "source_url_empty",
+        message: `Fetching ${JSON.stringify(current)} for "${path8}" returned no content.`,
+        next: "Check the URL actually serves the asset, or pass the bytes inline as base64 `content`."
+      }
+    };
+    if (!res.body) return emptyBody;
+    const reader = res.body.getReader();
+    const chunks = [];
+    let received = 0;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        received += value.length;
+        if (received > maxBytes) {
+          await reader.cancel();
+          return tooLarge;
+        }
+        chunks.push(value);
+      }
+    } catch (error2) {
+      return {
+        ok: false,
+        problem: {
+          code: "source_url_fetch_failed",
+          message: `Reading ${JSON.stringify(current)} for "${path8}" failed: ${error2 instanceof Error ? error2.message : String(error2)}`,
+          next: "Check the URL is reachable, or pass the bytes inline as base64 `content`."
+        }
+      };
+    } finally {
+      reader.releaseLock();
+    }
+    if (received === 0) return emptyBody;
+    const bytes = new Uint8Array(received);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return { ok: true, file: { path: path8, bytes }, size: received };
+  }
+  return { ok: false, problem: urlProblem(raw, `more than ${MAX_REDIRECTS} redirects`) };
+}
+async function resolveDeployFiles(files, opts = {}) {
+  const remoteCount = files.filter((f3) => f3.source_url !== void 0).length;
+  if (remoteCount > MAX_REMOTE_FILES) {
+    return {
+      ok: false,
+      problem: {
+        code: "too_many_source_urls",
+        message: `This deploy names ${remoteCount} source_url files; the cap is ${MAX_REMOTE_FILES} per deploy.`,
+        next: 'Deploy the rest in a follow-up mode:"patch" call \u2014 unchanged files carry forward.'
+      }
+    };
+  }
+  const maxTotal = opts.maxTotalBytes ?? MAX_BUNDLE_TOTAL_MB * 1024 * 1024;
+  const perFile = MAX_REMOTE_FILE_MB * 1024 * 1024;
+  let spent = files.reduce((total, file) => {
+    if (file.content === void 0) return total;
+    return total + (file.encoding === "base64" ? Math.floor(file.content.length * 3 / 4) : file.content.length);
+  }, 0);
+  const out = [];
+  for (const file of files) {
+    const sources = [
+      file.content !== void 0 && "content",
+      file.source_url !== void 0 && "source_url",
+      file.upload_id !== void 0 && "upload_id",
+      file.from_path !== void 0 && "from_path"
+    ].filter((s2) => s2 !== false);
+    if (sources.length > 1) {
+      return {
+        ok: false,
+        problem: {
+          code: "ambiguous_file_source",
+          message: `File "${file.path}" has ${sources.join(" and ")} \u2014 unclear which to use.`,
+          next: "Pass exactly one of content | source_url | upload_id | from_path per file."
+        }
+      };
+    }
+    if (file.upload_id !== void 0 || file.from_path !== void 0) {
+      out.push({ path: file.path, upload_id: file.upload_id, from_path: file.from_path });
+    } else if (file.source_url !== void 0) {
+      const remaining = maxTotal - spent;
+      if (remaining <= 0) {
+        return {
+          ok: false,
+          problem: {
+            code: "bundle_too_large",
+            message: `This deploy is already at the ${MAX_BUNDLE_TOTAL_MB} MB bundle limit before fetching "${file.path}".`,
+            next: 'Deploy the rest in a follow-up mode:"patch" call \u2014 unchanged files carry forward.'
+          }
+        };
+      }
+      const whole = remaining < perFile;
+      const fetched = await fetchRemote(file.path, file.source_url, {
+        maxBytes: Math.min(perFile, remaining),
+        whole
+      });
+      if (!fetched.ok) return fetched;
+      spent += fetched.size;
+      out.push(fetched.file);
+    } else if (file.content !== void 0) {
+      out.push({ path: file.path, content: file.content, encoding: file.encoding });
+    } else {
+      return {
+        ok: false,
+        problem: {
+          code: "missing_file_content",
+          message: `File "${file.path}" has no \`content\`, \`source_url\`, \`upload_id\`, or \`from_path\`.`,
+          next: "Pass the file's content inline, a public URL to fetch it from, the upload_id of a completed create_upload, or the from_path of a deployed file to copy."
+        }
+      };
+    }
+  }
+  return { ok: true, files: out };
+}
+var MAX_REMOTE_FILES, MAX_REMOTE_FILE_MB, MAX_BUNDLE_TOTAL_MB, MAX_REDIRECTS, FETCH_TIMEOUT_MS, BLOCKED_HOST_SUFFIXES, resolveAddresses, IP_LITERAL;
+var init_remote_assets = __esm({
+  "../mcp-tools/src/remote-assets.ts"() {
+    "use strict";
+    MAX_REMOTE_FILES = 20;
+    MAX_REMOTE_FILE_MB = 10;
+    MAX_BUNDLE_TOTAL_MB = 50;
+    MAX_REDIRECTS = 3;
+    FETCH_TIMEOUT_MS = 2e4;
+    BLOCKED_HOST_SUFFIXES = [".localhost", ".local", ".internal", ".home.arpa"];
+    resolveAddresses = resolveViaDoh;
+    IP_LITERAL = /^\d{1,3}(\.\d{1,3}){3}$/;
   }
 });
 
 // ../mcp-tools/src/tools.ts
 function ok(data) {
-  return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...data }, null, 2) }] };
+  return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...data }) }] };
 }
 function toolError(error2) {
   const body = apiErrorBody(error2) ?? {
     error: { code: "mcp_error", message: error2 instanceof Error ? error2.message : String(error2) }
   };
-  return { content: [{ type: "text", text: JSON.stringify({ ok: false, ...body }, null, 2) }], isError: true };
+  return { content: [{ type: "text", text: JSON.stringify({ ok: false, ...body }) }], isError: true };
 }
 function problemError(problem) {
   return new ToolApiError(422, { error: problem });
 }
+function sitePath(site) {
+  return `/v1/sites/${encodeURIComponent(site)}`;
+}
 function registerTools(server, ctx) {
   server.registerTool(
     "deploy_site",
     {
-      description: "Deploy a site to Drivethrough. Idempotent: creates the site if needed, else ships a new version. Sites are private by default. Pass `files` with generated content (the platform assembles the bundle server-side \u2014 no local filesystem or build toolchain needed), or `directory` when this tool runs on the user's machine.",
+      title: "Deploy site",
+      description: "Deploy a site to Drivethrough. Idempotent: creates the site if needed, else ships a new version. Sites are private by default. Pass `files` with generated content (the platform assembles the bundle server-side \u2014 no local filesystem or build toolchain needed), or `directory` when this tool runs on the user's machine. Images and other binary assets \u2014 pick the route by where the bytes live: already at a public URL \u2192 {path, source_url} (fetched server-side); a local file on the user's machine and no local filesystem here \u2192 create_upload first, then {path, upload_id}; a local project directory with filesystem access \u2192 `directory` carries binaries by itself; already deployed on this site \u2192 {path, from_path} copies it server-side (with delete_paths, a move). Never emit base64 by hand \u2014 inline base64 content is capped at 1 MB and is only for tiny pasted assets. To rework an already-deployed site, read it back with get_site first, then deploy with mode \"patch\" \u2014 only the files that change. For small text changes to existing files, use edit_site instead: it sends find/replace pairs, never whole files. Every deploy's version number is a restore point: prior versions stay listed (get_site history), diffable, viewable (preview_site), and returnable (revert_site).",
+      // Destructive: the default "replace" mode drops every deployed file the
+      // call doesn't re-send, and delete_paths removes files outright. Prior
+      // versions stay revertible, but the live site does lose content.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
       inputSchema: {
         directory: external_exports.string().optional().describe(
           "Path to a local project directory to deploy (stdio/CLI transport only; uses ./dist inside it when present)"
@@ -23324,31 +23881,85 @@ function registerTools(server, ctx) {
         files: external_exports.array(
           external_exports.object({
             path: external_exports.string().describe('Site-relative path like "/index.html"'),
-            content: external_exports.string().describe("File contents (text, or base64 for binary)"),
-            encoding: external_exports.enum(["utf8", "base64"]).optional().describe('How content is encoded; defaults to "utf8"')
+            content: external_exports.string().optional().describe(
+              "File contents (text, or base64 for tiny binary \u22641 MB). Give exactly one of content | source_url | upload_id | from_path."
+            ),
+            encoding: external_exports.enum(["utf8", "base64"]).optional().describe('How content is encoded; defaults to "utf8"'),
+            source_url: external_exports.string().optional().describe(
+              "Public http(s) URL to fetch this file from, server-side. The way to ship a binary asset that is already hosted somewhere \u2014 never generate base64 content by hand."
+            ),
+            upload_id: external_exports.string().optional().describe(
+              "Id of a completed direct upload (create_upload) \u2014 the way to ship a large local file the user uploaded. The platform copies the uploaded bytes into this deploy. Single-use: once deployed, reuse the file via from_path instead."
+            ),
+            from_path: external_exports.string().optional().describe(
+              `Path of a file in the site's current version to copy here, server-side \u2014 rename or duplicate a deployed file (especially a large binary) without re-sending bytes. Move = from_path + the old path in delete_paths (mode "patch").`
+            )
           })
         ).optional().describe(
           "Site files passed inline \u2014 use when there is no local filesystem (chat/remote agents). Include a drivethrough.json entry to declare data types."
         ),
         site: external_exports.string().optional().describe('Site name (defaults to drivethrough.json "site" or the folder name)'),
-        title: external_exports.string().optional().describe("Human title shown to guests")
+        title: external_exports.string().optional().describe("Human title shown to guests"),
+        mode: external_exports.enum(["replace", "patch"]).optional().describe(
+          '"patch" carries every unchanged file forward from the currently deployed version \u2014 send only the files that change (and/or delete_paths). Default "replace": the files given are the whole site.'
+        ),
+        delete_paths: external_exports.array(external_exports.string()).optional().describe('Files to remove from the site in a "patch" deploy, e.g. ["/old-page.html"]'),
+        base_version: external_exports.number().int().min(0).optional().describe(
+          "The deployed version this deploy builds on \u2014 pass it ONLY when you already know it from this conversation (an earlier get_site or deploy). If the site has moved past it (edits from another session), the deploy is refused with a summary of what changed instead of overwriting it. Never make an extra call just to learn the version \u2014 omit this instead."
+        )
       }
     },
     async ({
       directory,
       files,
       site,
-      title
+      title,
+      mode,
+      delete_paths,
+      base_version
     }) => {
       try {
+        const patch = mode === "patch";
+        if (files && files.length > 0 && directory) {
+          throw new ToolApiError(422, {
+            error: {
+              code: "ambiguous_source",
+              message: "This deploy has both inline `files` and a `directory` \u2014 unclear which is the site.",
+              next: "Pass exactly one of the two."
+            }
+          });
+        }
+        if (patch && directory) {
+          throw new ToolApiError(422, {
+            error: {
+              code: "patch_needs_files",
+              message: "Patch deploys take inline `files`, not a directory \u2014 a directory already is the whole site.",
+              next: "Deploy the directory without mode, or pass the changed files inline."
+            }
+          });
+        }
         let form;
         let config2;
-        let fallbackName = "site";
+        let fallbackName = null;
         if (files && files.length > 0) {
-          const assembled = assembleInlineBundle(files, MAX_BUNDLE_MB);
+          const resolved = await resolveDeployFiles(files);
+          if (!resolved.ok) throw problemError(resolved.problem);
+          const assembled = assembleInlineBundle(resolved.files, MAX_BUNDLE_MB);
           if (!assembled.ok) throw problemError(assembled.problem);
+          if (!patch && assembled.bundle.fileCount === 0) {
+            throw new ToolApiError(422, {
+              error: {
+                code: "config_only_replace",
+                message: "This deploy is only drivethrough.json \u2014 as a full replace it would leave the site with no files.",
+                next: 'Use mode "patch" to update the config while the deployed files carry forward.'
+              }
+            });
+          }
           form = assembled.bundle.form;
           config2 = assembled.bundle.config;
+        } else if (patch && delete_paths && delete_paths.length > 0) {
+          form = new FormData();
+          config2 = null;
         } else if (directory) {
           if (!ctx.localDirectories) {
             throw new ToolApiError(422, {
@@ -23374,13 +23985,31 @@ function registerTools(server, ctx) {
           });
         }
         const sitename = site ?? config2?.site ?? fallbackName;
+        if (!sitename) {
+          throw new ToolApiError(422, {
+            error: {
+              code: "missing_site",
+              message: "Inline deploys must name the site \u2014 otherwise unrelated deploys would collide on a default.",
+              next: 'Pass `site` (see list_sites for existing names), or include a drivethrough.json with a "site" field.'
+            }
+          });
+        }
+        if (patch) {
+          form.set("mode", "patch");
+          if (delete_paths && delete_paths.length > 0) {
+            form.set("delete_paths", JSON.stringify(delete_paths));
+          }
+        }
+        if (base_version !== void 0) {
+          form.set("base_version", String(base_version));
+        }
         const finalTitle = title ?? config2?.title;
         const siteRes = await ctx.api.request("POST", "/v1/sites", {
           body: { sitename, ...finalTitle ? { title: finalTitle } : {} }
         });
         const deploy = await ctx.api.request(
           "POST",
-          `/v1/sites/${siteRes.site.id}/deployments`,
+          `${sitePath(siteRes.site.id)}/deployments`,
           { form }
         );
         return ok({ site: siteRes.site, deploy, created: siteRes.created });
@@ -23390,31 +24019,464 @@ function registerTools(server, ctx) {
     }
   );
   server.registerTool(
-    "create_db",
+    "create_upload",
     {
-      description: "Provision the per-site database (\xA76). Idempotent. Deploying a drivethrough.json that declares types does this automatically.",
-      inputSchema: { site: external_exports.string().describe("Site name or id") }
+      title: "Create upload URL",
+      description: `Mint a short-lived signed URL the USER can upload one local file to \u2014 the route for large binary assets (photos, PDFs, audio, video) when you have no local filesystem and the file isn't hosted anywhere. The bytes never pass through you: relay the returned upload command to the user, wait for them to run it, then reference the file in deploy_site as {path, upload_id} (mode "patch" adds it to a live site). Choosing a route for a binary asset: already on the public web \u2192 deploy_site {path, source_url}; local file + this server runs on the user's machine \u2192 deploy the directory; local file + chat-only connection \u2192 this tool. Tiny pasted assets (\u22641 MB, e.g. a favicon) may still go inline as base64 content. Each link takes exactly one file, is capped at 25 MB, and expires in 15 minutes. Upload ids are single-use: the deploy that references one consumes it (the bundle keeps the bytes; the staged copy is removed and its quota refunded) \u2014 to rename or duplicate the file later, use deploy_site {path, from_path}. An upload no deploy references within 24 hours is deleted, so deploy soon after the user confirms. Pass size_bytes when the user told you the file size \u2014 quota errors then surface here instead of failing the user's upload.`,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id the upload belongs to"),
+        filename: external_exports.string().optional().describe(`The file's name, e.g. "dog.jpg" \u2014 its extension names the stored object`),
+        size_bytes: external_exports.number().int().optional().describe("Expected file size in bytes, if known \u2014 checked against the 25 MB cap and storage quota now")
+      }
     },
-    async ({ site }) => {
+    async ({ site, filename, size_bytes }) => {
       try {
-        return ok(await ctx.api.request("POST", `/v1/sites/${site}/db`));
+        return ok(
+          await ctx.api.request("POST", `${sitePath(site)}/uploads`, {
+            body: {
+              ...filename !== void 0 ? { filename } : {},
+              ...size_bytes !== void 0 ? { size_bytes } : {}
+            }
+          })
+        );
       } catch (error2) {
         return toolError(error2);
       }
     }
   );
   server.registerTool(
-    "set_privacy",
+    "edit_site",
     {
-      description: "Set a site's visibility to public or private (\xA78). Privacy is a setting \u2014 nothing redeploys.",
+      title: "Edit site files",
+      description: "Edit a deployed site's text files in place \u2014 the efficient way to make small changes (wording, values, a link, a style tweak) to a live site. Send only find/replace pairs, never whole file contents: the platform reads the current version, applies the edits, and ships a new version with everything else carried forward. Prefer this over get_site + deploy_site whenever the change is small relative to the file. Each `find` must match the deployed text exactly (whitespace included) and exactly once \u2014 add surrounding context to pin down one occurrence, or set replace_all. All-or-nothing: if any edit fails to match, nothing deploys and the error says how to recover, so you can try an edit without reading the file first. Edits are never lossy: the pre-edit version stays restorable via revert_site, so to undo an edit, revert \u2014 don't hand-invert it. After visual changes, preview_site shows what actually rendered.",
+      // Destructive: find/replace overwrites text that is currently live.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       inputSchema: {
         site: external_exports.string().describe("Site name or id"),
-        visibility: external_exports.enum(["public", "private"]).describe("Who can see the site")
+        edits: external_exports.array(
+          external_exports.object({
+            path: external_exports.string().describe('File to edit, site-relative like "/index.html"'),
+            find: external_exports.string().describe("Exact text currently in the deployed file \u2014 copy it verbatim, whitespace matters"),
+            replace: external_exports.string().describe('The new text ("" removes the matched text)'),
+            replace_all: external_exports.boolean().optional().describe("Replace every occurrence of `find` instead of requiring exactly one match")
+          })
+        ).min(1).describe("Edits applied in order; later edits see earlier results")
+      }
+    },
+    async ({ site, edits }) => {
+      try {
+        const normalized = edits.map((e3) => ({ ...e3, path: e3.path.startsWith("/") ? e3.path : `/${e3.path}` }));
+        for (const edit of normalized) {
+          if (edit.path === "/drivethrough.json") {
+            throw new ToolApiError(422, {
+              error: {
+                code: "cannot_edit_config",
+                message: "drivethrough.json is the site's config, not a served file \u2014 it can't be string-edited.",
+                next: 'Read the current config with get_site, then deploy a full drivethrough.json with mode "patch".'
+              }
+            });
+          }
+        }
+        const paths = [...new Set(normalized.map((e3) => e3.path))];
+        const query = paths.map((p2) => `path=${encodeURIComponent(p2)}`).join("&");
+        const read = await ctx.api.request("GET", `${sitePath(site)}/files?${query}`);
+        const texts = /* @__PURE__ */ new Map();
+        for (const path8 of paths) {
+          const file = read.files.find((f3) => f3.path === path8);
+          if (!file) {
+            throw new ToolApiError(422, {
+              error: {
+                code: "edit_path_not_found",
+                message: `${path8} is not in the deployed version.`,
+                next: "Check the exact path with get_site {manifest_only: true}."
+              }
+            });
+          }
+          if (file.content === void 0 || file.encoding !== "utf8") {
+            throw new ToolApiError(422, {
+              error: {
+                code: "edit_not_text",
+                message: `${path8} (${file.content_type}) is not an editable text file.`,
+                next: 'Only text files can be string-edited. Redeploy this file wholesale with deploy_site mode "patch".'
+              }
+            });
+          }
+          texts.set(path8, file.content);
+        }
+        let replacements = 0;
+        for (const [index, edit] of normalized.entries()) {
+          const outcome = applyEdit(texts.get(edit.path), edit, `edits[${index}]`);
+          if (!outcome.ok) throw problemError(outcome.problem);
+          texts.set(edit.path, outcome.content);
+          replacements += outcome.replacements;
+        }
+        const assembled = assembleInlineBundle(
+          paths.map((path8) => ({ path: path8, content: texts.get(path8) })),
+          MAX_BUNDLE_MB
+        );
+        if (!assembled.ok) throw problemError(assembled.problem);
+        assembled.bundle.form.set("mode", "patch");
+        assembled.bundle.form.set("base_version", String(read.version));
+        assembled.bundle.form.set("edit_script", JSON.stringify(normalized));
+        const deploy = await ctx.api.request(
+          "POST",
+          `${sitePath(read.site_id)}/deployments`,
+          { form: assembled.bundle.form }
+        );
+        return ok({
+          site: { id: read.site_id, sitename: read.sitename },
+          deploy,
+          files_edited: paths.length,
+          replacements
+        });
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "get_site",
+    {
+      title: "Read site files & history",
+      description: 'Read back a deployed site: file manifest, file contents, drivethrough.json \u2014 and the site\'s version history. Use this to resume work on a site from an earlier conversation. Read the minimum you need: `find` locates text without returning file contents, `manifest_only` lists what exists, `paths` fetches only named files \u2014 a bare call inlines every text file, so reserve it for genuinely reading a whole small site. Versions: every deploy is a numbered version the platform keeps. `history: true` lists them with what each one changed (the map for revert_site), `compare: {from, to}` returns line diffs between two versions ("what did v9\u2192v10 change?"), and `version` pins any read mode to a prior version instead of the live one. Modes are exclusive per call \u2014 compare wins over history, history over find/manifest_only. Entries come back deploy_site-compatible ({path, content, encoding}); binary files are listed but only inlined when named in `paths`. For small text changes you may not need this at all \u2014 edit_site applies find/replace to the deployed files directly.',
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        paths: external_exports.array(external_exports.string()).optional().describe(
+          'Return only these files, e.g. ["/index.html"] \u2014 naming a binary file inlines it as base64. With `find`, restricts the search to these files.'
+        ),
+        find: external_exports.string().optional().describe(
+          "Search the deployed text files for this literal string instead of returning contents. Matches come back as byte-exact lines with path + line number \u2014 usable directly as edit_site `find` context. The cheap way to locate text before editing."
+        ),
+        manifest_only: external_exports.boolean().optional().describe("List files (path, size, type, sha256) without any contents \u2014 a cheap inventory of what's deployed"),
+        version: external_exports.number().int().optional().describe(
+          "Read a prior version instead of the live one \u2014 works with paths, find, and manifest_only. The response's current_version shows what's actually live."
+        ),
+        history: external_exports.union([external_exports.boolean(), external_exports.number().int()]).optional().describe(
+          "true: list the most recent versions \u2014 number, date, size, and which files each one added/changed/removed. Pass a version number instead to page further back (versions before it). The cheap first call when the user wants something undone."
+        ),
+        compare: external_exports.object({
+          from: external_exports.number().int().describe("Older version"),
+          to: external_exports.number().int().describe("Newer version")
+        }).optional().describe(
+          "Line-diff two versions: per-file added/removed/changed status plus compact unified diffs for changed text files. Use before revert_site to see exactly what going back would change."
+        )
+      }
+    },
+    async ({
+      site,
+      paths,
+      find,
+      manifest_only,
+      version: version2,
+      history,
+      compare
+    }) => {
+      try {
+        if (compare) {
+          return ok(await ctx.api.request("GET", `${sitePath(site)}/diff?from=${compare.from}&to=${compare.to}`));
+        }
+        if (history !== void 0 && history !== false) {
+          if (typeof history === "number" && history < 1) {
+            throw new ToolApiError(422, {
+              error: {
+                code: "invalid_history",
+                message: "`history` as a number pages back from that version \u2014 it must be 1 or greater.",
+                next: "Pass history: true for the most recent versions."
+              }
+            });
+          }
+          const before = typeof history === "number" ? `?before=${history}` : "";
+          return ok(await ctx.api.request("GET", `${sitePath(site)}/versions${before}`));
+        }
+        if (find !== void 0 && find.length === 0) {
+          throw new ToolApiError(422, {
+            error: {
+              code: "empty_find",
+              message: "`find` is empty \u2014 an empty search matches nothing.",
+              next: "Pass the literal text to locate, or use manifest_only to list files."
+            }
+          });
+        }
+        const params = new URLSearchParams();
+        for (const p2 of paths ?? []) params.append("path", p2);
+        if (find !== void 0) params.set("find", find);
+        else if (manifest_only) params.set("manifest_only", "1");
+        if (version2 !== void 0) params.set("version", String(version2));
+        const query = params.toString();
+        return ok(await ctx.api.request("GET", `${sitePath(site)}/files${query ? `?${query}` : ""}`));
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "preview_site",
+    {
+      title: "Preview site (screenshot)",
+      description: "See a deployed site the way a visitor does: renders the page in a real browser server-side and returns a screenshot image you can look at directly. You have no browser of your own \u2014 this is your only view of rendered results, so use it to verify visual work (layout, styling, animations, responsive behavior) actually shipped correctly instead of assuming it did, and to eyeball a prior `version` before reverting to it. Works on private sites; nothing becomes public. Takes a few seconds \u2014 look once after a coherent batch of changes, not after every edit. Animations: the capture happens at page load; pass wait_ms to let one settle or reach mid-cycle.",
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        path: external_exports.string().optional().describe('Page to render, like "/about.html" (default "/")'),
+        version: external_exports.number().int().optional().describe("Render a prior version instead of the live one \u2014 see it before you revert_site to it"),
+        viewport: external_exports.enum(["desktop", "mobile"]).optional().describe('"desktop" 1280\xD7800 (default) or "mobile" 390\xD7844 for responsive checks'),
+        wait_ms: external_exports.number().int().optional().describe("Extra milliseconds after page load before capturing (max 5000) \u2014 for animations/transitions"),
+        full_page: external_exports.boolean().optional().describe("Capture the full page height, not just the viewport \u2014 costlier to read, use when below-the-fold matters")
+      }
+    },
+    async ({
+      site,
+      path: path8,
+      version: version2,
+      viewport,
+      wait_ms,
+      full_page
+    }) => {
+      try {
+        const { image_base64, content_type, ...meta } = await ctx.api.request("POST", `${sitePath(site)}/preview`, {
+          body: {
+            ...path8 !== void 0 ? { path: path8 } : {},
+            ...version2 !== void 0 ? { version: version2 } : {},
+            ...viewport !== void 0 ? { viewport } : {},
+            ...wait_ms !== void 0 ? { wait_ms } : {},
+            ...full_page !== void 0 ? { full_page } : {}
+          }
+        });
+        return {
+          content: [
+            { type: "image", data: image_base64, mimeType: content_type },
+            { type: "text", text: JSON.stringify({ ok: true, ...meta }) }
+          ]
+        };
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "revert_site",
+    {
+      title: "Revert site to a version",
+      description: `Return a site to a prior version, byte-exactly, in one call \u2014 the safe way to undo. When the user says "undo that" or "put it back how it was", use this; never reconstruct the old state by hand with inverse edits, which risks leaving the site neither old nor new. The platform redeploys the target version's exact stored files as a new version \u2014 history is preserved, so a revert can itself be reverted \u2014 and the response proves the restore: byte_identical: true means the new version's content hash equals the target's. Find the target with get_site {history: true} (each entry shows what that version changed), or use the version number a deploy/edit response reported. Undoing just one file of a multi-file change? Read that file at the old version (get_site {version, paths}) and deploy it with mode "patch" instead.`,
+      // Destructive: the live site's current content is replaced by the older
+      // version's. Recoverable (the replaced version is itself kept), but the
+      // visible site does change out from under whatever was there.
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        to_version: external_exports.number().int().min(1).describe("The version to return to (see get_site {history: true})")
+      }
+    },
+    async ({ site, to_version }) => {
+      try {
+        return ok(await ctx.api.request("POST", `${sitePath(site)}/revert`, { body: { to_version } }));
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "create_db",
+    {
+      title: "Create site database",
+      description: "Provision the per-site database. Idempotent. Deploying a drivethrough.json that declares types does this automatically.",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      inputSchema: { site: external_exports.string().describe("Site name or id") }
+    },
+    async ({ site }) => {
+      try {
+        return ok(await ctx.api.request("POST", `${sitePath(site)}/db`));
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "query_db",
+    {
+      title: "Query site database",
+      description: "Read the site's database as its owner (read-only \u2014 writes go through write_db): list the types present with row counts, list rows of a type, or fetch one row by id. Every row is {id, parent_id, type, json, created_at} \u2014 json is the document. Owner access skips visitor-side permission checks.",
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        action: external_exports.enum(["types", "list", "get"]).describe("types = row counts per type; list = rows of a type; get = one row by id"),
+        type: external_exports.string().optional().describe("Row type \u2014 required for list"),
+        id: external_exports.string().optional().describe("Row id \u2014 required for get"),
+        parent_id: external_exports.string().optional().describe("list: return only rows whose parent is this row id"),
+        limit: external_exports.number().int().optional().describe("list: max rows (default 100, cap 500)"),
+        offset: external_exports.number().int().optional().describe("list: rows to skip, for pagination")
+      }
+    },
+    async ({
+      site,
+      action,
+      type,
+      id,
+      parent_id,
+      limit,
+      offset
+    }) => {
+      try {
+        switch (action) {
+          case "types":
+            return ok(await ctx.api.request("GET", `${sitePath(site)}/data/types`));
+          case "list": {
+            if (parent_id !== void 0 && parent_id === "") {
+              throw new ToolApiError(422, {
+                error: {
+                  code: "parent_filter_unsupported",
+                  message: "Filtering to rows WITHOUT a parent isn't supported \u2014 `parent_id` must be a row id.",
+                  next: "List the type without parent_id and select the parent_id === null rows from the result."
+                }
+              });
+            }
+            const params = new URLSearchParams();
+            if (type) params.set("type", type);
+            if (parent_id !== void 0) params.set("parent", parent_id);
+            if (limit !== void 0) params.set("limit", String(limit));
+            if (offset !== void 0) params.set("offset", String(offset));
+            return ok(await ctx.api.request("GET", `${sitePath(site)}/data?${params}`));
+          }
+          case "get": {
+            if (!id) {
+              throw new ToolApiError(422, {
+                error: {
+                  code: "missing_id",
+                  message: 'query_db action "get" needs `id`.',
+                  next: 'Find row ids with action "list".'
+                }
+              });
+            }
+            return ok(await ctx.api.request("GET", `${sitePath(site)}/data?id=${encodeURIComponent(id)}`));
+          }
+        }
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "write_db",
+    {
+      title: "Write site database",
+      description: "Write to the site's database as its owner: insert, update, or delete rows (reads go through query_db). To change a few fields of a row, `update` with `merge` \u2014 only the fields that change, no fetch needed. Reserve `json` (wholesale replacement) for rewriting the whole document. Writes are validated against the types declared in the site's drivethrough.json (unknown types and mismatched fields are rejected); pass validate: false only for a deliberate migration. Deleted and overwritten rows are gone for good \u2014 there is no version history for data, so read a row (query_db) before destructive rewrites you might need to undo. Daily write quotas apply.",
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        action: external_exports.enum(["insert", "update", "delete"]).describe("What to do with the row"),
+        type: external_exports.string().optional().describe("Row type \u2014 required for insert"),
+        id: external_exports.string().optional().describe("Row id \u2014 required for update and delete"),
+        parent_id: external_exports.string().nullable().optional().describe("Parent row id to set on insert/update (null clears it)"),
+        json: external_exports.record(external_exports.unknown()).optional().describe("The row's full document \u2014 required for insert; a wholesale replacement on update (prefer `merge`)"),
+        merge: external_exports.record(external_exports.unknown()).optional().describe(
+          "update: change only these fields, merged into the row's existing document (RFC 7386: nested objects merge, null deletes a field). The cheap way to update \u2014 no fetch-modify-resend."
+        ),
+        validate: external_exports.boolean().optional().describe("insert/update: set false to bypass declared-type validation \u2014 only for deliberate migrations")
+      }
+    },
+    async ({
+      site,
+      action,
+      type,
+      id,
+      parent_id,
+      json,
+      merge: merge2,
+      validate: validate2
+    }) => {
+      try {
+        const needId = () => {
+          if (!id) {
+            throw new ToolApiError(422, {
+              error: {
+                code: "missing_id",
+                message: `write_db action "${action}" needs \`id\`.`,
+                next: 'Find row ids with query_db action "list".'
+              }
+            });
+          }
+          return id;
+        };
+        switch (action) {
+          case "insert": {
+            if (merge2 !== void 0) {
+              throw new ToolApiError(422, {
+                error: {
+                  code: "merge_not_for_insert",
+                  message: "`merge` applies to update only \u2014 insert takes the row's full document in `json`.",
+                  next: "Pass the document as `json`."
+                }
+              });
+            }
+            if (!type) {
+              throw new ToolApiError(422, {
+                error: {
+                  code: "missing_type",
+                  message: 'write_db action "insert" needs `type`.',
+                  next: 'See the types present with query_db action "types", or declare them in drivethrough.json.'
+                }
+              });
+            }
+            if (json === void 0) {
+              throw new ToolApiError(422, {
+                error: {
+                  code: "missing_json",
+                  message: 'write_db action "insert" needs `json` \u2014 the row\'s document.',
+                  next: "Pass json: {} explicitly if the row is deliberately empty."
+                }
+              });
+            }
+            return ok(
+              await ctx.api.request("POST", `${sitePath(site)}/data`, {
+                body: { type, parent_id, json, ...validate2 !== void 0 ? { validate: validate2 } : {} }
+              })
+            );
+          }
+          case "update":
+            if (json !== void 0 && merge2 !== void 0) {
+              throw new ToolApiError(422, {
+                error: {
+                  code: "ambiguous_update",
+                  message: "Pass either `json` (full replacement) or `merge` (partial), not both.",
+                  next: "For a small change, `merge` with just the fields that change is enough."
+                }
+              });
+            }
+            return ok(
+              await ctx.api.request("PATCH", `${sitePath(site)}/data/${encodeURIComponent(needId())}`, {
+                body: {
+                  ...type !== void 0 ? { type } : {},
+                  ...parent_id !== void 0 ? { parent_id } : {},
+                  ...json !== void 0 ? { json } : {},
+                  ...merge2 !== void 0 ? { merge: merge2 } : {},
+                  ...validate2 !== void 0 ? { validate: validate2 } : {}
+                }
+              })
+            );
+          case "delete":
+            return ok(await ctx.api.request("DELETE", `${sitePath(site)}/data/${encodeURIComponent(needId())}`));
+        }
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "set_privacy",
+    {
+      title: "Set site visibility",
+      description: "Set a site's visibility to public or private. Privacy is a setting \u2014 nothing redeploys.",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        visibility: external_exports.enum(["public", "private"]).describe("Who can see the site")
       }
     },
     async ({ site, visibility }) => {
       try {
-        return ok(await ctx.api.request("POST", `/v1/sites/${site}/privacy`, { body: { visibility } }));
+        return ok(await ctx.api.request("POST", `${sitePath(site)}/privacy`, { body: { visibility } }));
       } catch (error2) {
         return toolError(error2);
       }
@@ -23423,7 +24485,9 @@ function registerTools(server, ctx) {
   server.registerTool(
     "share_site",
     {
-      description: "Create a share link for a private site, or send a magic-link invitation by email (\xA78). Anyone with the link can view; guests never make accounts.",
+      title: "Share site",
+      description: "Create a share link for a private site, or send a magic-link invitation by email. Anyone with the link can view; guests never make accounts.",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
       inputSchema: {
         site: external_exports.string().describe("Site name or id"),
         email: external_exports.string().email().optional().describe("Send a magic-link invitation to this email instead of returning a link")
@@ -23431,8 +24495,8 @@ function registerTools(server, ctx) {
     },
     async ({ site, email: email2 }) => {
       try {
-        if (email2) return ok(await ctx.api.request("POST", `/v1/sites/${site}/invite`, { body: { email: email2 } }));
-        return ok(await ctx.api.request("POST", `/v1/sites/${site}/share`));
+        if (email2) return ok(await ctx.api.request("POST", `${sitePath(site)}/invite`, { body: { email: email2 } }));
+        return ok(await ctx.api.request("POST", `${sitePath(site)}/share`));
       } catch (error2) {
         return toolError(error2);
       }
@@ -23441,7 +24505,9 @@ function registerTools(server, ctx) {
   server.registerTool(
     "list_sites",
     {
+      title: "List sites",
       description: "List the authenticated account's sites with their addresses, visibility, and status. Pass include_deleted to also see recently deleted sites (recoverable for 30 days via restore_site).",
+      annotations: { readOnlyHint: true, openWorldHint: false },
       inputSchema: {
         include_deleted: external_exports.boolean().optional().describe("Also list deleted sites still inside their 30-day recovery window")
       }
@@ -23457,12 +24523,74 @@ function registerTools(server, ctx) {
   server.registerTool(
     "delete_site",
     {
+      title: "Delete site",
       description: "Delete a site. Two-phase and safe: the site leaves the driveway immediately (guests lose access, share links are revoked, the name frees up) but stays recoverable for 30 days via restore_site. Only after 30 days is it destroyed for good.",
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       inputSchema: { site: external_exports.string().describe("Site name or id") }
     },
     async ({ site }) => {
       try {
-        return ok(await ctx.api.request("DELETE", `/v1/sites/${site}`));
+        return ok(await ctx.api.request("DELETE", sitePath(site)));
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "check_domain",
+    {
+      title: "Check custom domain",
+      description: `Check a site's custom domain, read-only. "status": live verification progress \u2014 pending_dns (waiting on DNS records) \u2192 pending_ssl (certificate issuing) \u2192 active (serving with TLS); poll after setup and tell the user when it's live. "connect": look up one-click setup at the user's registrar (GoDaddy, Cloudflare, IONOS, Squarespace, \u2026) \u2014 when a URL comes back, relay it and their registrar creates the records in one click; otherwise relay the copy-paste records manage_domain attach returned.`,
+      // Not readOnlyHint despite being the "read" half of the domain pair:
+      // "status" re-polls the certificate authority and caches the transition
+      // it observes, and "connect" queries the user's registrar. Both reach
+      // outside and one writes, so neither claim would be true.
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      inputSchema: {
+        site: external_exports.string().describe("Site name or id"),
+        action: external_exports.enum(["status", "connect"]).describe('"status" = verification progress; "connect" = one-click registrar setup lookup')
+      }
+    },
+    async ({ site, action }) => {
+      try {
+        if (action === "connect") return ok(await ctx.api.request("GET", `${sitePath(site)}/domain/connect`));
+        return ok(await ctx.api.request("GET", `${sitePath(site)}/domain`));
+      } catch (error2) {
+        return toolError(error2);
+      }
+    }
+  );
+  server.registerTool(
+    "manage_domain",
+    {
+      title: "Attach/detach custom domain",
+      description: 'Attach or detach a custom domain the user already owns (paid plans). "attach": connect the domain to the site \u2014 returns the exact DNS records to add; afterwards use check_domain {action: "connect"} for a one-click registrar link and check_domain {action: "status"} to poll until active. "detach": remove the domain from the site. The site keeps its drivethrough.site address throughout.',
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      inputSchema: {
+        action: external_exports.enum(["attach", "detach"]).describe("Connect the domain, or remove it"),
+        site: external_exports.string().describe("Site name or id"),
+        domain: external_exports.string().optional().describe('The domain, e.g. "timsfossils.com" \u2014 required for attach')
+      }
+    },
+    async ({
+      action,
+      site,
+      domain
+    }) => {
+      try {
+        if (action === "attach") {
+          if (!domain) {
+            throw new ToolApiError(422, {
+              error: {
+                code: "missing_domain",
+                message: 'manage_domain action "attach" needs `domain`.',
+                next: 'Pass a bare domain like "timsfossils.com".'
+              }
+            });
+          }
+          return ok(await ctx.api.request("POST", `${sitePath(site)}/domain`, { body: { domain } }));
+        }
+        return ok(await ctx.api.request("DELETE", `${sitePath(site)}/domain`));
       } catch (error2) {
         return toolError(error2);
       }
@@ -23471,7 +24599,9 @@ function registerTools(server, ctx) {
   server.registerTool(
     "restore_site",
     {
-      description: "Restore a deleted site within its 30-day recovery window. It comes back exactly as it was \u2014 content, data, visibility \u2014 minus guest access (share links stay revoked; create new ones). If the old name is taken, pass `sitename` to restore under a new name.",
+      title: "Restore deleted site",
+      description: "Restore a deleted site within its 30-day recovery window. It comes back exactly as it was \u2014 content, data, visibility \u2014 minus guest access (share links stay revoked; create new ones). If the old name is taken, pass `sitename` to restore under a new name. (Undoing changes to a live site is different \u2014 that's revert_site.)",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       inputSchema: {
         site: external_exports.string().describe("The deleted site's original name, or its site id"),
         sitename: external_exports.string().optional().describe("Restore under this new name instead (when the old name is taken)")
@@ -23479,8 +24609,17 @@ function registerTools(server, ctx) {
     },
     async ({ site, sitename }) => {
       try {
+        if (sitename !== void 0 && sitename.length === 0) {
+          throw new ToolApiError(422, {
+            error: {
+              code: "invalid_sitename",
+              message: "`sitename` is empty \u2014 pass a real name, or omit it to restore under the original name.",
+              next: "Omit sitename unless the old name is taken."
+            }
+          });
+        }
         return ok(
-          await ctx.api.request("POST", `/v1/sites/${site}/restore`, {
+          await ctx.api.request("POST", `${sitePath(site)}/restore`, {
             body: sitename ? { sitename } : {}
           })
         );
@@ -23490,14 +24629,31 @@ function registerTools(server, ctx) {
     }
   );
 }
-var MAX_BUNDLE_MB;
+var MAX_BUNDLE_MB, SERVER_INSTRUCTIONS;
 var init_tools = __esm({
   "../mcp-tools/src/tools.ts"() {
     "use strict";
     init_zod();
     init_api3();
+    init_edits();
     init_inline_files();
+    init_remote_assets();
     MAX_BUNDLE_MB = 50;
+    SERVER_INSTRUCTIONS = `Drivethrough hosts websites: deploy, share, collect data. Sites are private by default; guests never need accounts.
+
+Work token-efficiently \u2014 generated output is your scarcest resource:
+- LOCATE, don't read: to find where text lives on a deployed site, call get_site with \`find\` \u2014 it returns byte-exact matching lines. Use \`manifest_only\` to see what files exist. Read full contents (\`paths\`) only when you genuinely need them; a bare get_site inlines every text file.
+- EDIT, don't resend: change existing files with edit_site (exact find/replace). Never re-emit a whole file to change a small part. Use deploy_site mode "patch" for new files or wholesale rewrites \u2014 unchanged files carry forward automatically.
+- REFERENCE, don't inline: never generate base64 by hand. To ship an image or other binary asset, pick the route by where the bytes live: already at a public URL \u2192 deploy_site {path, source_url}, fetched server-side; a local file on the user's machine \u2192 create_upload mints a signed URL the user uploads it to, then deploy_site {path, upload_id}. (Agents with a local filesystem deploy the directory instead \u2014 binaries ride along.) To move or duplicate an ALREADY-DEPLOYED file, {path, from_path} copies it server-side \u2014 never re-upload unchanged bytes. Inline base64 content is capped at 1 MB and exists only for tiny pasted assets like a favicon.
+- MERGE, don't replace: to change a few fields of a database row, write_db update with \`merge\` (null deletes a field). No need to fetch the row first.
+- UNDO by version, never by inverse edits: every deploy is a numbered version the platform keeps. When the user wants a change undone, call revert_site \u2014 it restores the exact bytes of any prior version in one call and proves it. Reconstructing old content from memory with edit_site is how sites end up in a state that is neither old nor new.
+- LOOK at what shipped: you have no browser, but preview_site returns a real rendered screenshot of any version \u2014 your only way to see visual results. Use it after layout/style/animation work, or to eyeball an old version before reverting.
+- DON'T overwrite unseen work: when you already know the deployed version (an earlier get_site or deploy in THIS conversation), pass it to deploy_site as \`base_version\` \u2014 if the site moved past it (another session deployed), the deploy is refused with a summary of what changed instead of clobbering it. Never make an extra call just to learn the version; omit it instead. edit_site guards itself. On a \`remote_changes\` refusal, read what changed (get_site {history: true}), fold it in, then redeploy with the current version.
+- Trust the errors: every failure returns {code, message, next} \u2014 and sometimes \`found\` with the exact deployed text to retry with. Follow \`next\` instead of guessing.
+
+Typical small-change flow, two calls total: get_site {find: "old phrase"} \u2192 edit_site {edits: [{path, find, replace}]}. If you already know the exact deployed text, edit_site alone is enough \u2014 a miss fails safely with recovery instructions. For visual changes, add preview_site to see the result; to undo anything, get_site {history: true} \u2192 revert_site.
+
+Custom domains (paid plans): manage_domain attaches a domain the user already owns. After attaching, check_domain {action: "connect"} looks up one-click setup at their registrar (relay the URL when offered, else the exact DNS records from attach), and check_domain {action: "status"} polls until "active" \u2014 DNS seen, then TLS issued.`;
   }
 });
 
@@ -23506,7 +24662,9 @@ var init_src2 = __esm({
   "../mcp-tools/src/index.ts"() {
     "use strict";
     init_api3();
+    init_edits();
     init_inline_files();
+    init_remote_assets();
     init_tools();
   }
 });
@@ -23518,9 +24676,9 @@ __export(mcp_exports, {
   runMcpServer: () => runMcpServer
 });
 function buildMcpServer() {
-  const server = new McpServer({ name: "drivethrough", version: "0.1.0" });
+  const server = new McpServer({ name: "drivethrough", version: "0.1.0" }, { instructions: SERVER_INSTRUCTIONS });
   registerTools(server, {
-    api: { request: (method, path5, options) => api(method, path5, options) },
+    api: { request: (method, path8, options) => api(method, path8, options) },
     localDirectories
   });
   return server;
@@ -25104,7 +26262,7 @@ async function runMain(cmd, opts = {}) {
 }
 
 // src/commands/deploy.ts
-import path3 from "node:path";
+import path4 from "node:path";
 
 // ../../node_modules/.pnpm/@clack+prompts@0.10.1/node_modules/@clack/prompts/dist/index.mjs
 import { stripVTControlCharacters as S4 } from "node:util";
@@ -25636,6 +26794,10 @@ var deployCommand = defineCommand({
     dir: { type: "positional", description: "Project directory (uses ./dist inside it when present)", required: false },
     site: { type: "string", description: 'Site name (defaults to drivethrough.json "site", then the folder name)' },
     title: { type: "string", description: "Site title shown to guests" },
+    force: {
+      type: "boolean",
+      description: "Deploy even if the site changed remotely since the last sync (skips the base_version guard)"
+    },
     json: { type: "boolean", description: "Machine-readable output" }
   },
   async run({ args }) {
@@ -25649,7 +26811,7 @@ var deployCommand = defineCommand({
         throw new ApiError2(422, { error: assembled.problem });
       }
       const bundle = assembled.bundle;
-      const sitename = args.site ?? bundle.config?.site ?? path3.basename(path3.resolve(dir)).toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+      const sitename = args.site ?? bundle.config?.site ?? path4.basename(path4.resolve(dir)).toLowerCase().replace(/[^a-z0-9-]+/g, "-");
       const title = args.title ?? bundle.config?.title;
       if (!isJsonMode(jsonArgs)) Ie("drivethrough deploy");
       const siteRes = await api("POST", "/v1/sites", {
@@ -25661,8 +26823,22 @@ var deployCommand = defineCommand({
         );
         M2.step(`Uploading ${bundle.files.length} files (${(bundle.totalBytes / 1024).toFixed(0)} kB)\u2026`);
       }
+      const { readState: readState2, writeState: writeState2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+      const root = path4.resolve(dir);
+      const state = readState2(root);
+      const form = bundleForm2(bundle);
+      if (!args.force && state && state.site_id === siteRes.site.id) {
+        form.set("base_version", String(state.version));
+      }
       const deploy = await api("POST", `/v1/sites/${siteRes.site.id}/deployments`, {
-        form: bundleForm2(bundle)
+        form
+      });
+      writeState2(root, {
+        site_id: deploy.site_id,
+        sitename,
+        version: deploy.version,
+        bundle_hash: deploy.bundle_hash,
+        synced_at: (/* @__PURE__ */ new Date()).toISOString()
       });
       emit(jsonArgs, { site: siteRes.site, deploy, created: siteRes.created }, () => {
         M2.success(`Version ${deploy.version} is live.`);
@@ -26119,13 +27295,135 @@ var dbCommand = defineCommand({
   subCommands: { create: createCommand }
 });
 
+// src/commands/data.ts
+init_api();
+var typesCommand = defineCommand({
+  meta: { name: "types", description: "List the row types in the site's database, with counts" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const res = await api(
+        "GET",
+        `/v1/sites/${args.site}/data/types`
+      );
+      emit(jsonArgs, { ...res }, () => {
+        if (res.types.length === 0) {
+          M2.message("The database is empty.");
+          return;
+        }
+        for (const t2 of res.types) M2.message(`  ${t2.type}: ${t2.count} row(s)`);
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List rows of a type" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    type: { type: "positional", description: "Row type", required: true },
+    parent: { type: "string", description: "Only rows under this parent id" },
+    limit: { type: "string", description: "Max rows (default 100, cap 500)" },
+    offset: { type: "string", description: "Rows to skip (pagination)" },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const params = new URLSearchParams({ type: args.type });
+      if (args.parent) params.set("parent", args.parent);
+      if (args.limit) params.set("limit", args.limit);
+      if (args.offset) params.set("offset", args.offset);
+      const res = await api("GET", `/v1/sites/${args.site}/data?${params}`);
+      emit(jsonArgs, { ...res }, () => {
+        if (res.items.length === 0) {
+          M2.message(`No "${args.type}" rows.`);
+          return;
+        }
+        for (const row of res.items) {
+          M2.message(`  ${row.id}  ${JSON.stringify(row.json)}`);
+        }
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+var getCommand = defineCommand({
+  meta: { name: "get", description: "Fetch one row by id" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    id: { type: "positional", description: "Row id", required: true },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const res = await api(
+        "GET",
+        `/v1/sites/${args.site}/data?id=${encodeURIComponent(args.id)}`
+      );
+      emit(jsonArgs, { item: res.items[0] }, () => {
+        M2.message(JSON.stringify(res.items[0], null, 2));
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+var dataCommand = defineCommand({
+  meta: { name: "data", description: "Inspect the site's database" },
+  subCommands: { types: typesCommand, list: listCommand, get: getCommand }
+});
+
+// src/commands/files.ts
+init_api();
+var filesCommand = defineCommand({
+  meta: { name: "files", description: "Read back a deployed site's files" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    path: { type: "positional", description: 'A single file to print (e.g. "/index.html")', required: false },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const query = args.path ? `?path=${encodeURIComponent(args.path)}` : "";
+      const res = await api("GET", `/v1/sites/${args.site}/files${query}`);
+      if (args.path && !isJsonMode(jsonArgs)) {
+        const file = res.files[0];
+        if (file?.content !== void 0) {
+          const out = file.encoding === "base64" ? Buffer.from(file.content, "base64") : Buffer.from(file.content, "utf8");
+          process.stdout.write(out);
+        } else {
+          M2.warn(`${file?.path ?? args.path}: content not inlined (${file?.content_omitted ?? "unknown"}).`);
+        }
+        return;
+      }
+      emit(jsonArgs, { ...res }, () => {
+        M2.message(`${res.sitename} \u2014 version ${res.version}, ${(res.total_bytes / 1024).toFixed(1)} KB`);
+        for (const file of res.files) {
+          M2.message(`  ${file.path}  (${file.content_type}, ${file.size} bytes)`);
+        }
+        if (res.note) M2.info(res.note);
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+
 // src/commands/upgrade.ts
 init_api();
 var upgradeCommand = defineCommand({
   meta: { name: "upgrade", description: "Get a checkout link to upgrade your plan" },
   args: {
     plan: { type: "string", description: '"personal" or "pro"', default: "personal" },
-    domain: { type: "string", description: "Custom domain to bundle into a Personal checkout" },
     interval: { type: "string", description: '"monthly" or "yearly" (Personal headline is yearly)' },
     json: { type: "boolean", description: "Machine-readable output" }
   },
@@ -26136,14 +27434,12 @@ var upgradeCommand = defineCommand({
       const res = await api("POST", "/v1/billing/checkout", {
         body: {
           plan,
-          ...args.domain ? { domain: args.domain } : {},
           ...args.interval ? { interval: args.interval } : {}
         }
       });
       emit(jsonArgs, { checkout_url: res.url, plan }, () => {
         M2.success(`Here's your secure checkout link (${plan} plan):`);
         Me(res.url, "open to finish");
-        if (args.domain) M2.info(`Your domain ${args.domain} is bundled into this one approval.`);
       });
     } catch (error2) {
       fail(jsonArgs, error2);
@@ -26153,8 +27449,17 @@ var upgradeCommand = defineCommand({
 
 // src/commands/domain.ts
 init_api();
+function recordLines(records) {
+  return records.map((r3) => `${r3.type}  ${r3.name}  \u2192  ${r3.value}${r3.note ? `
+  (${r3.note})` : ""}`).join("\n");
+}
+var STATUS_HUMAN = {
+  pending_dns: "waiting for DNS to point at us",
+  pending_ssl: "DNS looks right \u2014 issuing the TLS certificate",
+  active: "live with TLS"
+};
 var addCommand = defineCommand({
-  meta: { name: "add", description: "Attach a custom domain to a site" },
+  meta: { name: "add", description: "Attach a domain you already own to a site" },
   args: {
     site: { type: "positional", description: "Site name", required: true },
     domain: { type: "positional", description: "Domain, e.g. timsfossils.com", required: true },
@@ -26169,11 +27474,11 @@ var addCommand = defineCommand({
         { body: { domain: args.domain } }
       );
       emit(jsonArgs, { ...res }, () => {
-        M2.success(`${res.domain} is attached to ${args.site}.`);
-        if (res.dns) {
-          Me(
-            Object.entries(res.dns).map(([k4, v3]) => `${k4}: ${v3}`).join("\n"),
-            "point your DNS here"
+        M2.success(`${res.domain} is attached to ${args.site} (${STATUS_HUMAN[res.status] ?? res.status}).`);
+        if (res.status !== "active") {
+          Me(recordLines(res.records), "add these DNS records at your registrar");
+          M2.info(
+            `Try one-click setup first: \`drivethrough domain connect ${args.site}\` \u2014 then \`drivethrough domain status ${args.site}\` until it's live.`
           );
         }
       });
@@ -26182,9 +27487,80 @@ var addCommand = defineCommand({
     }
   }
 });
+var statusCommand = defineCommand({
+  meta: { name: "status", description: "Check a site's domain: DNS seen, certificate issued, live" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const res = await api(
+        "GET",
+        `/v1/sites/${args.site}/domain`
+      );
+      emit(jsonArgs, { ...res }, () => {
+        M2.info(`${res.domain}: ${STATUS_HUMAN[res.status] ?? res.status}`);
+        if (res.status === "pending_dns") {
+          Me(recordLines(res.records), "still waiting on these records");
+        }
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+var connectCommand = defineCommand({
+  meta: { name: "connect", description: "One-click DNS setup at supported registrars (GoDaddy, Cloudflare, \u2026)" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const res = await api("GET", `/v1/sites/${args.site}/domain/connect`);
+      emit(jsonArgs, { ...res }, () => {
+        if (res.supported && res.url) {
+          M2.success(`${res.provider} can set up ${res.domain} in one click:`);
+          Me(res.url, "open to approve the DNS changes");
+        } else {
+          M2.info(`${res.domain}'s registrar doesn't offer one-click setup \u2014 add these records by hand:`);
+          Me(recordLines(res.records), "DNS records");
+        }
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+var removeCommand = defineCommand({
+  meta: { name: "remove", description: "Detach the custom domain from a site" },
+  args: {
+    site: { type: "positional", description: "Site name", required: true },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const res = await api("DELETE", `/v1/sites/${args.site}/domain`);
+      emit(jsonArgs, { ...res }, () => {
+        M2.success(`${res.detached} is detached. The site still serves at its drivethrough.site address.`);
+      });
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
 var domainCommand = defineCommand({
-  meta: { name: "domain", description: "Custom domains" },
-  subCommands: { add: addCommand }
+  meta: { name: "domain", description: "Custom domains: connect one you own" },
+  subCommands: {
+    add: addCommand,
+    status: statusCommand,
+    connect: connectCommand,
+    remove: removeCommand
+  }
 });
 
 // src/commands/collaborators.ts
@@ -26280,8 +27656,8 @@ var mcpCommand = defineCommand({
 });
 
 // src/commands/agent-setup.ts
-import { writeFileSync as writeFileSync2 } from "node:fs";
-import path4 from "node:path";
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import path5 from "node:path";
 
 // src/agent-docs.ts
 var SKILL_MD = `---
@@ -26337,6 +27713,10 @@ Declare data types the site collects. The platform owns the write path.
 }
 \`\`\`
 - \`write\`: "public" | "viewers" | "owner". Public writes require Turnstile.
+- \`read\`: "public" | "viewers" | "owner". Defaults follow \`write\` \u2014 owner-authored
+  types read "public", \`write: "viewers"\` reads "viewers", and \`write: "public"\`
+  reads "owner" (form submissions belong to whoever typed them). Set
+  \`"read": "public"\` explicitly to publish submissions, e.g. a public guestbook.
 - \`unique_per: "session"\`: the row edits itself (an RSVP updates, never duplicates).
 - \`notify: "owner-email"\`: the owner gets an email on each entry (leads/RSVPs).
 - \`indexes\`: [{ "type": "event", "path": "$.date" }] for larger datasets.
@@ -26351,6 +27731,81 @@ await data.ofType("rsvp").create({ name, attending: true });
 const rows = await data.ofType("rsvp").list();
 \`\`\`
 
+## Resuming work on a deployed site
+Every deployed site can be read back \u2014 files and database \u2014 so work can
+continue in a later session:
+- \`drivethrough files <site> --json\` \u2014 the deployed version's manifest and
+  file contents (or one file: \`drivethrough files <site> /index.html\`).
+- \`drivethrough data types <site>\` / \`data list <site> <type>\` /
+  \`data get <site> <id>\` \u2014 inspect the site's database rows.
+- MCP: \`get_site\` and \`query_db\` do the same. Reads and writes are separate
+  tools: \`query_db\` lists types, lists rows, and fetches one row; \`write_db\`
+  inserts, updates, and deletes. Writes are validated against the site's
+  declared types \u2014 pass \`validate: false\` only for deliberate migrations \u2014
+  and update with \`merge\` to change a few fields without resending the
+  document.
+- Locate before you read: \`get_site\` with \`find\` searches the deployed text
+  files and returns byte-exact matching lines; \`manifest_only\` lists files
+  without contents. Read whole files only when you truly need them.
+- Redeploy only what changed: \`deploy_site\` with \`mode: "patch"\` carries
+  every unchanged file forward from the current version (and \`delete_paths\`
+  removes files). Unchanged images never need re-uploading.
+- Small text changes: the \`edit_site\` MCP tool applies exact find/replace
+  pairs to the deployed files server-side \u2014 never resend a whole file to
+  change a phrase.
+- Images/binary: one decision, three routes \u2014 pick by where the bytes live.
+  Already at a public URL \u2192 deploy_site \`{path, source_url}\` (fetched
+  server-side). Local file and you have the filesystem \u2192 deploy the directory
+  (binaries ride along). Local file but chat-only (remote MCP) \u2192
+  \`create_upload\` mints a signed URL the user uploads the file to, then
+  deploy_site \`{path, upload_id}\`. To rename or duplicate an already-deployed
+  file, deploy_site \`{path, from_path}\` copies it server-side (with
+  \`delete_paths\`, a move). Never hand-generate base64 \u2014 inline base64 is
+  capped at 1 MB, for tiny pasted assets only.
+- Versions are restore points: every deploy is kept. MCP \`get_site\` lists
+  history (\`history: true\`), diffs versions (\`compare\`), and reads old ones
+  (\`version\`); \`revert_site\` returns to any version byte-exactly \u2014 the safe
+  "undo", never hand-inverted edits. \`preview_site\` renders a real browser
+  screenshot of any version \u2014 the way to verify visual work actually shipped.
+
+## Returning to a repo: status \u2192 sync \u2192 deploy
+
+A deployed site may have moved while the repo sat still \u2014 the user edits from
+chat, from other machines, from anywhere. So on returning to a repo-born
+site, ALWAYS sync down before editing:
+
+1. \`drivethrough status <dir> --json\` \u2014 hashes the local tree against the
+   deployed manifests. Reports: \`in_sync\` (just work), \`behind\` (remote
+   versions landed \u2014 listed with what each changed), \`local_changes\`
+   (undeployed local work), or \`fork\` (BOTH moved \u2014 conflicted files listed).
+   No state file needed: a fresh clone is matched to its version by hashing.
+2. \`drivethrough pull <dir> --json\` \u2014 brings the tree to the deployed
+   version byte-exactly, fetching only changed hashes, applying remote
+   deletions, and updating drivethrough.json. It NEVER overwrites a locally
+   modified file: conflicts are listed and nothing is touched \u2014 fold the
+   remote change in yourself, then deploy. For built sites (dist/) it
+   touches nothing and instead emits the remote edits as replayable
+   find/replace scripts + line diffs (port them into src/, rebuild) and
+   stages new binary assets under \`.drivethrough/incoming/\`. Report any
+   edit you cannot locate in src/ \u2014 never guess.
+   Pulling into an EMPTY directory materializes a chat-born site + its
+   config \u2014 how a chat-first site graduates to a repo.
+3. \`drivethrough diff <dir> --json\` \u2014 proves local(\u2261 build) matches the
+   deployed version by hashing alone, zero bytes uploaded. Exit 0 = parity.
+4. Then edit, build, \`drivethrough deploy\`. The CLI records
+   \`.drivethrough/state.json\` (gitignore it) and sends \`base_version\`
+   automatically: a deploy built on a stale version is refused with a 409
+   \`remote_changes\` naming every version since \u2014 sync down (steps 1\u20133) and
+   redeploy. \`--force\` overwrites anyway; every version stays recoverable
+   via revert.
+
+**Ground truth rule:** the repo wins **after sync-down**. Read-back is for
+inspection; do NOT overwrite repo \`src/\` with read-back content \u2014 the
+deployed bundle is built output, and clobbering the repo with it loses
+source. Sync down (status \u2192 pull \u2192 port), then edit the repo, rebuild,
+redeploy. Read-back-then-patch-deploy is the workflow for sites that have
+no repo (built in chat).
+
 ## Sharing (the flagship)
 - \`drivethrough share <site> --json\` \u2192 a share link. Guests open an
   interstitial, then view \u2014 no account. Free links expire in 30 days.
@@ -26364,8 +27819,8 @@ CLI limit errors are machine-readable and include an \`url\` to relay:
   "message": "...", "next": "...", "url": "https://drivethrough.dev/upgrade?reason=public_sites" } }
 \`\`\`
 Relay that upgrade link once, at the moment of intent \u2014 don't nag.
-Custom domain: \`drivethrough domain add <site> example.com\` (bundled into a
-Personal upgrade: \`drivethrough upgrade --plan personal --domain example.com\`).
+Custom domain (one the user already owns): \`drivethrough domain add <site> example.com\`,
+then \`drivethrough domain connect <site>\` for one-click setup where supported.
 
 ## Every command supports --json
 Use \`--json\` for machine-readable output and non-interactive operation.
@@ -26374,9 +27829,22 @@ var AGENTS_MD = `# Drivethrough
 
 This project deploys to Drivethrough. Use the \`drivethrough\` CLI (alias \`dt\`).
 
+- **Returning to this repo? Sync down FIRST**: \`drivethrough status . --json\`
+  (are we behind? forked?), then \`drivethrough pull . --json\` (fast-forwards
+  no-build sites byte-exactly; for built sites emits the remote edits to port
+  into src/), then \`drivethrough diff . --json\` to prove parity. The site may
+  have been edited from chat while the repo sat still.
 - Deploy: \`drivethrough deploy . --json\` (builds from ./dist if present).
+  Sends \`base_version\` from \`.drivethrough/state.json\` (gitignore that dir)
+  so a deploy over unseen remote changes is refused (409 remote_changes) \u2014
+  sync down and redeploy; \`--force\` overwrites (revert can restore).
 - Sites are private by default; share with \`drivethrough share <site>\`.
 - Declare data behavior in \`drivethrough.json\` (types, fields, write policy).
+- Read back what's live: \`drivethrough files <site> --json\` (deployed bundle)
+  and \`drivethrough data types|list|get\` (database rows). Inspection only \u2014
+  this repo wins AFTER sync-down; never overwrite repo \`src/\` with read-back
+  content (the deployed bundle is built output). Sync, edit here, rebuild,
+  redeploy.
 - Every command supports \`--json\` and non-interactive mode.
 - Full guide: run \`drivethrough agent-setup --skill\` for SKILL.md.
 `;
@@ -26419,12 +27887,12 @@ var agentSetupCommand = defineCommand({
       if (args.skill) return void process.stdout.write(SKILL_MD);
       if (args.agents) return void process.stdout.write(AGENTS_MD);
       if (args.mcp) return void process.stdout.write(mcpConfigSnippet() + "\n");
-      const dir = path4.resolve(args.dir ?? ".");
-      const skillPath = path4.join(dir, "SKILL.md");
-      const agentsPath = path4.join(dir, "AGENTS.md");
+      const dir = path5.resolve(args.dir ?? ".");
+      const skillPath = path5.join(dir, "SKILL.md");
+      const agentsPath = path5.join(dir, "AGENTS.md");
       if (!isJsonMode(jsonArgs)) Ie("drivethrough agent-setup");
-      writeFileSync2(skillPath, SKILL_MD);
-      writeFileSync2(agentsPath, AGENTS_MD);
+      writeFileSync3(skillPath, SKILL_MD);
+      writeFileSync3(agentsPath, AGENTS_MD);
       emit(
         jsonArgs,
         {
@@ -26445,6 +27913,448 @@ var agentSetupCommand = defineCommand({
   }
 });
 
+// src/commands/status.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import path6 from "node:path";
+init_api();
+init_state();
+
+// src/sync.ts
+init_src();
+init_api();
+init_state();
+function fetchManifest(siteRef, version2) {
+  const pin = version2 !== void 0 ? `&version=${version2}` : "";
+  return api("GET", `/v1/sites/${encodeURIComponent(siteRef)}/files?manifest_only=1${pin}`);
+}
+function treesEqual(local, manifest) {
+  if (local.size !== manifest.files.length) return false;
+  for (const entry of manifest.files) {
+    if (local.get(entry.path)?.sha256 !== entry.sha256) return false;
+  }
+  return true;
+}
+var BASE_MATCH_DEPTH = 20;
+async function resolveBase(dir, siteRef, local, current) {
+  const state = readState(dir);
+  if (state && state.site_id === current.site_id) {
+    if (state.version === current.version) return { version: current.version, manifest: current, source: "state" };
+    try {
+      const manifest = await fetchManifest(siteRef, state.version);
+      return { version: state.version, manifest, source: "state" };
+    } catch {
+      return null;
+    }
+  }
+  if (local.size === 0) return null;
+  if (treesEqual(local, current)) return { version: current.version, manifest: current, source: "hash_match" };
+  for (let v3 = current.version - 1; v3 >= Math.max(1, current.version - BASE_MATCH_DEPTH + 1); v3--) {
+    try {
+      const manifest = await fetchManifest(siteRef, v3);
+      if (treesEqual(local, manifest)) return { version: v3, manifest, source: "hash_match" };
+    } catch {
+      break;
+    }
+  }
+  return null;
+}
+function planPull(local, base, current) {
+  const baseByPath = new Map((base?.files ?? []).map((f3) => [f3.path, f3]));
+  const plan = { writes: [], deletes: [], conflicts: [], local_only: [], in_sync: [] };
+  for (const remote of current.files) {
+    const localFile = local.get(remote.path);
+    const baseFile = baseByPath.get(remote.path);
+    if (localFile?.sha256 === remote.sha256) {
+      plan.in_sync.push(remote.path);
+    } else if (!localFile) {
+      if (baseFile && baseFile.sha256 === remote.sha256) plan.local_only.push(remote.path);
+      else plan.writes.push(remote);
+    } else if (baseFile && baseFile.sha256 === remote.sha256) {
+      plan.local_only.push(remote.path);
+    } else if (baseFile && localFile.sha256 === baseFile.sha256) {
+      plan.writes.push(remote);
+    } else {
+      plan.conflicts.push(remote.path);
+    }
+  }
+  for (const [path8, baseFile] of baseByPath) {
+    if (current.files.some((f3) => f3.path === path8)) continue;
+    const localFile = local.get(path8);
+    if (!localFile) continue;
+    if (localFile.sha256 === baseFile.sha256) plan.deletes.push(path8);
+    else plan.conflicts.push(path8);
+  }
+  for (const path8 of local.keys()) {
+    if (!current.files.some((f3) => f3.path === path8) && !baseByPath.has(path8)) {
+      plan.local_only.push(path8);
+    }
+  }
+  return plan;
+}
+function canonicalConfig(value) {
+  const result = parseSiteConfig(value);
+  return result.ok ? JSON.stringify(result.config) : null;
+}
+function planConfig(localRaw, baseConfig, remoteConfig) {
+  const remote = remoteConfig == null ? null : canonicalConfig(remoteConfig);
+  if (remote === null) return { action: "none" };
+  const local = localRaw === null ? null : (() => {
+    try {
+      return canonicalConfig(JSON.parse(localRaw));
+    } catch {
+      return null;
+    }
+  })();
+  if (local === remote) return { action: "none" };
+  const base = baseConfig == null ? null : canonicalConfig(baseConfig);
+  if (local === null || local === base) {
+    return { action: "write", json: JSON.stringify(remoteConfig, null, 2) + "\n" };
+  }
+  return { action: "conflict" };
+}
+function stateFor(manifest, sitename) {
+  return {
+    site_id: manifest.site_id,
+    sitename,
+    version: manifest.version,
+    bundle_hash: manifest.bundle_hash ?? "",
+    synced_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/commands/status.ts
+function projectDirs(dir) {
+  const root = path6.resolve(dir);
+  const dist = path6.join(root, "dist");
+  const built = existsSync3(dist) && statSync2(dist).isDirectory();
+  return { root, assetDir: built ? dist : root, built };
+}
+function localConfigRaw(root) {
+  const configPath2 = path6.join(root, "drivethrough.json");
+  return existsSync3(configPath2) ? readFileSync4(configPath2, "utf8") : null;
+}
+function resolveSitename(root, explicit) {
+  if (explicit) return explicit;
+  const raw = localConfigRaw(root);
+  if (raw) {
+    try {
+      const site = JSON.parse(raw).site;
+      if (site) return site;
+    } catch {
+    }
+  }
+  return path6.basename(root).toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+}
+var statusCommand2 = defineCommand({
+  meta: { name: "status", description: "Compare the local tree with what's deployed" },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    site: { type: "string", description: 'Site name (defaults to drivethrough.json "site", then the folder name)' },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const { root, assetDir, built } = projectDirs(args.dir ?? ".");
+      const sitename = resolveSitename(root, args.site);
+      const current = await fetchManifest(sitename);
+      const local = hashLocalFiles(assetDir);
+      const base = await resolveBase(root, sitename, local, current);
+      const inSync = treesEqual(local, current);
+      const localClean = base !== null && treesEqual(local, base.manifest);
+      const behind = base !== null && base.version < current.version;
+      const configDiffers = canonicalConfig(current.config ?? {}) !== (localConfigRaw(root) !== null ? (() => {
+        try {
+          return canonicalConfig(JSON.parse(localConfigRaw(root)));
+        } catch {
+          return null;
+        }
+      })() : canonicalConfig({}));
+      const relation = inSync ? "in_sync" : behind ? localClean ? "behind" : "fork" : base ? "local_changes" : "unknown";
+      let versionsSince = [];
+      if (behind) {
+        const history = await api(
+          "GET",
+          `/v1/sites/${encodeURIComponent(sitename)}/versions?limit=${Math.min(current.version - base.version, 100)}`
+        );
+        versionsSince = history.versions.filter((v3) => v3.version > base.version);
+      }
+      const plan = planPull(local, base?.manifest ?? null, current);
+      emit(
+        jsonArgs,
+        {
+          sitename,
+          site_id: current.site_id,
+          current_version: current.version,
+          base_version: base?.version ?? null,
+          base_source: base?.source ?? null,
+          built_site: built,
+          relation,
+          config_differs: configDiffers,
+          conflicts: plan.conflicts,
+          local_only: plan.local_only,
+          versions_since: versionsSince,
+          next: relation === "in_sync" ? "Nothing to do \u2014 edit, build, deploy." : relation === "behind" ? "Run `dt pull` to bring the remote changes down, then continue working." : relation === "fork" ? "Both sides changed. Run `dt pull` \u2014 clean files fast-forward; conflicted files are listed for you to merge." : relation === "local_changes" ? "Local edits not yet deployed. Deploy when ready \u2014 the current base_version will be sent automatically." : "No provable relation to the deployed site (no state, no hash match). `dt diff` shows per-file differences."
+        },
+        () => {
+          M2.message(`${sitename} \u2014 deployed v${current.version}${base ? `, local base v${base.version} (${base.source === "state" ? "state file" : "matched by hashing"})` : ", local base unknown"}`);
+          if (relation === "in_sync") M2.success(`In sync with v${current.version}.`);
+          if (relation === "behind") {
+            M2.warn(`Behind by ${current.version - (base?.version ?? 0)} version(s) \u2014 remote sessions deployed while you were away:`);
+            for (const v3 of versionsSince) M2.message(`  v${v3.version} (${v3.created_at}): ${JSON.stringify(v3.changes)}`);
+            M2.info("Run `dt pull` to sync down.");
+          }
+          if (relation === "local_changes") M2.info("Local edits not yet deployed.");
+          if (relation === "fork") {
+            M2.warn("TRUE FORK: the site moved remotely AND the local tree has its own changes.");
+            if (plan.conflicts.length) M2.message(`  conflicted: ${plan.conflicts.join(", ")}`);
+            M2.info("Run `dt pull` \u2014 clean files fast-forward, conflicts are listed, nothing is overwritten.");
+          }
+          if (relation === "unknown") M2.warn("No provable relation to the deployed site \u2014 `dt diff` shows per-file differences.");
+          if (configDiffers) M2.warn("drivethrough.json differs from the deployed config.");
+        }
+      );
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+
+// src/commands/pull.ts
+import { mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import path7 from "node:path";
+init_api();
+init_state();
+init_bundle2();
+init_state();
+var pullCommand = defineCommand({
+  meta: { name: "pull", description: "Sync remote changes into the local project (never overwrites local edits)" },
+  args: {
+    dir: { type: "positional", description: "Project directory (empty dir adopts the whole site)", required: false },
+    site: { type: "string", description: 'Site name (defaults to drivethrough.json "site", then the folder name)' },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const { root, assetDir, built } = projectDirs(args.dir ?? ".");
+      const sitename = resolveSitename(root, args.site);
+      const current = await fetchManifest(sitename);
+      const local = hashLocalFiles(assetDir);
+      const base = await resolveBase(root, sitename, local, current);
+      if (built) {
+        return await builtSitePull(jsonArgs, { root, sitename, current, base });
+      }
+      const plan = planPull(local, base?.manifest ?? null, current);
+      const configAction = planConfig(localConfigRaw(root), base?.manifest.config ?? null, current.config);
+      const conflicts = [...plan.conflicts, ...configAction.action === "conflict" ? ["/drivethrough.json"] : []];
+      if (conflicts.length > 0) {
+        throw new ApiError(409, {
+          error: {
+            code: "sync_conflict",
+            message: `These local files changed since the last sync AND changed remotely \u2014 pull will not overwrite local work: ${conflicts.join(", ")}.`,
+            next: "Merge by hand (or with your agent): compare each conflicted file against the deployed one (dt files / get_site), fold the remote change in, then deploy. Nothing was modified."
+          }
+        });
+      }
+      for (const file of plan.writes) {
+        const bytes = await apiBytes(`/v1/sites/${encodeURIComponent(current.site_id)}/blobs/${file.sha256}`);
+        if (sha256(bytes) !== file.sha256) {
+          throw new ApiError(500, {
+            error: {
+              code: "blob_hash_mismatch",
+              message: `Downloaded content for ${file.path} does not hash to ${file.sha256} \u2014 refusing to write it.`,
+              next: "Retry the pull; if it persists, report it \u2014 the stored blob may be corrupt."
+            }
+          });
+        }
+        const target = path7.join(assetDir, file.path);
+        mkdirSync3(path7.dirname(target), { recursive: true });
+        writeFileSync4(target, bytes);
+      }
+      for (const p2 of plan.deletes) {
+        rmSync(path7.join(assetDir, p2), { force: true });
+      }
+      if (configAction.action === "write") {
+        writeFileSync4(path7.join(root, "drivethrough.json"), configAction.json);
+      }
+      const after = hashLocalFiles(assetDir);
+      const parity = plan.writes.every((f3) => after.get(f3.path)?.sha256 === f3.sha256) && plan.deletes.every((p2) => !after.has(p2));
+      if (!parity) {
+        throw new ApiError(500, {
+          error: {
+            code: "sync_incomplete",
+            message: "After applying remote changes the local tree still differs from the deployed manifest.",
+            next: "Run `dt diff` to see the per-file differences."
+          }
+        });
+      }
+      writeState(root, stateFor(current, sitename));
+      const exact = treesEqual(after, current);
+      emit(
+        jsonArgs,
+        {
+          sitename,
+          version: current.version,
+          pulled: plan.writes.map((f3) => f3.path),
+          deleted: plan.deletes,
+          config_updated: configAction.action === "write",
+          unchanged: plan.in_sync.length,
+          local_only: plan.local_only,
+          parity: true,
+          byte_exact: exact
+        },
+        () => {
+          M2.success(`Local tree now matches deployed v${current.version}.`);
+          for (const f3 of plan.writes) M2.message(`  pulled  ${f3.path}`);
+          for (const p2 of plan.deletes) M2.message(`  deleted ${p2}`);
+          if (configAction.action === "write") M2.message("  updated drivethrough.json");
+          if (plan.local_only.length) M2.info(`Untouched local-only files: ${plan.local_only.join(", ")}`);
+        }
+      );
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+async function builtSitePull(jsonArgs, ctx) {
+  const { root, sitename, current, base } = ctx;
+  if (!base) {
+    throw new ApiError(409, {
+      error: {
+        code: "no_sync_base",
+        message: "This is a built site (dist/) with no provable relation to a deployed version \u2014 there is no way to know which remote changes are new.",
+        next: "Rebuild so dist/ matches what you last deployed and run `dt pull` again (the version is matched by hashing), or run `dt diff` to compare the current build against the deployed site."
+      }
+    });
+  }
+  if (base.version === current.version) {
+    emit(jsonArgs, { sitename, version: current.version, in_sync: true, ported: false }, () => {
+      M2.success(`Deployed v${current.version} is what you left \u2014 nothing to port.`);
+    });
+    return;
+  }
+  const history = await api(
+    "GET",
+    `/v1/sites/${encodeURIComponent(sitename)}/versions?limit=${Math.min(current.version - base.version, 100)}&edit_scripts=1`
+  );
+  const since = history.versions.filter((v3) => v3.version > base.version).sort((a2, b4) => a2.version - b4.version);
+  const scripts = since.filter((v3) => v3.edit_script?.length).map((v3) => ({ version: v3.version, edits: v3.edit_script }));
+  const scriptedPaths = new Set(scripts.flatMap((s2) => s2.edits.map((e3) => e3.path)));
+  const diff = await api(
+    "GET",
+    `/v1/sites/${encodeURIComponent(sitename)}/diff?from=${base.version}&to=${current.version}`
+  );
+  const textish = (ct) => ct.startsWith("text/") || ct.includes("json") || ct.includes("javascript") || ct.includes("xml") || ct.includes("svg");
+  const diffs = diff.files.filter(
+    (f3) => f3.status === "changed" && textish(f3.content_type) && !scriptedPaths.has(f3.path) && f3.diff
+  );
+  const toStage = diff.files.filter(
+    (f3) => f3.status === "added" || f3.status === "changed" && (!textish(f3.content_type) || !f3.diff && !scriptedPaths.has(f3.path))
+  );
+  const stagingDir = path7.join(root, ".drivethrough", "incoming");
+  rmSync(stagingDir, { recursive: true, force: true });
+  const staged = [];
+  for (const f3 of toStage) {
+    const entry = current.files.find((m3) => m3.path === f3.path);
+    if (!entry) continue;
+    const bytes = await apiBytes(`/v1/sites/${encodeURIComponent(current.site_id)}/blobs/${entry.sha256}`);
+    const target = path7.join(stagingDir, f3.path);
+    mkdirSync3(path7.dirname(target), { recursive: true });
+    writeFileSync4(target, bytes);
+    staged.push(f3.path);
+  }
+  const removed = diff.files.filter((f3) => f3.status === "removed").map((f3) => f3.path);
+  emit(
+    jsonArgs,
+    {
+      sitename,
+      built_site: true,
+      base_version: base.version,
+      current_version: current.version,
+      edit_scripts: scripts,
+      diffs: diffs.map((f3) => ({ path: f3.path, diff: f3.diff })),
+      staged_files: staged,
+      staging_dir: staged.length ? path7.join(".drivethrough", "incoming") : null,
+      removed_paths: removed,
+      next: "These remote changes landed on BUILT OUTPUT. Port them into src/ (apply the edit scripts' find/replace to the matching source text; fold in the diffs; place staged files), rebuild, then prove parity with `dt diff` before deploying. Report any edit you cannot locate in src/ \u2014 never guess."
+    },
+    () => {
+      M2.warn(
+        `Deployed moved v${base.version} \u2192 v${current.version} while this built site was away. Nothing was modified locally.`
+      );
+      for (const s2 of scripts) {
+        M2.message(`  v${s2.version} edit script:`);
+        for (const e3 of s2.edits) M2.message(`    ${e3.path}: "${e3.find}" \u2192 "${e3.replace}"${e3.replace_all ? " (all)" : ""}`);
+      }
+      for (const d4 of diffs) M2.message(`  changed (diff available): ${d4.path}`);
+      for (const s2 of staged) M2.message(`  staged: .drivethrough/incoming${s2}`);
+      if (removed.length) M2.message(`  removed remotely: ${removed.join(", ")}`);
+      M2.info("Port into src/, rebuild, then `dt diff` to prove parity before deploying.");
+    }
+  );
+}
+
+// src/commands/diff.ts
+init_state();
+var diffCommand = defineCommand({
+  meta: { name: "diff", description: "Prove (or disprove) that the local build matches the deployed site \u2014 no upload" },
+  args: {
+    dir: { type: "positional", description: "Project directory (compares ./dist when present)", required: false },
+    site: { type: "string", description: 'Site name (defaults to drivethrough.json "site", then the folder name)' },
+    json: { type: "boolean", description: "Machine-readable output" }
+  },
+  async run({ args }) {
+    const jsonArgs = { json: args.json };
+    try {
+      const { root, assetDir } = projectDirs(args.dir ?? ".");
+      const sitename = resolveSitename(root, args.site);
+      const current = await fetchManifest(sitename);
+      const local = hashLocalFiles(assetDir);
+      const same = [];
+      const changed = [];
+      const missing_locally = [];
+      for (const entry of current.files) {
+        const localFile = local.get(entry.path);
+        if (!localFile) missing_locally.push(entry.path);
+        else if (localFile.sha256 === entry.sha256) same.push(entry.path);
+        else changed.push(entry.path);
+      }
+      const extra_locally = [...local.keys()].filter((p2) => !current.files.some((f3) => f3.path === p2));
+      const parity = treesEqual(local, current);
+      if (parity) {
+        writeState(root, stateFor(current, sitename));
+      }
+      emit(
+        jsonArgs,
+        {
+          sitename,
+          version: current.version,
+          parity,
+          same: same.length,
+          changed,
+          missing_locally,
+          extra_locally,
+          bytes_uploaded: 0
+        },
+        () => {
+          if (parity) {
+            M2.success(`Local \u2261 deployed v${current.version} \u2014 ${same.length} files, byte-identical.`);
+          } else {
+            M2.warn(`Local differs from deployed v${current.version}:`);
+            for (const p2 of changed) M2.message(`  changed:        ${p2}`);
+            for (const p2 of missing_locally) M2.message(`  missing local:  ${p2}`);
+            for (const p2 of extra_locally) M2.message(`  extra local:    ${p2}`);
+          }
+        }
+      );
+      if (!parity) process.exitCode = 1;
+    } catch (error2) {
+      fail(jsonArgs, error2);
+    }
+  }
+});
+
 // src/main.ts
 var main = defineCommand({
   meta: {
@@ -26457,12 +28367,17 @@ var main = defineCommand({
     logout: logoutCommand,
     whoami: whoamiCommand,
     deploy: deployCommand,
+    status: statusCommand2,
+    pull: pullCommand,
+    diff: diffCommand,
     sites: sitesCommand,
     delete: deleteCommand,
     restore: restoreCommand,
     share: shareCommand,
     privacy: privacyCommand,
     db: dbCommand,
+    data: dataCommand,
+    files: filesCommand,
     upgrade: upgradeCommand,
     domain: domainCommand,
     collaborators: collaboratorsCommand,