droppage 0.1.1 → 0.2.0

package/README.md

@@ -38,14 +38,21 @@ Open the printed link in any browser. That's it.
 |---|---|
 | `droppage login` | Authenticate with a magic link (session stored in `~/.droppage/config.json`). |
 | `droppage logout` | Sign out and clear local credentials. |
-| `droppage upload <file>` | Publish an `.html`/`.htm` file and print its URL. Options: `--password`, `--email <addr>`, `--private`. |
-| `droppage update <slug> <file>` | Replace the HTML behind an existing URL. Keeps the URL, access mode, and stats. |
-| `droppage list` | List your pages. `--json` for machines, `--preview` for no-count preview URLs. |
-| `droppage delete <slug>` | Delete a page. `--yes` skips the confirmation prompt. |
+| `droppage upload <file>` | Publish an `.html`/`.htm` file (and the local images it references) and print its URL. Options: `--password`, `--email <addr>`, `--private`, `--expires <when>`. |
+| `droppage update <slug> <file>` | Replace the HTML (and images) behind an existing URL. Keeps the URL, access mode, and stats. `--expires <when\|never>` changes the expiry. |
+| `droppage expire <slug> <when\|never>` | Set or clear when a page expires without re-uploading. |
+| `droppage list` | List your pages, including an EXPIRES column. `--json` for machines (rows have `expires_at`), `--preview` for no-count preview URLs. |
+| `droppage delete <slug>` | Delete a page and its images. `--yes` skips the confirmation prompt. |
 | `droppage recipients list <slug>` | List recipients of an email-gated page (`--json`, `--page <n>`). |
 | `droppage recipients add <slug> <emails...>` | Add recipients and queue their invitation emails. |
 | `droppage recipients remove <slug> <email>` | Revoke a recipient; their invitation link stops working (`--yes`). |
 | `droppage recipients resend <slug> <email>` | Queue a fresh invitation for an existing recipient. |
+| `droppage image upload <files...> --page <slug>` | Advanced: add images (PNG, JPEG, GIF, WebP, AVIF, SVG; up to 4 MB each) to an existing page and print their URLs. `--json` prints `[{file,id,url,bytes,content_type,existing}]`. |
+| `droppage image list [--page <slug>]` | List your pages' images; with `--page`, one page and its image budget. `--json` for machines. |
+| `droppage image delete <id-or-url...>` | Delete images. Cached copies may still show for up to a day. |
+| `droppage quota` | Show the current plan, page usage, monthly meter, reset date, and enabled features. `--json` returns the account API body. |
+| `droppage feedback <message>` | Send feedback without requiring login. Options: `--kind idea|bug|review|other`, `--agent [model]`, `--contact <email>`, review-only `--rating <1-5>` and `--allow-quote`. Quote permission never publishes automatically. |
+| `droppage upgrade` | Install the latest CLI globally with npm and report the installed version. |
 
 Run `droppage <command> --help` for full option details.
 
@@ -59,22 +66,76 @@ Run `droppage <command> --help` for full option details.
 | `--private` | private | Only you (your account email). Useful for drafts. |
 
 `--password`, `--email`, and `--private` are mutually exclusive. `update` never changes the access
-mode — it only swaps the HTML.
+mode — it only swaps the HTML. When you are signed in to droppage.dev, your own protected pages
+open directly, without the password or email link.
 
 ## Rules for uploads
 
 - One `.html` or `.htm` file per upload; the file is validated before any network call.
-- Inline your assets (CSS, JS, images as data URIs). Relative asset paths will not resolve.
-- Views shown by `list` are raw successful renders (including refreshes and crawlers), not unique visitors.
+- Inline your CSS, JS, and data. Relative asset paths other than images will not resolve. Local
+  images referenced in `<img src>` are uploaded with the page (see below); sensitive images belong
+  inline as data: URIs.
+- Views shown by `list` count one unique visitor per page. Refreshes, reopening in the same browser,
+  link previews from chat apps, and your own opens do not add views.
 - Preview URLs (`list --preview`) never increment the view count.
 
