drops-mcp 0.1.4 → 0.2.0

package/drop.mjs

@@ -111,6 +111,27 @@ function genPassword() {
   return `${ADJ[buf[0] % ADJ.length]}-${NOUN[buf[1] % NOUN.length]}-${10 + (buf[2] % 90)}`;
 }
 
+function luhn(s) {
+  let sum = 0, alt = false;
+  for (let i = s.length - 1; i >= 0; i--) { let n = +s[i]; if (alt) { n *= 2; if (n > 9) n -= 9; } sum += n; alt = !alt; }
+  return s.length >= 13 && sum % 10 === 0;
+}
+// Client-side secret/PII scan run BEFORE encryption+upload. High-signal patterns only
+// (the real risk for AI artifacts is an embedded credential); emails warn only in bulk.
+function scanPII(text) {
+  const hits = [];
+  const add = (label, re) => { if (re.test(text)) hits.push(label); };
+  add("AWS access key", /\bAKIA[0-9A-Z]{16}\b/);
+  add("private key block", /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/);
+  add("API token/secret", /\b(?:sk-[A-Za-z0-9]{20,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AIza[0-9A-Za-z_-]{30,}|vercel_blob_rw_[A-Za-z0-9_]{20,})\b/);
+  add("JWT", /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/);
+  const cc = (text.match(/\b(?:\d[ -]?){13,16}\b/g) || []).map((c) => c.replace(/[ -]/g, ""));
+  if (cc.some(luhn)) hits.push("possible card number");
+  const emails = [...new Set(text.match(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g) || [])];
+  if (emails.length >= 5) hits.push(`${emails.length} email addresses`);
+  return [...new Set(hits)];
+}
+
 async function dataUri(path) {
   const ext = extname(path).toLowerCase();
   const mime = ext === ".svg" ? "image/svg+xml" : ext === ".png" ? "image/png"
@@ -299,16 +320,33 @@ async function upload(key, body, contentType, token) {
 
 // Managed (zero-setup) publish: POST the already-branded/encrypted bytes to the host's
 // managed endpoint. No token, no Vercel setup — the server assigns a `u/` slug.
-async function managedPublish(body, contentType) {
+async function managedPublish(body, contentType, { burn } = {}) {
   const endpoint = `${ORIGIN}/api/publish`;
+  const headers = { "content-type": "application/octet-stream", "x-drop-content-type": contentType };
+  if (burn) headers["x-drop-burn"] = "1";
   let r;
   try {
-    r = await fetch(endpoint, { method: "POST", headers: { "content-type": "application/octet-stream", "x-drop-content-type": contentType }, body });
+    r = await fetch(endpoint, { method: "POST", headers, body });
   } catch (e) { die(`managed publish failed: ${e.message}`); }
   if (!r.ok) { let m; try { m = (await r.json()).error; } catch {} die(`managed publish failed: ${m || r.status}`); }
   return r.json();
 }
 
+// Hosted (logged-in free tier) publish: same client-side branded/encrypted bytes, but
+// authenticated with the API key so the drop lands persistently at <handle>/<slug>.
+async function hostedPublish(body, contentType, slug, locked, emailGate) {
+  const key = getApiKey();
+  const headers = { "content-type": "application/octet-stream", "x-drop-content-type": contentType, authorization: `Bearer ${key}` };
+  if (slug) headers["x-drop-slug"] = slug;
+  if (locked) headers["x-drop-locked"] = "1";
+  if (emailGate) headers["x-drop-email-gate"] = String(emailGate).replace(/^@/, "").toLowerCase();
+  let r;
+  try { r = await fetch(`${ORIGIN}/api/publish`, { method: "POST", headers, body }); }
+  catch (e) { die(`hosted publish failed: ${e.message}`); }
+  if (!r.ok) { let m; try { m = (await r.json()).error; } catch {} die(`hosted publish failed: ${m || r.status}`); }
+  return r.json();
+}
+
 // Import an npm dep, auto-installing into the skill dir on first use (gitignored).
 async function ensureDep(name) {
   try { return await import(name); }
@@ -324,8 +362,13 @@ async function ensureDep(name) {
 async function cmdDrop(file, opts) {
   if (!file) die("usage: drop <file> [-p password] [-s slug] [--page] [--no-lock]");
   if (!existsSync(file)) die(`no such file: ${file}`);
+
+  // Tier selection: explicit --managed wins; then self-host if a Blob token is set
+  // (you brought your own infra); then hosted if you're logged in; else nudge.
   const token = opts.managed ? null : getToken();
-  if (!opts.managed && !token) die("BLOB_READ_WRITE_TOKEN not set (env or ~/.drop/.env). Run 'drop setup' first — or use --managed for the zero-setup tier.");
+  const apiKey = getApiKey();
+  const mode = opts.managed ? "managed" : token ? "selfhost" : apiKey ? "hosted" : null;
+  if (!mode) die("not set up yet.\n  Free hosted:  drop login\n  Self-host:    drop setup   (needs a Vercel Blob token)\n  One-off 24h:  drop <file> --managed");
 
   const ext = extname(file).toLowerCase();
   const isMd = ext === ".md" || ext === ".markdown";
@@ -337,7 +380,7 @@ async function cmdDrop(file, opts) {
   const expiresAt = parseExpiry(opts.expire);
   if (opts.expire && !expiresAt) die(`bad --expire value: ${opts.expire} (use 7d, 24h, 30m, 2w, or a date)`);
 
-  if (opts.managed && (opts.page || !isHtml)) die("--managed supports HTML/markdown only. Self-host ('drop deploy') for files, --page, and zip sites.");
+  if ((mode === "managed" || mode === "hosted") && (opts.page || !isHtml)) die(`the ${mode} tier supports HTML/markdown only. Self-host ('drop deploy') for files, --page, and zip sites.`);
 
   const manifest = await loadManifest();
   const now = new Date().toISOString();
@@ -383,6 +426,18 @@ async function cmdDrop(file, opts) {
     const title = opts.title || basename(file, ext).replace(/[-_]+/g, " ");
     let html = await readFile(file, "utf8");
     if (isMd) html = await mdToHtml(html, title);
+
+    // PII / secret scan on the RAW content (before brand + encrypt). Warn by default
+    // (agent-friendly); --block-pii refuses; --no-pii-check silences. Skipped for
+    // password-locked drops only when explicitly told to (locking already protects them).
+    if (!opts.noPiiCheck) {
+      const pii = scanPII(html);
+      if (pii.length) {
+        const msg = `possible sensitive data in ${basename(file)}: ${pii.join(", ")}`;
+        if (opts.blockPii) die(`⚠ ${msg}\n  refusing to publish (--block-pii). Remove it, or drop --no-pii-check to publish anyway.`);
+        if (!JSON_OUT) console.error(`\x1b[33m⚠ ${msg}\x1b[0m\n  \x1b[2mpublishing anyway — use --block-pii to refuse, --no-pii-check to silence${opts.noLock ? ", and note this drop is PUBLIC (unlocked)" : ""}\x1b[0m`);
+      }
+    }
     html = await brandHtml(html, { title, url, logoUri, ogImage, expiresAt });
 
     let password = null, body = html;
@@ -394,11 +449,18 @@ async function cmdDrop(file, opts) {
       body = await encrypt(inPath, { password, title, logoUri, faviconUri, ogImage, url });
       await rm(tmp, { recursive: true, force: true });
     }
-    if (opts.managed) {
-      const m = await managedPublish(body, "text/html; charset=utf-8");
-      manifest.unshift({ slug: m.slug, url: m.url, type: "html", locked: !opts.noLock, password, file: basename(file), size: stat, managed: true, createdAt: now });
+    if (mode === "managed") {
+      const m = await managedPublish(body, "text/html; charset=utf-8", { burn: opts.burn });
+      manifest.unshift({ slug: m.slug, url: m.url, type: "html", locked: !opts.noLock, password, file: basename(file), size: stat, managed: true, burn: !!opts.burn, createdAt: now });
+      await saveManifest(manifest);
+      report({ url: m.url, password, locked: !opts.noLock, extra: opts.burn ? "managed · burns on first view" : "managed · auto-expires in 24h" });
+      return;
+    }
+    if (mode === "hosted") {
+      const m = await hostedPublish(body, "text/html; charset=utf-8", slug, !opts.noLock, opts.emailGate);
+      manifest.unshift({ slug: m.slug, url: m.url, type: "html", locked: !opts.noLock, password, file: basename(file), size: stat, hosted: true, handle: m.handle, createdAt: now });
       await saveManifest(manifest);
-      report({ url: m.url, password, locked: !opts.noLock, extra: "managed · auto-expires in 24h" });
+      report({ url: m.url, password, locked: !opts.noLock, extra: `hosted · ${m.handle}/${m.slug}${opts.emailGate ? ` · @${String(opts.emailGate).replace(/^@/, "")} only` : ""}` });
       return;
     }
     const res = await upload(slug, body, "text/html; charset=utf-8", token);
@@ -469,9 +531,38 @@ function report({ url, password, locked, extra }) {
   console.log("");
 }
 
+// Logged-in hosted account → list/remove via the API (not the BYO Blob store).
+const useHosted = () => getApiKey() && !getToken();
+
+async function hostedList() {
+  const key = getApiKey();
+  let r; try { r = await fetch(`${ORIGIN}/api/sites`, { headers: { authorization: `Bearer ${key}` } }); } catch (e) { die(e.message); }
+  if (!r.ok) die("could not list drops (key invalid? run `drop login`)");
+  const { sites } = await r.json();
+  const local = await loadManifest();
+  const pw = new Map(); for (const d of local) if (d.password) pw.set(d.slug, d.password);
+  if (JSON_OUT) { console.log(JSON.stringify(sites.map((s) => ({ ...s, password: pw.get(s.slug) || null })))); return; }
+  if (!sites.length) return console.log("no drops yet.");
+  for (const s of sites) {
+    const known = pw.get(s.slug);
+    const lock = known ? `🔒 ${known}` : (s.locked ? "🔒 locked" : "public");
+    console.log(`${s.url}\n  ${humanSize(s.size)} · ${lock} · ${String(s.created_at).slice(0, 10)}`);
+  }
+}
+
+async function hostedRm(slug) {
+  const key = getApiKey();
+  let r; try { r = await fetch(`${ORIGIN}/api/sites?slug=${encodeURIComponent(slug)}`, { method: "DELETE", headers: { authorization: `Bearer ${key}` } }); } catch (e) { die(e.message); }
+  if (!r.ok) { let m; try { m = (await r.json()).error; } catch {} die(m || "remove failed"); }
+  const m = await loadManifest(); const kept = m.filter((d) => d.slug !== slug); if (kept.length !== m.length) await saveManifest(kept);
+  if (JSON_OUT) { console.log(JSON.stringify({ removed: slug })); return; }
+  ok(`removed ${slug}`);
+}
+
 async function cmdList() {
+  if (useHosted()) return hostedList();
   const token = getToken();
-  if (!token) die("BLOB_READ_WRITE_TOKEN not set. Run: drop setup");
+  if (!token) die("BLOB_READ_WRITE_TOKEN not set. Run: drop setup (self-host) or drop login (hosted)");
   const { list } = await loadBlob();
   const { blobs } = await list({ token });
   // overlay local passwords (kept on this machine only) keyed by pathname/slug
@@ -498,8 +589,9 @@ async function cmdList() {
 
 async function cmdRm(slug) {
   if (!slug) die("usage: drop rm <slug>");
+  if (useHosted()) return hostedRm(slug);
   const token = getToken();
-  if (!token) die("BLOB_READ_WRITE_TOKEN not set. Run: drop setup");
+  if (!token) die("BLOB_READ_WRITE_TOKEN not set. Run: drop setup (self-host) or drop login (hosted)");
   const { list, del } = await loadBlob();
   const { blobs } = await list({ token });
   // match the page/file key (slug), a sibling like <slug>.<ext>, or a whole site under <slug>/
@@ -572,9 +664,13 @@ async function cmdDeploy(opts) {
   await del(probe.url, { token }).catch(() => {});
   ok(`blob host: ${blobHost}`);
 
-  // 3. patch middleware.js (BLOB const) + vercel.json (fallback rewrite) idempotently
+  // 3. patch middleware.js fallback host + vercel.json (fallback rewrite) idempotently.
+  // (Middleware derives the host from BLOB_READ_WRITE_TOKEN at runtime, so this only
+  // pins the fallback for explicit BYO-host setups.)
   let mw = await readFile(mwPath, "utf8");
-  const newMw = mw.replace(/const BLOB = "https:\/\/[^"]+";/, `const BLOB = "https://${blobHost}";`);
+  const newMw = mw
+    .replace(/const DEFAULT_BLOB_HOST = "[^"]+";/, `const DEFAULT_BLOB_HOST = "${blobHost}";`)
+    .replace(/const BLOB = "https:\/\/[^"]+";/, `const BLOB = "https://${blobHost}";`);
   let vj = await readFile(vjPath, "utf8");
   const newVj = vj.replace(/https:\/\/[a-z0-9]+\.public\.blob\.vercel-storage\.com/g, `https://${blobHost}`);
   const mwChanged = newMw !== mw, vjChanged = newVj !== vj;
@@ -698,6 +794,134 @@ async function pullTokenFromVercel() {
   finally { await rm(tmp, { recursive: true, force: true }); }
 }
 
+// ---------- hosted accounts (drop login / whoami / logout) ----------
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function getApiKey() {
+  if (process.env.DROP_API_KEY) return process.env.DROP_API_KEY;
+  try { return JSON.parse(readFileSync(CONFIG_FILE, "utf8")).apiKey || null; } catch { return null; }
+}
+async function saveApiKey(key) {
+  let cfg = {}; try { cfg = JSON.parse(readFileSync(CONFIG_FILE, "utf8")); } catch {}
+  cfg.apiKey = key;
+  await mkdir(DROP_HOME, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n");
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try { spawnSync(cmd, [url], { stdio: "ignore", shell: process.platform === "win32" }); } catch {}
+}
+async function cmdLogin(opts) {
+  if (opts.token && opts.token.startsWith("drop_")) { await saveApiKey(opts.token); ok("API key saved"); return cmdWhoami(); }
+  let start;
+  try { start = await (await fetch(`${ORIGIN}/api/auth/device/start`, { method: "POST" })).json(); }
+  catch (e) { die(`could not reach ${ORIGIN}: ${e.message}`); }
+  if (!start?.code) die("login unavailable (hosted tier not configured yet)");
+  console.log(`\n  opening ${start.verify_url}`);
+  console.log(`  \x1b[2mif it doesn't open, paste that URL into your browser\x1b[0m\n`);
+  openBrowser(start.verify_url);
+  const deadline = Date.now() + 5 * 60 * 1000;
+  process.stdout.write("  waiting for you to approve");
+  while (Date.now() < deadline) {
+    await sleep((start.poll_interval || 2) * 1000);
+    process.stdout.write(".");
+    let p; try { p = await (await fetch(`${ORIGIN}/api/auth/device/poll?code=${start.code}`)).json(); } catch { continue; }
+    if (p.status === "approved" && p.api_key) { console.log(""); await saveApiKey(p.api_key); ok(`logged in — key saved to ${CONFIG_FILE}`); return cmdWhoami(); }
+    if (p.status === "denied") { console.log(""); die("authorization denied"); }
+    if (p.status === "expired") { console.log(""); die("code expired — run `drop login` again"); }
+  }
+  console.log(""); die("login timed out");
+}
+async function cmdWhoami() {
+  const key = getApiKey(); if (!key) die("not logged in. Run: drop login");
+  let r; try { r = await fetch(`${ORIGIN}/api/me`, { headers: { authorization: `Bearer ${key}` } }); } catch (e) { die(e.message); }
+  if (!r.ok) die("not authenticated (key invalid or revoked). Run: drop login");
+  const d = await r.json();
+  if (JSON_OUT) { console.log(JSON.stringify(d)); return; }
+  ok(`${d.email || "logged in"}${d.handle ? `  ·  handle: ${d.handle}` : ""}`);
+}
+async function cmdLogout() {
+  let cfg = {}; try { cfg = JSON.parse(readFileSync(CONFIG_FILE, "utf8")); } catch {}
+  delete cfg.apiKey;
+  await mkdir(DROP_HOME, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n");
+  ok("logged out");
+}
+
+// ---------- hosted-drop management (Phase 2: set-* / claim / share / migrate) ----------
+// Thin authenticated calls against the hosted API. Each needs `drop login` first.
+async function apiCall(path, init = {}) {
+  const key = getApiKey(); if (!key) die("not logged in — run: drop login");
+  let r; try { r = await fetch(`${ORIGIN}${path}`, { ...init, headers: { authorization: `Bearer ${key}`, ...(init.headers || {}) } }); }
+  catch (e) { die(`request failed: ${e.message}`); }
+  let d = {}; try { d = await r.json(); } catch {}
+  if (!r.ok) die(d.error || `request failed (${r.status})`);
+  return d;
+}
+const patchSite = (slug, patch) => apiCall(`/api/sites?slug=${encodeURIComponent(slug)}`, { method: "PATCH", headers: { "content-type": "application/json" }, body: JSON.stringify(patch) });
+
+async function cmdSetExpiry(slug, when) {
+  if (!slug || !when) die("usage: drop set-expiry <slug> <7d|24h|2w|date|off>");
+  const iso = when === "off" ? null : (() => { const at = parseExpiry(when); if (!at) die(`bad expiry: ${when}`); return new Date(at).toISOString(); })();
+  await patchSite(slug, { expires_at: iso });
+  if (JSON_OUT) return console.log(JSON.stringify({ slug, expires_at: iso }));
+  ok(iso ? `expiry set on ${slug} → ${iso.slice(0, 16).replace("T", " ")}` : `expiry cleared on ${slug}`);
+}
+async function cmdSetEmailGate(slug, domain) {
+  if (!slug) die("usage: drop set-email-gate <slug> <domain|off>   (e.g. acme.com)");
+  const val = !domain || domain === "off" ? null : domain.replace(/^@/, "").toLowerCase();
+  await patchSite(slug, { email_gate: val });
+  if (JSON_OUT) return console.log(JSON.stringify({ slug, email_gate: val }));
+  ok(val ? `email-gate on ${slug} → only @${val} may open it` : `email-gate cleared on ${slug}`);
+}
+async function cmdSetFeedback(slug, state) {
+  if (!slug) die("usage: drop set-feedback <slug> [on|off]");
+  const on = state !== "off";
+  await patchSite(slug, { feedback: on });
+  if (JSON_OUT) return console.log(JSON.stringify({ slug, feedback: on }));
+  ok(`feedback ${on ? "enabled" : "disabled"} on ${slug}`);
+}
+async function cmdSetPassword(slug, file) {
+  // Zero-knowledge: changing the password re-encrypts, which needs the source again.
+  if (!slug || !file) die("usage: drop set-password <slug> <file.html> [-p <password>]\n  (zero-knowledge: a password change re-encrypts, so the source file is required)");
+  if (!existsSync(file)) die(`no such file: ${file}`);
+  return cmdDrop(file, { ...opts, slug, noLock: false, password: opts.password || genPassword() });
+}
+async function cmdClaim(target) {
+  if (!target) die("usage: drop claim <url|slug>   (move an anonymous /u/ drop into your account)");
+  if (!getApiKey()) die("not logged in — run: drop login");
+  const url = /^https?:/.test(target) ? target : `${ORIGIN}/u/${target.replace(/^u\//, "")}`;
+  let body; try { const r = await fetch(url); if (!r.ok) die(`could not fetch ${url} (${r.status})`); body = Buffer.from(await r.arrayBuffer()); }
+  catch (e) { die(`could not fetch ${url}: ${e.message}`); }
+  const slug = opts.slug || ("claimed-" + rand(4));
+  const m = await hostedPublish(body, "text/html; charset=utf-8", slug, false);
+  if (JSON_OUT) return console.log(JSON.stringify(m));
+  report({ url: m.url, password: null, locked: false, extra: `claimed → ${m.handle}/${m.slug}` });
+}
+async function cmdShare(slug) {
+  if (!slug) die("usage: drop share <slug> [--revoke]");
+  const d = await apiCall(`/api/share`, { method: opts.revoke ? "DELETE" : "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ slug }) });
+  if (JSON_OUT) return console.log(JSON.stringify(d));
+  if (opts.revoke) return ok(`share token revoked for ${slug}`);
+  ok(`revocable share link → ${d.url}\n  revoke anytime:  drop share ${slug} --revoke`);
+}
+async function cmdMigrate() {
+  // Re-home your hosted drops onto your own Vercel Blob, then rewrite config to self-host.
+  const sites = (await apiCall("/api/sites")).sites || [];
+  const token = getToken();
+  if (opts.dryRun || !token) {
+    const tgt = token ? "your Vercel Blob" : "(no blob token yet — run `drop setup` first)";
+    if (JSON_OUT) return console.log(JSON.stringify({ dryRun: true, count: sites.length, target: tgt }));
+    return console.log(`drop migrate (dry-run): would re-upload ${sites.length} hosted drop(s) to ${tgt}, then rewrite ~/.drop/config.json to self-host on your own domain.`);
+  }
+  let n = 0;
+  for (const s of sites) {
+    try { const body = Buffer.from(await (await fetch(s.url)).arrayBuffer()); await upload(`${s.slug}`, body, s.content_type || "text/html; charset=utf-8", token); n++; }
+    catch (e) { console.error(`  skip ${s.slug}: ${e.message}`); }
+  }
+  if (JSON_OUT) return console.log(JSON.stringify({ migrated: n, of: sites.length }));
+  ok(`migrated ${n}/${sites.length} drops to your own blob. Run 'drop deploy' to finish self-hosting.`);
+}
+
 // ---------- arg parsing ----------
 const { values, positionals } = parseArgs({
   allowPositionals: true,
@@ -717,12 +941,18 @@ const { values, positionals } = parseArgs({
     "dry-run": { type: "boolean" },
     "no-deploy": { type: "boolean" },
     managed: { type: "boolean" },
+    burn: { type: "boolean" },
+    "email-gate": { type: "string" },
+    revoke: { type: "boolean" },
+    "no-pii-check": { type: "boolean" },
+    "block-pii": { type: "boolean" },
+    help: { type: "boolean", short: "h" },
   },
 });
 const JSON_OUT = !!values.json;
 
 const [cmd, ...rest] = positionals;
-const opts = { password: values.password, slug: values.slug, title: values.title, page: values.page, noLock: values["no-lock"], token: values.token, domain: values.domain, blobHost: values["blob-host"], project: values.project, org: values.org, expire: values.expire, dryRun: values["dry-run"], noDeploy: values["no-deploy"], managed: values.managed };
+const opts = { password: values.password, slug: values.slug, title: values.title, page: values.page, noLock: values["no-lock"], token: values.token, domain: values.domain, blobHost: values["blob-host"], project: values.project, org: values.org, expire: values.expire, dryRun: values["dry-run"], noDeploy: values["no-deploy"], managed: values.managed, burn: values.burn, emailGate: values["email-gate"], revoke: values.revoke, noPiiCheck: values["no-pii-check"], blockPii: values["block-pii"] };
 
 try {
   if (cmd === "init") await cmdInit(opts);
@@ -731,7 +961,17 @@ try {
   else if (cmd === "rm") await cmdRm(rest[0]);
   else if (cmd === "gc") await cmdGc();
   else if (cmd === "deploy") await cmdDeploy(opts);
-  else if (cmd === "help" || cmd === "--help" || !cmd) {
+  else if (cmd === "login") await cmdLogin(opts);
+  else if (cmd === "logout") await cmdLogout();
+  else if (cmd === "whoami") await cmdWhoami();
+  else if (cmd === "claim") await cmdClaim(rest[0]);
+  else if (cmd === "share") await cmdShare(rest[0]);
+  else if (cmd === "migrate") await cmdMigrate();
+  else if (cmd === "set-expiry") await cmdSetExpiry(rest[0], rest[1]);
+  else if (cmd === "set-email-gate") await cmdSetEmailGate(rest[0], rest[1]);
+  else if (cmd === "set-feedback") await cmdSetFeedback(rest[0], rest[1]);
+  else if (cmd === "set-password") await cmdSetPassword(rest[0], rest[1]);
+  else if (values.help || cmd === "help" || cmd === "--help" || !cmd) {
     console.log(`drop — branded password-protected sharing on ${DOMAIN}
 
   drop <file.html|.md>          brand + lock (auto password) + upload → clean URL
@@ -739,6 +979,9 @@ try {
   drop <file> -p secret         use your own password
   drop <file> --no-lock         brand only, no password (renders for anyone)
   drop <file> --expire 7d       auto-expire (7d/24h/30m/2w/date); enforce with 'drop gc'
+  drop <file> --burn            burn-after-read: the drop self-destructs on first view
+  drop <file> --email-gate co.com  only viewers with that email domain may open it
+  drop <file> --block-pii       refuse to publish if a secret/credential is detected
   drop <file> --page            branded download page wrapping the file
   drop <file> --page -p secret  password-protect the download page
   drop site.zip                 multi-file static site → /slug/ (public)
@@ -748,6 +991,16 @@ try {
   drop rm <slug>                delete a drop
   drop gc                       delete drops whose --expire has passed (cron-friendly)
   drop init --domain ...        point drop at your own domain + Vercel Blob (BYO)
+  drop login                    sign in (magic-link) to host on drops + persist your drops
+  drop whoami                   show your hosted account (email + handle)
+  drop logout                   clear your hosted account (forget the API key)
+  drop claim <url|slug>         move an anonymous /u/ drop into your account
+  drop share <slug> [--revoke]  mint (or revoke) a revocable guest share link
+  drop migrate [--dry-run]      re-home your hosted drops to your own blob (self-host)
+  drop set-expiry <slug> <when> change a hosted drop's expiry (7d/24h/date/off)
+  drop set-email-gate <slug> <domain>  restrict a hosted drop to one email domain
+  drop set-password <slug> <file>      re-encrypt a hosted drop with a new password
+  drop set-feedback <slug> [on|off]    toggle the feedback widget on a hosted drop
   drop setup [--token <tok>]    provision a machine (deps + blob token)
   drop deploy [--domain ...]    wire backend (blob host → middleware/vercel.json) + deploy`);
   } else {

package/mcp.mjs

@@ -141,5 +141,52 @@ server.tool(
   }
 );
 
+server.tool(
+  "set_password",
+  "Change the password gate on a hosted drop. Zero-knowledge means re-keying re-encrypts, so re-supply the HTML; returns the new URL + password.",
+  {
+    slug: z.string().describe("The slug to re-key."),
+    html: z.string().describe("The drop's HTML (required — content is re-encrypted under the new password)."),
+    password: z.string().optional().describe("New password (auto-generated if omitted)."),
+  },
+  async ({ slug, html, password }) => {
+    try {
+      const args = ["-s", slug];
+      if (password) args.push("-p", password);
+      return textResult(await withTempFile(slug + ".html", html, (p) => runDrop([p, ...args])));
+    } catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "set_expiry",
+  "Set (or clear) the auto-expiry on a hosted drop. The host's gc cron deletes it after the deadline.",
+  { slug: z.string(), expire: z.string().describe("'7d' | '24h' | '2w' | a date | 'off' to clear.") },
+  async ({ slug, expire }) => {
+    try { return textResult(await runDrop(["set-expiry", slug, expire])); }
+    catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "set_email_gate",
+  "Restrict a hosted drop so only viewers with a given email domain can open it (e.g. 'acme.com'); pass 'off' to remove.",
+  { slug: z.string(), domain: z.string().describe("Allowed email domain, or 'off'.") },
+  async ({ slug, domain }) => {
+    try { return textResult(await runDrop(["set-email-gate", slug, domain])); }
+    catch (e) { return errResult(e); }
+  }
+);
+
+server.tool(
+  "set_feedback",
+  "Toggle the viewer feedback widget on a hosted drop (collect reactions/comments from recipients).",
+  { slug: z.string(), enabled: z.boolean().optional().describe("true to enable (default), false to disable.") },
+  async ({ slug, enabled }) => {
+    try { return textResult(await runDrop(["set-feedback", slug, enabled === false ? "off" : "on"])); }
+    catch (e) { return errResult(e); }
+  }
+);
+
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drops-mcp",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Open-source artifact sharing — publish HTML/Markdown/files as branded, password-protected, zero-knowledge links on your own domain, from any AI agent. CLI + MCP server. The open-source, self-hosted Stacktree alternative.",
   "type": "module",
   "bin": {