+## Images
+
+Images belong to a page. Reference local image files in your HTML (inside the HTML file's folder; `../` and absolute paths are ignored), with paths relative to the HTML
+file, and upload it:
+
+```html
+<img src="chart.png">
+```
+
+```bash
+$ droppage upload report.html
+droppage: image chart.png → https://droppage.dev/i/AbCdEfGhIjKl.png
+https://droppage.dev/p/k3x9qd2m
+```
+
+`upload` finds the images, uploads them to that page, rewrites the links to
+`https://droppage.dev/i/<id>.<ext>`, then publishes. The image lines go to stderr; stdout is still
+only the page URL.
+
+- `update` uploads any new local images, keeps the same URL for an unchanged image, and deletes
+  the page's images the new HTML no longer uses.
+- Deleting a page, or the page expiring, removes its images too. Images never outlive their page.
+- Image budget per page by plan: Free 5 MB, Starter 20 MB, Builder 50 MB. Each image up to 4 MB.
+  PNG, JPEG, GIF, WebP, AVIF, SVG. Image traffic counts toward your monthly bandwidth.
+- Prefer small formats: WebP or AVIF for photos and screenshots, SVG for charts and logos (often
+  several times smaller than PNG or JPEG). The CLI prints a tip on stderr when a PNG, JPEG, or GIF
+  is over 300 KB.
+- **Images are public** to anyone with the URL. A page's password, email, or private gate does not
+  protect them. Keep sensitive images inline in the HTML as data: URIs instead.
+- Advanced: `droppage image upload <files...> --page <slug>` adds images to an existing page and
+  prints their URLs; `droppage image list [--page <slug>] [--json]` shows them (`--json` prints
+  `{images:[{id,url,ext,content_type,bytes,name,created_at,page}], page?:{slug,used_bytes,limit_bytes}}`);
+  `droppage image delete <id-or-url...>` removes them.
+
+## Expiry
+
+Pages can expire. Nothing expires unless you set it, on any plan.
+
+```bash
+droppage upload report.html --expires 7d          # also 30m, 12h, 2w, or a date like 2026-12-31
+droppage update <slug> report.html --expires never
+droppage expire <slug> 2026-12-31                 # change it without re-uploading; `never` clears it
+```
+
+After expiry the page shows "This page has expired." (HTTP 410) to everyone, including you, and
+its images stop working. A daily cleanup then deletes the page and its images for good.
+`droppage list` shows an EXPIRES column (`never` or a date); `list --json` rows have `expires_at`
+(`null` means never).
+
 ## For agents and scripts
 
 droppage keeps a strict stream contract so it is safe to call from automation:
 
-- `upload` and `update` print **only the URL** on stdout.
-- `list --json` and `recipients list --json` print **only JSON** on stdout.
-- Progress, warnings, prompts, and errors go to **stderr**.
+- `upload` and `update` print **only the URL** on stdout, even when they upload images;
+  `image upload` prints **only the image URL(s)**; `expire` prints **nothing** on stdout.
+- `list --json`, `image list --json`, `recipients list --json`, and `quota --json` print **only JSON** on stdout.
+- Progress, warnings, prompts, errors, and the per-image `droppage: image … → …` lines go to **stderr**.
 - Non-zero exit code on any failure.
 - Use `--yes` on `delete` / `recipients remove` for non-interactive runs.
 
@@ -84,10 +145,28 @@ Ready-made instruction packs for Codex, Cursor, and Claude-style agents live in
 ## Updating
 
 ```bash
-npm update -g droppage      # upgrade to the latest release
+droppage upgrade            # upgrade to the latest release
 droppage --version          # confirm the installed version
 ```
 
+After a command finishes, interactive terminals check npm for a new release at most once every 24
+hours and put any update notice on stderr only. The check sends no identifier or usage data, and
+all errors are ignored. Set `DROPPAGE_NO_UPDATE_CHECK=1` to opt out. This registry lookup is the
+CLI's only non-backend network request; droppage still collects no telemetry.
+
+Before bulk publishing, use `droppage quota --json`. A `warn` level means the monthly meter is at
+least 80% used; `limit` means new uploads, updates, or previews may pause. Existing links remain
+live. Delete unneeded pages or review plan options at [droppage.dev/account](https://droppage.dev/account).
+
+Feedback is public and login is optional:
+
+```bash
+droppage feedback "The preview command should…" --kind idea
+droppage feedback "Upload failed after…" --kind bug --agent "my-model"
+```
+
+Agent-authored feedback should always use `--agent` and include the model name.
+
 Releases are published from GitHub Actions with
 [npm provenance](https://docs.npmjs.com/generating-provenance-statements), so every version on npm
 is verifiably built from a tagged commit in the public repository.
@@ -102,6 +181,7 @@ setups, these environment variables are honoured (in order of precedence):
 | `DROPPAGE_SUPABASE_URL` / `DROPPAGE_SUPABASE_ANON_KEY` | Point the CLI at another backend. |
 | `SUPABASE_URL` / `SUPABASE_ANON_KEY` | Fallback names for the same. |
 | `DROPPAGE_SHARE_BASE_URL` | Origin used when printing share URLs (default `https://droppage.dev`). |
+| `DROPPAGE_NO_UPDATE_CHECK` | Set to `1` to disable the optional 24-hour npm release check. |
 
 ## Security
 

package/dist/cli.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "droppage",
-      version: "0.1.1",
+      version: "0.2.0",
       description: "Publish HTML files as shareable, access-controlled live pages",
       type: "module",
       license: "Apache-2.0",
@@ -83,12 +83,12 @@ var init_package = __esm({
 // src/lib/callback-server.ts
 import { createServer } from "http";
 function closeServer(server) {
-  return new Promise((resolve) => {
-    server.close(() => resolve());
+  return new Promise((resolve2) => {
+    server.close(() => resolve2());
   });
 }
 function tryListen(port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = createServer();
     const onError = (err) => {
       server.off("listening", onListening);
@@ -96,7 +96,7 @@ function tryListen(port) {
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve(server);
+      resolve2(server);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -137,7 +137,7 @@ function normalizeArgs(portOrOptions, pathArg) {
 }
 function waitForAuthCode(portOrOptions, pathArg) {
   const { port, path, timeoutMs } = normalizeArgs(portOrOptions, pathArg);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     let timeout;
     const settle = (fn) => {
@@ -160,7 +160,7 @@ function waitForAuthCode(portOrOptions, pathArg) {
       res.end(SUCCESS_BODY);
       void closeServer(server).then(() => {
         if (code) {
-          settle(() => resolve(code));
+          settle(() => resolve2(code));
           return;
         }
         const message = errorDescription || error || "No auth code in callback";
@@ -215,7 +215,7 @@ function rejectSecrets(label, value) {
   }
 }
 function resolveSupabaseEnv() {
-  loadDotenv({ path: join(process.cwd(), ".env") });
+  loadDotenv({ path: join(process.cwd(), ".env"), quiet: true });
   const url = process.env.DROPPAGE_SUPABASE_URL || process.env.SUPABASE_URL || DEFAULT_SUPABASE_URL;
   const anonKey = process.env.DROPPAGE_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || DEFAULT_SUPABASE_ANON_KEY;
   if (!url.trim() || !anonKey.trim()) {
@@ -245,6 +245,18 @@ var init_env = __esm({
 import Conf from "conf";
 import { homedir } from "os";
 import { join as join2 } from "path";
+function confAt(slot, configName) {
+  const home = homedir();
+  if (!slot.instance || slot.home !== home) {
+    slot.home = home;
+    slot.instance = new Conf({
+      cwd: join2(home, ".droppage"),
+      configName,
+      configFileMode: 384
+    });
+  }
+  return slot.instance;
+}
 function validateConfig(data) {
   for (const [key, value] of Object.entries(data)) {
     if (FORBIDDEN.test(key)) {
@@ -260,16 +272,10 @@ function validateConfig(data) {
   }
 }
 function getConf() {
-  const home = homedir();
-  if (!confInstance || confHome !== home) {
-    confHome = home;
-    confInstance = new Conf({
-      cwd: join2(home, ".droppage"),
-      configName: "config",
-      configFileMode: 384
-    });
-  }
-  return confInstance;
+  return confAt(sessionConf, "config");
+}
+function getUpdateCheckConf() {
+  return confAt(updateCheckConf, "update-check");
 }
 function createConfStorage() {
   const conf = getConf();
@@ -287,11 +293,13 @@ function createConfStorage() {
     }
   };
 }
-var FORBIDDEN, confInstance, confHome;
+var FORBIDDEN, sessionConf, updateCheckConf;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     FORBIDDEN = /service_role|sb_secret/i;
+    sessionConf = {};
+    updateCheckConf = {};
   }
 });
 
@@ -375,7 +383,8 @@ async function login() {
     `(debug) After you click the link, Auth redirects to: ${emailRedirectTo}`
   );
   const { url } = resolveSupabaseEnv();
-  if (isLocalSupabaseUrl(url)) {
+  const noBrowser = Boolean(process.env.DROPPAGE_NO_BROWSER || process.env.CI);
+  if (isLocalSupabaseUrl(url) && !noBrowser) {
     try {
       await open(INBUCKET_URL);
     } catch {
@@ -483,6 +492,86 @@ var init_password = __esm({
   }
 });
 
+// src/lib/duration.ts
+function parseExpiry(value, now = Date.now()) {
+  const raw = value.trim().toLowerCase();
+  if (raw === "never" || raw === "none") return null;
+  const match = /^(\d+)\s*([mhdw])$/.exec(raw);
+  if (match) {
+    const ms = Number(match[1]) * UNITS[match[2]];
+    if (ms <= 0) throw new Error(`--expires must be in the future: ${value}`);
+    return new Date(now + ms);
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(raw)) {
+    const date = new Date(value.trim());
+    if (Number.isNaN(date.getTime())) throw new Error(`--expires: not a date: ${value}`);
+    if (date.getTime() <= now) throw new Error(`--expires must be in the future: ${value}`);
+    return date;
+  }
+  throw new Error(`--expires: use a duration like 30m, 12h, 7d or 2w, a date like 2026-12-31, or never`);
+}
+var UNITS;
+var init_duration = __esm({
+  "src/lib/duration.ts"() {
+    "use strict";
+    UNITS = { m: 6e4, h: 36e5, d: 864e5, w: 7 * 864e5 };
+  }
+});
+
+// src/lib/html-images.ts
+import { existsSync, realpathSync, statSync } from "fs";
+import { dirname, extname, relative, resolve, sep } from "path";
+function inside(base, path) {
+  const rel = relative(base, path);
+  return !!rel && !rel.startsWith("..") && !rel.startsWith(sep) && !/^[a-z]:/i.test(rel);
+}
+function findLocalImages(html, htmlFile) {
+  const base = dirname(resolve(htmlFile));
+  let realBase;
+  try {
+    realBase = realpathSync(base);
+  } catch {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const match of html.matchAll(SRC_RE)) {
+    const ref = match[3].trim();
+    if (seen.has(ref) || /^(?:[a-z][a-z0-9+.-]*:|\/|\\|#)/i.test(ref)) continue;
+    let decoded;
+    try {
+      decoded = decodeURIComponent(ref.split(/[?#]/)[0]);
+    } catch {
+      continue;
+    }
+    if (!IMAGE_EXTS.has(extname(decoded).toLowerCase())) continue;
+    const path = resolve(base, decoded);
+    if (!inside(base, path) || !existsSync(path)) continue;
+    let real;
+    try {
+      real = realpathSync(path);
+    } catch {
+      continue;
+    }
+    if (!inside(realBase, real) || !statSync(real).isFile()) continue;
+    seen.set(ref, { ref, path: real });
+  }
+  return [...seen.values()];
+}
+function rewriteImageRefs(html, urls) {
+  return html.replace(SRC_RE, (whole, before, quote, ref) => {
+    const url = urls.get(ref.trim());
+    return url ? `${before}${quote}${url}${quote}` : whole;
+  });
+}
+var IMAGE_EXTS, SRC_RE;
+var init_html_images = __esm({
+  "src/lib/html-images.ts"() {
+    "use strict";
+    IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".svg"]);
+    SRC_RE = /(<(?:img|source)\b[^>]*?\ssrc\s*=\s*)(["'])([^"']+)\2/gi;
+  }
+});
+
 // src/lib/share-url.ts
 function resolveShareBaseUrl() {
   const raw = process.env.DROPPAGE_SHARE_BASE_URL?.trim();
@@ -499,6 +588,143 @@ var init_share_url = __esm({
   }
 });
 
+// src/services/images.ts
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+async function accessToken() {
+  const { data } = await createSupabaseClient().auth.getSession();
+  const token = data.session?.access_token;
+  if (!token) throw new ImageRequestError("not signed in; run `droppage login`", 401);
+  return token;
+}
+async function call(path, init) {
+  const base = resolveShareBaseUrl();
+  let response;
+  try {
+    response = await fetch(`${base}${path}`, init);
+  } catch (err) {
+    throw new ImageRequestError(`could not reach ${base}: ${err instanceof Error ? err.message : String(err)}`, 0);
+  }
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (!response.ok) {
+    const message = body?.error ?? `request failed (HTTP ${response.status})`;
+    throw new ImageRequestError(message, response.status);
+  }
+  return body;
+}
+async function uploadImage(file, slug, { update = false } = {}) {
+  const info = await stat(file).catch(() => null);
+  if (!info?.isFile()) throw new ImageRequestError(`file not found: ${file}`, 0);
+  if (info.size === 0) throw new ImageRequestError(`file is empty: ${file}`, 0);
+  if (info.size > MAX_IMAGE_BYTES) {
+    throw new ImageRequestError(`image is larger than ${MAX_IMAGE_BYTES / 1024 / 1024} MB (${info.size} bytes): ${file}`, 413);
+  }
+  const bytes = await readFile(file);
+  const body = await call("/api/images", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${await accessToken()}`,
+      "Content-Type": "application/octet-stream",
+      "X-Droppage-Filename": encodeURIComponent(basename(file)),
+      "X-Droppage-Page": slug,
+      ...update ? { "X-Droppage-Update": "1" } : {}
+    },
+    body: bytes
+  });
+  if (info.size > HEAVY_IMAGE_BYTES && /\.(png|jpe?g|gif)$/i.test(file)) {
+    console.error(`droppage: tip: ${basename(file)} is ${Math.round(info.size / 1024)} KB; WebP or AVIF is usually several times smaller (SVG for charts).`);
+  }
+  const image = body;
+  if (!image || typeof image.url !== "string" || typeof image.id !== "string") {
+    throw new ImageRequestError("unexpected response from the image API", 0);
+  }
+  return image;
+}
+async function listImages(slug) {
+  const query = slug ? `?page=${encodeURIComponent(slug)}` : "";
+  const body = await call(`/api/images${query}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${await accessToken()}` }
+  });
+  const list = body;
+  if (!list || !Array.isArray(list.images)) throw new ImageRequestError("unexpected response from the image API", 0);
+  return list;
+}
+function imageIdFrom(value) {
+  const match = /(?:^|\/i\/)([A-Za-z0-9]{12})(?:\.[a-z]+)?$/.exec(value.trim());
+  return match ? match[1] : null;
+}
+async function deleteImage(idOrUrl) {
+  const id = imageIdFrom(idOrUrl);
+  if (!id) throw new ImageRequestError(`not an image id or URL: ${idOrUrl}`, 0);
+  await call(`/api/images/${id}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${await accessToken()}` }
+  });
+  return id;
+}
+async function pruneImages(slug) {
+  const body = await call(`/api/pages/${encodeURIComponent(slug)}/images/prune`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${await accessToken()}` }
+  });
+  return Number(body?.removed ?? 0);
+}
+var MAX_IMAGE_BYTES, HEAVY_IMAGE_BYTES, ImageRequestError;
+var init_images = __esm({
+  "src/services/images.ts"() {
+    "use strict";
+    init_share_url();
+    init_supabase();
+    MAX_IMAGE_BYTES = 4 * 1024 * 1024;
+    HEAVY_IMAGE_BYTES = 300 * 1024;
+    ImageRequestError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "ImageRequestError";
+      }
+    };
+  }
+});
+
+// src/services/page-images.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename2 } from "path";
+async function attachLocalImages(file, slug, { html, update = false } = {}) {
+  const source = html ?? await readFile2(file);
+  const text = source.toString("utf8");
+  const local = findLocalImages(text, file);
+  if (local.length === 0) return { html: source, uploaded: [] };
+  const urls = /* @__PURE__ */ new Map();
+  const uploaded = [];
+  for (const image of local) {
+    const result = await uploadImage(image.path, slug, { update });
+    urls.set(image.ref, result.url);
+    uploaded.push(result);
+    console.error(`droppage: image ${basename2(image.path)} \u2192 ${result.url}`);
+  }
+  return { html: Buffer.from(rewriteImageRefs(text, urls), "utf8"), uploaded };
+}
+async function hasLocalImages(file) {
+  return findLocalImages((await readFile2(file)).toString("utf8"), file).length > 0;
+}
+async function pruneUnusedImages(slug) {
+  return pruneImages(slug);
+}
+var init_page_images = __esm({
+  "src/services/page-images.ts"() {
+    "use strict";
+    init_html_images();
+    init_images();
+  }
+});
+
 // src/lib/slug.ts
 import { customAlphabet } from "nanoid";
 function createSlug() {
@@ -514,14 +740,34 @@ var init_slug = __esm({
   }
 });
 
+// src/lib/supabase-error.ts
+function asError(err) {
+  if (err instanceof Error) return err;
+  if (err !== null && typeof err === "object" && typeof err.message === "string") {
+    const error = new Error(err.message);
+    const code = err.code;
+    if (typeof code === "string") Object.assign(error, { code });
+    return error;
+  }
+  return new Error(String(err));
+}
+var init_supabase_error = __esm({
+  "src/lib/supabase-error.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/validate-html.ts
-import { extname } from "path";
+import { extname as extname2 } from "path";
+function isHostedImage(url) {
+  return url.startsWith(`${resolveShareBaseUrl()}/i/`);
+}
 function formatBytes(bytes) {
   const mb = bytes / (1024 * 1024);
   return `${mb.toFixed(1)} MB`;
 }
 function validateHtmlUpload(path, bytes) {
-  const ext = extname(path).toLowerCase();
+  const ext = extname2(path).toLowerCase();
   if (!ALLOWED_EXTENSIONS.has(ext)) {
     throw new Error(
       `Unsupported file type: ${path} (expected .html or .htm)`
@@ -553,7 +799,8 @@ function validateHtmlUpload(path, bytes) {
       "HTML references relative assets (src/href beginning with ./ or /); they will not resolve in a single-file share. Inline them for a self-contained page."
     );
   }
-  if (EXTERNAL_ASSET_RE.test(body)) {
+  const external = [...body.matchAll(EXTERNAL_ASSET_RE)].map((m) => m[1]).filter((url) => !isHostedImage(url));
+  if (external.length > 0) {
     warnings.push(
       "HTML references external assets (//host or http(s)://); they must be publicly reachable to render in the shared page."
     );
@@ -564,6 +811,7 @@ var MAX_UPLOAD_BYTES, ALLOWED_EXTENSIONS, SNIFF_BYTES, HTML_MARKERS, RELATIVE_AS
 var init_validate_html = __esm({
   "src/lib/validate-html.ts"() {
     "use strict";
+    init_share_url();
     MAX_UPLOAD_BYTES = 5 * 1024 * 1024;
     ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".htm"]);
     SNIFF_BYTES = 4096;
@@ -574,33 +822,51 @@ var init_validate_html = __esm({
       /<body[\s>]/i,
       /<div[\s>]/i
     ];
-    RELATIVE_ASSET_RE = /(?:src|href)\s*=\s*["'](?:\.\.?\/|\/(?!\/))/i;
-    EXTERNAL_ASSET_RE = /(?:src|href)\s*=\s*["'](\/\/|https?:\/\/)/i;
+    RELATIVE_ASSET_RE = /(?:src|href)\s*=\s*["'](?:\.\.?\/|\/(?!\/)(?!i\/[A-Za-z0-9]{12}\.[a-z]+["']))/i;
+    EXTERNAL_ASSET_RE = /(?:src|href)\s*=\s*["']((?:\/\/|https?:\/\/)[^"']*)/gi;
   }
 });
 
 // src/services/upload.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 async function upload({
   file,
   user,
   passwordHash,
   allowedEmails,
-  accessMode
+  accessMode,
+  prepare,
+  expiresAt
 }) {
-  const bytes = await readFile(file);
+  let bytes = await readFile3(file);
   const { warnings } = validateHtmlUpload(file, bytes);
-  for (const w of warnings) console.error(`droppage: warning: ${w}`);
+  if (!prepare) for (const w of warnings) console.error(`droppage: warning: ${w}`);
   const supabase = createSupabaseClient();
+  const resolvedMode = accessMode ?? (allowedEmails ? "email" : passwordHash ? "password" : "public");
+  const preflight = await supabase.rpc("assert_page_create_allowed", {
+    p_access_mode: resolvedMode,
+    p_recipient_count: allowedEmails?.length ?? 0
+  });
+  if (preflight.error) throw asError(preflight.error);
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     const slug = createSlug();
     const storagePath = `${user.id}/${slug}.html`;
+    if (prepare) {
+      bytes = await prepare(slug);
+      if (attempt === 0) for (const w of validateHtmlUpload(file, bytes).warnings) console.error(`droppage: warning: ${w}`);
+    }
     const up = await supabase.storage.from(BUCKET).upload(storagePath, bytes, {
       contentType: "text/html; charset=utf-8",
       upsert: false
     });
-    if (up.error) throw up.error;
-    const resolvedMode = accessMode ?? (allowedEmails ? "email" : passwordHash ? "password" : "public");
+    if (up.error) {
+      if (/row-level security/i.test(up.error.message)) {
+        throw new Error(
+          `the server rejected this upload: ${up.error.message}. This can happen when an account limit is reached while an upload is in flight \u2014 run \`droppage quota\` to check your limits.`
+        );
+      }
+      throw asError(up.error);
+    }
     const ins = await supabase.rpc("create_page_with_entitlements", {
       p_slug: slug,
       p_storage_path: storagePath,
@@ -608,7 +874,17 @@ async function upload({
       p_password_hash: resolvedMode === "password" ? passwordHash : null,
       p_allowed_emails: allowedEmails ?? null
     });
-    if (!ins.error) return buildShareUrl(slug);
+    if (!ins.error) {
+      if (expiresAt) {
+        const expiry = await supabase.rpc("set_page_expiry", { p_slug: slug, p_expires_at: expiresAt.toISOString() });
+        if (expiry.error) {
+          throw new Error(
+            `published ${buildShareUrl(slug)} but could not set its expiry (${expiry.error.message}); set it with \`droppage expire ${slug} <when>\` or delete it`
+          );
+        }
+      }
+      return buildShareUrl(slug);
+    }
     const rm = await supabase.storage.from(BUCKET).remove([storagePath]);
     if (rm.error) {
       console.error(
@@ -616,7 +892,7 @@ async function upload({
       );
     }
     if (ins.error.code === "23505") continue;
-    throw ins.error;
+    throw asError(ins.error);
   }
   throw new Error(
     `Could not allocate a unique slug after ${MAX_RETRIES} attempts`
@@ -628,6 +904,7 @@ var init_upload = __esm({
     "use strict";
     init_share_url();
     init_slug();
+    init_supabase_error();
     init_supabase();
     init_validate_html();
     BUCKET = "pages";
@@ -642,7 +919,7 @@ function registerUpload(program2) {
     "--email <address>",
     "restrict access to an email allowlist (repeatable; comma-separated)",
     (val, prev = []) => prev.concat(val.split(","))
-  ).option("--private", "restrict access to only you (owner-only draft)").action(
+  ).option("--private", "restrict access to only you (owner-only draft)").option("--expires <when>", "delete the page (and its images) after 30m, 12h, 7d, 2w or on a date").action(
     async (file, options) => {
       let user;
       try {
@@ -707,21 +984,28 @@ function registerUpload(program2) {
           allowedEmails = [ownerEmail];
           accessMode = "private";
         }
+        const expiresAt = options.expires ? parseExpiry(options.expires) ?? void 0 : void 0;
         console.error(`droppage: uploading ${file}...`);
+        const prepare = await hasLocalImages(file) ? async (slug) => (await attachLocalImages(file, slug)).html : void 0;
         const url = await upload({
           file,
           user,
           passwordHash,
           allowedEmails,
-          accessMode
+          accessMode,
+          prepare,
+          expiresAt
         });
+        if (expiresAt) console.error(`droppage: expires ${expiresAt.toISOString()}`);
         console.error("droppage: done");
         process.stdout.write(url + "\n");
       } catch (err) {
         process.exitCode = 1;
-        console.error(
-          `droppage: upload failed: ${err instanceof Error ? err.message : String(err)}`
-        );
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`droppage: upload failed: ${message}`);
+        if (/quota reached|require (Starter|Builder)/i.test(message)) {
+          console.error("run `droppage quota` to see your limits");
+        }
       }
     }
   );
@@ -730,17 +1014,19 @@ var init_upload2 = __esm({
   "src/commands/upload.ts"() {
     "use strict";
     init_password();
+    init_duration();
+    init_page_images();
     init_auth();
     init_upload();
   }
 });
 
 // src/services/pages.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 async function listPages(user) {
   const supabase = createSupabaseClient();
   const { data, error } = await supabase.from("pages").select(
-    "slug, access_mode, allowed_emails, view_count, created_at, last_viewed_at"
+    "slug, access_mode, allowed_emails, view_count, created_at, last_viewed_at, expires_at"
   ).eq("owner_id", user.id).order("created_at", { ascending: false });
   if (error) throw error;
   return data ?? [];
@@ -782,9 +1068,10 @@ async function deletePage(slug, user) {
 async function updatePageHtml({
   slug,
   file,
-  user
+  user,
+  html
 }) {
-  const bytes = await readFile2(file);
+  const bytes = html ?? await readFile4(file);
   const { warnings } = validateHtmlUpload(file, bytes);
   for (const warning of warnings) {
     console.error(`droppage: warning: ${warning}`);
@@ -793,7 +1080,7 @@ async function updatePageHtml({
   const preflight = await supabase.rpc("assert_page_update_allowed", {
     p_slug: slug
   });
-  if (preflight.error) throw preflight.error;
+  if (preflight.error) throw asError(preflight.error);
   const { data: row, error: selectError } = await supabase.from("pages").select("slug, storage_path").eq("slug", slug).eq("owner_id", user.id).maybeSingle();
   if (selectError) throw selectError;
   if (!row) throw new Error("page not found or not owned");
@@ -815,11 +1102,24 @@ async function updatePageHtml({
     url: buildShareUrl(slug)
   };
 }
+async function setPageExpiry(slug, expiresAt) {
+  const supabase = createSupabaseClient();
+  const { error } = await supabase.rpc("set_page_expiry", {
+    p_slug: slug,
+    p_expires_at: expiresAt ? expiresAt.toISOString() : null
+  });
+  if (error) throw asError(error);
+}
+async function assertUpdateAllowed(slug) {
+  const { error } = await createSupabaseClient().rpc("assert_page_update_allowed", { p_slug: slug });
+  if (error) throw asError(error);
+}
 var BUCKET2, NOT_FOUND_MESSAGE;
 var init_pages = __esm({
   "src/services/pages.ts"() {
     "use strict";
     init_share_url();
+    init_supabase_error();
     init_supabase();
     init_validate_html();
     BUCKET2 = "pages";
@@ -828,8 +1128,9 @@ var init_pages = __esm({
 });
 
 // src/commands/update.ts
+import { readFile as readFile5 } from "fs/promises";
 function registerUpdate(program2) {
-  program2.command("update").description("Replace the HTML behind an existing page URL").argument("<slug>", "slug of the page to update").argument("<file>", "path to replacement .html file").action(async (slug, file) => {
+  program2.command("update").description("Replace the HTML behind an existing page URL (its local images are uploaded too)").argument("<slug>", "slug of the page to update").argument("<file>", "path to replacement .html file").option("--expires <when>", "set when the page expires: 30m, 12h, 7d, 2w, a date, or never").action(async (slug, file, options) => {
     let user;
     try {
       user = await requireAuth();
@@ -838,22 +1139,53 @@ function registerUpdate(program2) {
       throw err;
     }
     try {
+      const expiresAt = options.expires === void 0 ? void 0 : parseExpiry(options.expires);
       console.error(`droppage: updating ${slug} from ${file}...`);
-      const result = await updatePageHtml({ slug, file, user });
+      await assertUpdateAllowed(slug);
+      validateHtmlUpload(file, await readFile5(file));
+      const { html } = await attachLocalImages(file, slug, { update: true });
+      const result = await updatePageHtml({ slug, file, user, html });
+      const removed = await pruneUnusedImages(slug);
+      if (removed) console.error(`droppage: removed ${removed} image(s) the page no longer uses`);
+      if (expiresAt !== void 0) {
+        await setPageExpiry(slug, expiresAt);
+        console.error(expiresAt ? `droppage: expires ${expiresAt.toISOString()}` : "droppage: never expires");
+      }
       console.error(`droppage: updated ${slug}`);
       process.stdout.write(result.url + "\n");
     } catch (err) {
       process.exitCode = 1;
-      console.error(
-        `droppage: update failed: ${err instanceof Error ? err.message : String(err)}`
-      );
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`droppage: update failed: ${message}`);
+      if (/quota reached|limit reached|require (Starter|Builder)/i.test(message)) {
+        console.error("run `droppage quota` to see your limits");
+      }
+    }
+  });
+  program2.command("expire").description("Set when a page (and its images) is deleted: 30m, 12h, 7d, 2w, a date, or never").argument("<slug>", "slug of the page").argument("<when>", "e.g. 7d, 2026-12-31, or never").action(async (slug, when) => {
+    try {
+      await requireAuth();
+    } catch (err) {
+      if (err instanceof AuthRequiredError) return;
+      throw err;
+    }
+    try {
+      const expiresAt = parseExpiry(when);
+      await setPageExpiry(slug, expiresAt);
+      console.error(expiresAt ? `droppage: ${slug} expires ${expiresAt.toISOString()}` : `droppage: ${slug} never expires`);
+    } catch (err) {
+      process.exitCode = 1;
+      console.error(`droppage: expire failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   });
 }
 var init_update = __esm({
   "src/commands/update.ts"() {
     "use strict";
+    init_validate_html();
+    init_duration();
     init_auth();
+    init_page_images();
     init_pages();
   }
 });
@@ -883,7 +1215,8 @@ function pageTableCells(row) {
     formatModeCell(row.access_mode, row.allowed_emails),
     formatDateCell(row.created_at),
     String(row.view_count),
-    formatDateCell(row.last_viewed_at)
+    formatDateCell(row.last_viewed_at),
+    row.expires_at ? row.expires_at.slice(0, 16).replace("T", " ") : "never"
   ];
 }
 var PAGE_TABLE_HEADERS, PAGE_TABLE_ALIGN;
@@ -895,13 +1228,15 @@ var init_table = __esm({
       "MODE",
       "CREATED",
       "VIEWS",
-      "LAST VIEWED"
+      "LAST VIEWED",
+      "EXPIRES"
     ];
     PAGE_TABLE_ALIGN = [
       "left",
       "left",
       "left",
       "right",
+      "left",
       "left"
     ];
   }
@@ -1243,6 +1578,353 @@ var init_recipients2 = __esm({
   }
 });
 
+// src/services/quota.ts
+async function fetchQuota() {
+  const supabase = createSupabaseClient();
+  const { data } = await supabase.auth.getSession();
+  const token = data.session?.access_token;
+  if (!token) throw new QuotaRequestError("not signed in; run `droppage login`", 401);
+  let response;
+  try {
+    response = await fetch(`${resolveShareBaseUrl()}/api/account`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` }
+    });
+  } catch (err) {
+    throw new QuotaRequestError(
+      `could not reach ${resolveShareBaseUrl()}: ${err instanceof Error ? err.message : String(err)}`,
+      0
+    );
+  }
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (!response.ok) {
+    const message = body?.error ?? `request failed (HTTP ${response.status})`;
+    throw new QuotaRequestError(message, response.status);
+  }
+  if (body === null || typeof body !== "object" || !("usage" in body) || !("entitlements" in body) || typeof body.usage !== "object" || body.usage === null || typeof body.entitlements !== "object" || body.entitlements === null) {
+    throw new QuotaRequestError(`request failed (HTTP ${response.status})`, response.status);
+  }
+  return body;
+}
+var QuotaRequestError;
+var init_quota = __esm({
+  "src/services/quota.ts"() {
+    "use strict";
+    init_share_url();
+    init_supabase();
+    QuotaRequestError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "QuotaRequestError";
+      }
+    };
+  }
+});
+
+// src/commands/quota.ts
+function formatBytes2(value) {
+  if (value < 1e6) return `${Math.round(value / 1e3)} KB`;
+  if (value < 1e9) return `${Number((value / 1e6).toFixed(1))} MB`;
+  return `${Number((value / 1e9).toFixed(2))} GB`;
+}
+function usedAndLimit(usage) {
+  const used = usage.meter === "views" ? `${usage.used} views` : formatBytes2(usage.used);
+  if (usage.limit === null) return `${used} / unlimited`;
+  const limit = usage.meter === "views" ? `${usage.limit} views` : formatBytes2(usage.limit);
+  return `${used} / ${limit} (${usage.percent}%)`;
+}
+function registerQuota(program2) {
+  program2.command("quota").description("Show your plan, current usage, and publishing limits").option("--json", "print the account API response as JSON").action(async (options) => {
+    try {
+      await requireAuth();
+    } catch (err) {
+      if (err instanceof AuthRequiredError) return;
+      throw err;
+    }
+    try {
+      const result = await fetchQuota();
+      if (options.json) {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return;
+      }
+      const enabled = [
+        result.entitlements.can_update && "update",
+        result.entitlements.can_preview && "preview",
+        result.entitlements.can_password && "password",
+        result.entitlements.can_email_allowlist && "email"
+      ].filter((feature) => Boolean(feature));
+      const pageLimit = result.usage.pages.limit === null ? "unlimited" : String(result.usage.pages.limit);
+      process.stdout.write(renderTable(
+        ["ITEM", "VALUE"],
+        [
+          ["Plan", result.entitlements.plan_name],
+          ["Pages", `${result.usage.pages.used} / ${pageLimit}`],
+          ...result.usage.images ? [["Images per page", result.usage.images.per_page_limit_bytes === null ? "unlimited" : `up to ${formatBytes2(result.usage.images.per_page_limit_bytes)}`]] : [],
+          ["Monthly meter", usedAndLimit(result.usage)],
+          ["Period ends", result.usage.period_end],
+          ["Features", enabled.length ? enabled.join(", ") : "basic publishing"]
+        ]
+      ) + "\n");
+      console.error(`droppage: quota level ${result.usage.level}.`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`droppage: quota failed: ${message}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_quota2 = __esm({
+  "src/commands/quota.ts"() {
+    "use strict";
+    init_table();
+    init_auth();
+    init_quota();
+  }
+});
+
+// src/services/feedback.ts
+async function submitFeedback(input2) {
+  const { data } = await createSupabaseClient().auth.getSession();
+  const token = data.session?.access_token;
+  const base = resolveShareBaseUrl();
+  let response;
+  try {
+    response = await fetch(`${base}/api/feedback`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify(input2)
+    });
+  } catch (error) {
+    throw new FeedbackRequestError(
+      `could not reach ${base}: ${error instanceof Error ? error.message : String(error)}`,
+      0
+    );
+  }
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (!response.ok || !body?.ok || !body.id) {
+    throw new FeedbackRequestError(
+      body?.error ?? `request failed (HTTP ${response.status})`,
+      response.status
+    );
+  }
+  return { ok: true, id: body.id };
+}
+var FeedbackRequestError;
+var init_feedback = __esm({
+  "src/services/feedback.ts"() {
+    "use strict";
+    init_share_url();
+    init_supabase();
+    FeedbackRequestError = class extends Error {
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "FeedbackRequestError";
+      }
+    };
+  }
+});
+
+// src/commands/feedback.ts
+function isKind(value) {
+  return value === "idea" || value === "bug" || value === "review" || value === "other";
+}
+function registerFeedback(program2) {
+  program2.command("feedback").description("Send an idea, bug report, review, or other feedback").argument("<message>", "feedback message (3\u20134000 characters)").option("--kind <kind>", "idea, bug, review, or other", "other").option("--agent [model]", "identify this feedback as coming from an agent").option("--contact <email>", "optional reply-to email address").option("--rating <rating>", "optional 1\u20135 rating for a review").option("--allow-quote", "allow this review to be quoted publicly (never publishes automatically)").action(async (message, options) => {
+    const cleanedMessage = message.trim();
+    const model = typeof options.agent === "string" ? options.agent.trim() : void 0;
+    const contact = options.contact?.trim().toLowerCase();
+    if (cleanedMessage.length < 3 || cleanedMessage.length > 4e3) {
+      console.error("droppage: feedback must be between 3 and 4000 characters");
+      process.exitCode = 1;
+      return;
+    }
+    if (!isKind(options.kind)) {
+      console.error("droppage: --kind must be idea, bug, review, or other");
+      process.exitCode = 1;
+      return;
+    }
+    if (model && model.length > 120) {
+      console.error("droppage: agent model must be 120 characters or fewer");
+      process.exitCode = 1;
+      return;
+    }
+    if (contact && !emailSchema.safeParse(contact).success) {
+      console.error(`droppage: invalid contact email: ${contact}`);
+      process.exitCode = 1;
+      return;
+    }
+    const rating = options.rating === void 0 ? void 0 : Number(options.rating);
+    if (rating !== void 0 && (!Number.isInteger(rating) || rating < 1 || rating > 5)) {
+      console.error("droppage: --rating must be a whole number from 1 to 5");
+      process.exitCode = 1;
+      return;
+    }
+    if (options.kind !== "review" && (rating !== void 0 || options.allowQuote)) {
+      console.error("droppage: --rating and --allow-quote require --kind review");
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const result = await submitFeedback({
+        message: cleanedMessage,
+        kind: options.kind,
+        actor: options.agent === void 0 ? "human" : "agent",
+        ...model ? { model } : {},
+        ...contact ? { contact } : {},
+        ...rating !== void 0 ? { rating } : {},
+        ...options.allowQuote ? { testimonial_consent: true } : {},
+        source: "cli",
+        cli_version: package_default.version
+      });
+      process.stdout.write(`${result.id}
+`);
+      console.error("droppage: thanks \u2014 your feedback was sent.");
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      console.error(`droppage: feedback failed: ${message2}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_feedback2 = __esm({
+  "src/commands/feedback.ts"() {
+    "use strict";
+    init_package();
+    init_auth();
+    init_feedback();
+  }
+});
+
+// src/commands/upgrade.ts
+import { spawn } from "child_process";
+function installLatest() {
+  return new Promise((resolve2, reject) => {
+    const child = spawn("npm", ["install", "-g", "droppage@latest"], {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.once("error", reject);
+    child.once("close", (code) => code === 0 ? resolve2() : reject(new Error(`npm exited with status ${code ?? "unknown"}`)));
+  });
+}
+function registerUpgrade(program2) {
+  program2.command("upgrade").description("Install the latest droppage CLI release").action(async () => {
+    try {
+      await installLatest();
+      console.error("droppage: upgrade complete; run `droppage --version` to confirm.");
+    } catch (error) {
+      console.error(`droppage: upgrade failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+    }
+  });
+}
+var init_upgrade = __esm({
+  "src/commands/upgrade.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/image.ts
+function formatBytes3(value) {
+  if (value < 1e3) return `${value} B`;
+  if (value < 1e6) return `${Math.round(value / 1e3)} KB`;
+  if (value < 1e9) return `${Number((value / 1e6).toFixed(1))} MB`;
+  return `${Number((value / 1e9).toFixed(2))} GB`;
+}
+async function signedIn() {
+  try {
+    await requireAuth();
+    return true;
+  } catch (err) {
+    if (err instanceof AuthRequiredError) return false;
+    throw err;
+  }
+}
+function fail(err) {
+  console.error(`droppage: ${err instanceof Error ? err.message : String(err)}`);
+  process.exitCode = 1;
+}
+function registerImage(program2) {
+  const image = program2.command("image").description("Images that belong to a page (uploaded automatically by upload/update from local <img src> files)");
+  image.command("upload").description("Add images to one of your pages and print their URLs (PNG, JPEG, GIF, WebP, AVIF, SVG; up to 4 MB each)").argument("<files...>", "image files").requiredOption("--page <slug>", "the page the images belong to (they go when it is deleted or expires)").option("--json", "print the results as JSON").action(async (files, options) => {
+    if (!await signedIn()) return;
+    const results = [];
+    for (const file of files) {
+      try {
+        const uploaded = await uploadImage(file, options.page);
+        results.push({ file, ...uploaded });
+        if (!options.json) {
+          process.stdout.write(`${uploaded.url}
+`);
+          if (uploaded.existing) console.error(`droppage: ${file} is already on this page; same URL.`);
+        }
+      } catch (err) {
+        fail(new Error(`${file}: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    if (options.json) process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+  });
+  image.command("list").description("List your pages' images (one page with --page, including its image budget)").option("--page <slug>", "only this page").option("--json", "print the list as JSON").action(async (options) => {
+    if (!await signedIn()) return;
+    try {
+      const list = await listImages(options.page);
+      if (options.json) {
+        process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+        return;
+      }
+      if (list.images.length === 0) {
+        console.error("droppage: no images. `droppage upload page.html` uploads the images the page uses.");
+      } else {
+        process.stdout.write(renderTable(
+          ["ID", "PAGE", "NAME", "SIZE", "UPLOADED", "URL"],
+          list.images.map((row) => [row.id, row.page ?? "", row.name ?? "", formatBytes3(row.bytes), formatDateCell(row.created_at), row.url]),
+          ["left", "left", "left", "right", "left", "left"]
+        ) + "\n");
+      }
+      if (list.page) {
+        const limit = list.page.limit_bytes === null ? "unlimited" : formatBytes3(list.page.limit_bytes);
+        console.error(`droppage: images on ${list.page.slug}: ${formatBytes3(list.page.used_bytes)} of ${limit} per page.`);
+      }
+    } catch (err) {
+      fail(err);
+    }
+  });
+  image.command("delete").description("Delete images (by id or URL); a browser that already loaded one may keep it up to a day").argument("<images...>", "image ids or URLs").action(async (ids) => {
+    if (!await signedIn()) return;
+    for (const value of ids) {
+      try {
+        const id = await deleteImage(value);
+        console.error(`droppage: deleted image ${id}`);
+      } catch (err) {
+        fail(new Error(`${value}: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+  });
+}
+var init_image = __esm({
+  "src/commands/image.ts"() {
+    "use strict";
+    init_table();
+    init_auth();
+    init_images();
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -1260,6 +1942,10 @@ function createProgram() {
   registerList(program2);
   registerDelete(program2);
   registerRecipients(program2);
+  registerQuota(program2);
+  registerImage(program2);
+  registerFeedback(program2);
+  registerUpgrade(program2);
   return program2;
 }
 var init_index = __esm({
@@ -1273,6 +1959,70 @@ var init_index = __esm({
     init_list();
     init_delete();
     init_recipients2();
+    init_quota2();
+    init_feedback2();
+    init_upgrade();
+    init_image();
+  }
+});
+
+// src/lib/update-check.ts
+var update_check_exports = {};
+__export(update_check_exports, {
+  checkForUpdate: () => checkForUpdate
+});
+function stableVersion(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+function isNewerVersion(latest, current) {
+  const next = stableVersion(latest);
+  const installed = stableVersion(current);
+  if (!next || !installed) return false;
+  for (let index = 0; index < next.length; index += 1) {
+    if (next[index] !== installed[index]) return next[index] > installed[index];
+  }
+  return false;
+}
+function shouldCheck() {
+  return Boolean(process.stderr.isTTY) && !process.env.DROPPAGE_NO_UPDATE_CHECK && !process.env.CI;
+}
+async function checkForUpdate() {
+  if (!shouldCheck()) return;
+  try {
+    const cache = getUpdateCheckConf();
+    const lastCheckedAt = Date.parse(cache.get("lastCheckedAt") ?? "");
+    const stale = !Number.isFinite(lastCheckedAt) || Date.now() - lastCheckedAt >= CHECK_INTERVAL_MS;
+    let latest = cache.get("latest");
+    if (stale) {
+      const response = await fetch(REGISTRY_URL, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(1500)
+      });
+      if (!response.ok) return;
+      const body = await response.json();
+      if (typeof body.version !== "string" || !body.version.trim()) return;
+      latest = body.version.trim();
+      cache.set("latest", latest);
+      cache.set("lastCheckedAt", (/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (latest && isNewerVersion(latest, package_default.version)) {
+      process.stderr.write(
+        `droppage ${package_default.version} \u2192 ${latest} available: npm install -g droppage@latest (or droppage upgrade)
+`
+      );
+    }
+  } catch {
+  }
+}
+var CHECK_INTERVAL_MS, REGISTRY_URL;
+var init_update_check = __esm({
+  "src/lib/update-check.ts"() {
+    "use strict";
+    init_package();
+    init_config();
+    CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+    REGISTRY_URL = "https://registry.npmjs.org/droppage/latest";
   }
 });
 
@@ -1290,3 +2040,5 @@ Upgrade Node.js: https://nodejs.org/
 var { createProgram: createProgram2 } = await Promise.resolve().then(() => (init_index(), index_exports));
 var program = createProgram2();
 await program.parseAsync(process.argv);
+var { checkForUpdate: checkForUpdate2 } = await Promise.resolve().then(() => (init_update_check(), update_check_exports));
+await checkForUpdate2();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "droppage",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Publish HTML files as shareable, access-controlled live pages",
   "type": "module",
   "license": "Apache-2.0",