driggsby 0.3.1 → 0.3.3

package/README.md

@@ -86,7 +86,9 @@ Every deploy after that uploads only the files that changed. Deploy with
 `--preview` to upload a version without
 changing what visitors see, `npx driggsby@latest versions` to list every
 kept version, and `npx driggsby@latest rollback` to switch which one is
-live — switching re-uploads nothing. `npx driggsby@latest query <tool>`
+live — switching re-uploads nothing. `npx driggsby@latest delete` removes
+a deployed app forever, after asking you to type its address name back
+(`--yes` for scripts). `npx driggsby@latest query <tool>`
 runs one read-only data tool and prints its result as JSON, the same
 shape a `driggsby.watch` callback receives, so you can see the data
 before writing any render code.

package/dist/args-delete.js

@@ -0,0 +1,38 @@
+// Argv parsing for driggsby delete: one optional positional (the app's
+// address name), --yes for scripts and agents, help, and the shared
+// usage-error shape — usage errors exit 2, echoed argv is sanitized by the
+// shared builders.
+import { helpCommand, unexpectedArgument, unexpectedFlagValue, } from "./args-shared.js";
+import { DELETE_HELP } from "./help.js";
+const DELETE_USAGE = "Usage: npx driggsby@latest delete [APP-ADDRESS-NAME] [--yes]";
+export function parseDelete(argv) {
+    let slug = null;
+    let yes = false;
+    let optionsEnded = false;
+    for (const token of argv) {
+        if (!optionsEnded && token === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (!optionsEnded && (token === "-h" || token === "--help")) {
+            return helpCommand(DELETE_HELP);
+        }
+        if (!optionsEnded && token === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (!optionsEnded && token.startsWith("--yes=")) {
+            throw unexpectedFlagValue("--yes", token.slice("--yes=".length), DELETE_USAGE);
+        }
+        // Any other flag-looking token is a mistake, not a name; after "--"
+        // everything is positional and the server refuses unknown names.
+        if (!optionsEnded && token.startsWith("-") && token !== "-") {
+            throw unexpectedArgument(token, DELETE_USAGE);
+        }
+        if (slug !== null) {
+            throw unexpectedArgument(token, DELETE_USAGE);
+        }
+        slug = token;
+    }
+    return { kind: "delete", slug, yes };
+}

package/dist/args.js

@@ -7,6 +7,7 @@
 // clap's byte-level quirks.
 import { parseDeploy, parseRollback, parseVersions } from "./args-deploy.js";
 import { parseDev } from "./args-dev.js";
+import { parseDelete } from "./args-delete.js";
 import { parseInit } from "./args-init.js";
 import { parseMcpSetup } from "./args-mcp-setup.js";
 import { parseQuery } from "./args-query.js";
@@ -21,7 +22,7 @@ const MCP_USAGE = "Usage: npx driggsby@latest mcp <COMMAND>";
 const ROOT_LEVEL = {
     helpText: ROOT_HELP,
     usage: ROOT_USAGE,
-    subcommands: ["mcp", "login", "logout", "init", "dev", "deploy", "rollback", "versions", "query"],
+    subcommands: ["mcp", "login", "logout", "init", "dev", "deploy", "rollback", "versions", "delete", "query"],
     longFlags: ["help", "version"],
     subcommandFlags: [
         { name: "mcp", longFlags: ["help"] },
@@ -32,6 +33,7 @@ const ROOT_LEVEL = {
         { name: "deploy", longFlags: ["preview", "help"] },
         { name: "rollback", longFlags: ["to", "help"] },
         { name: "versions", longFlags: ["help"] },
+        { name: "delete", longFlags: ["yes", "help"] },
         { name: "query", longFlags: ["sql", "params", "help"] },
     ],
     usagePrefix: "npx driggsby@latest",
@@ -96,6 +98,8 @@ function dispatchSubcommand(name, rest) {
             return parseDeploy(rest);
         case "rollback":
             return parseRollback(rest);
+        case "delete":
+            return parseDelete(rest);
         case "versions":
             return parseVersions(rest);
         case "query":

package/dist/deploy/delete-command.js

@@ -0,0 +1,125 @@
+// driggsby delete: permanently remove a deployed app — the app itself and
+// every version Driggsby kept for it. There is no undo, so this command
+// owns the "are you sure": interactively the person types the app's
+// address name back; in a script or agent run, --yes is required.
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { deleteApp, readProjectConfig, slugProblem } from "@driggsby/deploy";
+import { apiBaseUrl } from "../api/base-url.js";
+import { CliError } from "../cli-error.js";
+import { defaultCredentialEnvironment, } from "../credentials/store.js";
+import { capForTerminal, quotedForTerminal, wrapProse } from "../terminal-text.js";
+import { MAX_SERVER_TEXT_CHARS, MAX_SERVER_URL_CHARS, deployFailure, requireDeploySession, } from "./api-session.js";
+import { fetchVersionList } from "./versions-command.js";
+const DELETE_RETRY_COMMAND = "npx driggsby@latest delete";
+// The success line is `✓ Deleted   ` (12 columns) plus the quoted name;
+// 12 + 2 quotes + 64 = 78 keeps it inside 80 whatever the server sends.
+const DELETED_LINE_NAME_CHARS = 64;
+// Once the name is known (and validated), the retry names it too, so a
+// retry from the wrong folder can't quietly target a different app.
+function retryCommandFor(slug) {
+    return slug === null ? DELETE_RETRY_COMMAND : `${DELETE_RETRY_COMMAND} ${slug}`;
+}
+function defaultDeleteIo() {
+    return {
+        out: (text) => {
+            process.stdout.write(text);
+        },
+        ask: async (question) => {
+            const { createInterface } = await import("node:readline/promises");
+            const readline = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                return await readline.question(question);
+            }
+            finally {
+                readline.close();
+            }
+        },
+        interactive: process.stdin.isTTY && process.stdout.isTTY,
+    };
+}
+export async function runDelete(options, environment = defaultCredentialEnvironment(), io = defaultDeleteIo()) {
+    const projectDirectory = options.projectDirectory ?? process.cwd();
+    const baseUrl = apiBaseUrl(environment.env);
+    let resolvedSlug = null;
+    try {
+        const slug = options.slug === null
+            ? await slugFromProjectFolder(projectDirectory)
+            : validatedArgvSlug(options.slug);
+        resolvedSlug = slug;
+        const session = await requireDeploySession(environment);
+        const api = { baseUrl: session.baseUrl, token: session.token };
+        // The look-before-you-leap read: it shows exactly what is about to
+        // go, and an unknown name stops here — with delete's own not-found,
+        // never the version list's "deploy it first" suggestion — before the
+        // DELETE is ever sent.
+        const list = await fetchVersionList(api, slug, appAlreadyGone);
+        const versionCount = list.versions.length;
+        const versionsLine = versionCount === 1 ? "1 deployed version" : `${versionCount} deployed versions`;
+        // The slug passed the strict pattern above (argv) or came from the
+        // validated project config, so it prints bare here.
+        io.out(`${wrapProse(`Deleting ${slug} removes it forever: ${versionsLine}, its page in Driggsby, and its address:`)}\n` +
+            `  ${capForTerminal(list.url, MAX_SERVER_URL_CHARS)}\n\n`);
+        if (!options.yes) {
+            await confirmOrStop(slug, io);
+        }
+        const deleted = await deleteApp(api, slug);
+        // The name is server text: quoted so it reads as a name, never as the
+        // CLI's own sentence, and capped tighter than usual (64) so the line
+        // stays inside 80 columns whatever the server sends. The preflight
+        // above already named the address, so the slug isn't repeated here.
+        io.out(`✓ Deleted   ${quotedForTerminal(deleted.appName, DELETED_LINE_NAME_CHARS)}\n\n`);
+        io.out(`${wrapProse("The app and its versions are gone, and its address now shows nothing. Deploying the app's folder again would create a new app at a new address.")}\n` +
+            "\nNext:\n" +
+            "  Start a new app with npx driggsby@latest init\n");
+        return 0;
+    }
+    catch (error) {
+        throw deployFailure(error, baseUrl, retryCommandFor(resolvedSlug));
+    }
+}
+// A name typed on the command line is shape-gated before it goes anywhere:
+// a typo gets the naming rules instead of a network round trip, nothing
+// unvalidated is ever echoed, and the empty string can't slip through to
+// match an empty confirmation answer.
+function validatedArgvSlug(slug) {
+    const problem = slugProblem(slug);
+    if (problem === null)
+        return slug;
+    const flatProblem = problem.replaceAll("\n", " ");
+    throw new CliError(wrapProse(`${quotedForTerminal(slug, MAX_SERVER_TEXT_CHARS)} doesn't look like an app's address name: ${flatProblem}. Copy the name from the app's driggsby.json ("slug"), or from npx driggsby@latest versions run in its folder.`), 2);
+}
+// The app already isn't there — for a delete that is closer to done than
+// to broken, and the one wrong suggestion would be "deploy it first".
+function appAlreadyGone(slug) {
+    return new CliError(wrapProse(`There's no app named ${quotedForTerminal(slug, MAX_SERVER_TEXT_CHARS)} on your Driggsby account — maybe it was already deleted. Nothing was changed.`), 1);
+}
+// With no name given, the app is the one this folder deploys. Only a
+// genuinely missing driggsby.json gets the "name it directly" guidance;
+// a present-but-broken config surfaces its own precise error, the same
+// one deploy and versions would show.
+async function slugFromProjectFolder(projectDirectory) {
+    try {
+        await access(join(projectDirectory, "driggsby.json"));
+    }
+    catch {
+        throw new CliError(`${wrapProse("This folder doesn't have a driggsby.json, so there's no app here to delete. Name the app directly — the \"slug\" in its driggsby.json:")}\n` +
+            "  npx driggsby@latest delete <APP-ADDRESS-NAME>", 1);
+    }
+    const config = await readProjectConfig(projectDirectory);
+    return config.slug;
+}
+// The person types the address name back. Anything else — including an
+// empty answer — deletes nothing and says so. Scripts and agents have no
+// one to ask, so they must say --yes explicitly.
+async function confirmOrStop(slug, io) {
+    if (!io.interactive) {
+        // Already shape-validated, so echoing it into a command line is safe.
+        throw new CliError(`${wrapProse("Deleting can't be undone, and this terminal can't ask you to confirm. Say it explicitly:")}\n` +
+            `  npx driggsby@latest delete ${slug} --yes`, 2);
+    }
+    const answer = (await io.ask("Type the app's address name to confirm: ")).trim();
+    if (answer !== slug) {
+        throw new CliError("That didn't match, so nothing was deleted.", 1);
+    }
+}

package/dist/deploy/versions-command.js

@@ -42,20 +42,25 @@ export async function runVersions(options, environment = defaultCredentialEnviro
         throw deployFailure(error, baseUrl, "npx driggsby@latest versions");
     }
 }
-// A 404 here means the app has never been deployed from this account, and
-// the fix is a deploy — not a retry.
-export async function fetchVersionList(api, slug) {
+// A 404 here means the app isn't on this account. For versions and
+// rollback the fix is a deploy; a caller whose right next step differs
+// (delete) passes its own notFound shape. The slug is quoted and capped
+// either way — delete hands this an argv string, not only config values.
+export async function fetchVersionList(api, slug, notFound = firstDeployCreatesIt) {
     try {
         return await listVersions(api, slug);
     }
     catch (error) {
         if (error instanceof DeployApiError && error.status === 404) {
-            throw new CliError(`${wrapProse(`There's no app named ${slug} on your Driggsby account yet. Its first deploy creates it:`)}\n` +
-                "  npx driggsby@latest deploy", 1);
+            throw notFound(slug);
         }
         throw error;
     }
 }
+function firstDeployCreatesIt(slug) {
+    return new CliError(`${wrapProse(`There's no app named ${quotedForTerminal(slug, MAX_SERVER_TEXT_CHARS)} on your Driggsby account yet. Its first deploy creates it:`)}\n` +
+        "  npx driggsby@latest deploy", 1);
+}
 export function renderVersionRows(list) {
     const rows = list.versions.map((version) => ({
         label: `v${version.number}`,

package/dist/help.js

@@ -19,6 +19,7 @@ Commands:
   deploy    Deploy the app in this directory to Driggsby.
   rollback  Switch which deployed version of your app is live.
   versions  List your deployed app's versions.
+  delete    Permanently remove a deployed app.
   query     Run one Driggsby data tool and print its result as JSON.
 
 Options:
@@ -128,6 +129,19 @@ Options:
                       npx driggsby@latest versions.
   -h, --help          Print help
 `;
+export const DELETE_HELP = `Permanently remove a deployed app.
+
+This deletes the app and every version Driggsby kept for it. There is no
+undo: the app's address shows nothing from that moment on. With no name,
+the app in this folder's driggsby.json is the one deleted. You'll be asked
+to type the name back to confirm; scripts and agents pass --yes instead.
+
+Usage: npx driggsby@latest delete [APP-ADDRESS-NAME] [--yes]
+
+Options:
+      --yes   Skip the confirmation question. For scripts and agents.
+  -h, --help  Print help
+`;
 export const VERSIONS_HELP = `List your deployed app's versions.
 
 Shows every version Driggsby has kept for the app in this directory, which

package/dist/init/template-styles.js

@@ -176,12 +176,13 @@ h2 {
   font-variant-numeric: tabular-nums;
 }
 
-/* The skeleton ships in the HTML so the first paint is the final layout as
-   muted bars; the first render replaces it and fades in (see app.js). Each
-   bar's margins pad it to exactly the height of the text it stands in for,
-   and the columns holding stacked bars are flex so those margins never
-   collapse — the skeleton page and the data page measure identical, and
-   nothing shifts when data lands. */
+/* The skeleton ships in the HTML so the first paint is the final layout
+   as muted bars; the first data render replaces it in a dissolve (see the
+   "Settling in" section of app.js). Each bar's margins pad it to exactly
+   the height of the text it stands in for, and the columns holding
+   stacked bars are flex so those margins never collapse — the skeleton
+   page and the data page measure identical, and nothing shifts when data
+   lands. */
 .skeleton {
   border-radius: var(--radius-bar);
   background: var(--bg-mute);
@@ -230,18 +231,10 @@ h2 {
   50% { opacity: 0.55; }
 }
 
-.fade-in {
-  animation: fade-in 200ms ease-out;
-}
-
-@keyframes fade-in {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-
+/* The skeleton-to-data dissolve itself is app.js's "Settling in" View
+   Transition; it needs no CSS here and already sits out reduced motion. */
 @media (prefers-reduced-motion: reduce) {
-  .skeleton,
-  .fade-in {
+  .skeleton {
     animation: none;
   }
 }

package/dist/init/templates.js

@@ -6,8 +6,8 @@
 // tool result shapes only in structure, so the scaffold's render functions
 // work unchanged when live data replaces them. The HTML ships a skeleton
 // of the final layout so the first paint — in every context, before any
-// script runs — is muted bars that the first render replaces, fading in
-// at the exact same size so nothing shifts.
+// script runs — is muted bars that the first render replaces at the exact
+// same size, dissolving one into the other, so nothing shifts or pops.
 export function indexHtml(slug) {
     return `<!doctype html>
 <html lang="en">
@@ -190,19 +190,6 @@ function element(tag, className, text) {
   return node;
 }
 
-// The page ships with a skeleton of this exact layout in its HTML — muted
-// bars where the numbers will be — so the very first paint is already the
-// final shape. The first render into a container replaces its skeleton and
-// fades in, so data arriving reads as the page settling, never as content
-// popping. classList.add is idempotent and re-adding a class never restarts
-// its animation, so later live updates repaint in place without re-fading.
-// aria-busy ships in the HTML so assistive tech hears "loading" until the
-// first real content lands.
-function revealOnce(container) {
-  container.classList.add("fade-in");
-  container.removeAttribute("aria-busy");
-}
-
 function renderOverview(result) {
   const rollups = (result && result.summary_rollups) || {};
   const container = document.getElementById("overview");
@@ -221,7 +208,9 @@ function renderOverview(result) {
     );
     container.append(stat);
   }
-  revealOnce(container);
+  // aria-busy ships in the HTML so assistive tech hears "loading" until
+  // the first content lands; every render clears it (harmless once gone).
+  container.removeAttribute("aria-busy");
 }
 
 function renderAccounts(result) {
@@ -231,7 +220,7 @@ function renderAccounts(result) {
   container.replaceChildren();
   if (accounts.length === 0) {
     container.append(element("div", "empty-row", "No linked accounts yet."));
-    revealOnce(container);
+    container.removeAttribute("aria-busy");
     return;
   }
   for (const account of accounts) {
@@ -262,7 +251,99 @@ function renderAccounts(result) {
     );
     container.append(row);
   }
-  revealOnce(container);
+  container.removeAttribute("aria-busy");
+}
+
+// ---------------------------------------------------------------------------
+// Settling in. The first data a section shows replaces its skeleton in a
+// dissolve: the browser snapshots the page, the paint lands, and old
+// crossfades into new (a View Transition — pixels that did not change
+// don't visibly change, so what reads as animating is the bars becoming
+// numbers). The skeleton and the data measure identical (see styles.css),
+// so the dissolve reads as the page coming into focus — never a blink, a
+// shift, or a pop. Where the browser has no View Transitions, or the
+// person prefers reduced motion, the swap is simply instant.
+//
+// The beat below covers sections whose data lands together (the common
+// case). A section whose first data trails in later gets its own beat and
+// its own dissolve; starting it skips whatever remained of the first one's
+// animation — the paints always land, only the crossfade is cut short.
+// ---------------------------------------------------------------------------
+
+// How long a section's first paint may wait so sections whose data lands
+// in the same beat dissolve in together instead of one by one.
+const SETTLE_TOGETHER_MS = 50;
+
+let pendingFirstPaints = [];
+let settleFlushScheduled = false;
+
+function settle(paint) {
+  const reducedMotion =
+    typeof window.matchMedia === "function" &&
+    window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  if (typeof document.startViewTransition !== "function" || reducedMotion) {
+    paint();
+    return;
+  }
+  pendingFirstPaints.push(paint);
+  if (settleFlushScheduled) return; // this paint rides the beat already in flight
+  settleFlushScheduled = true;
+  setTimeout(() => {
+    // Collected inside the flush, which runs inside the transition
+    // callback, so a first result that lands between the beat ending and
+    // the snapshot being taken joins this dissolve instead of cutting it
+    // short with a second one.
+    const flush = () => {
+      const paints = pendingFirstPaints;
+      pendingFirstPaints = [];
+      settleFlushScheduled = false;
+      for (const apply of paints) {
+        // One section's render must never stop another's: the scaffold
+        // is meant to be edited, and a throw mid-edit stays that
+        // section's problem — it heals on its own next result.
+        try {
+          apply();
+        } catch (error) {
+          console.error(error);
+        }
+      }
+    };
+    try {
+      const transition = document.startViewTransition(flush);
+      // A skipped transition (a hidden tab, a second dissolve starting)
+      // still runs flush; only the animation is dropped. Without this,
+      // the skip surfaces as an uncaught rejection in the console.
+      transition.ready.catch(() => {});
+    } catch (error) {
+      // If starting the transition itself threw, nothing will call
+      // flush; run it plain so the paints land and the beat resets.
+      console.error(error);
+      flush();
+    }
+  }, SETTLE_TOGETHER_MS);
+}
+
+// Wraps a render function for its watch: the first result goes through
+// settle() above, and only the latest result paints if more arrive while
+// that dissolve is still pending. Every later result repaints in place
+// with no animation at all.
+function settledRenderer(render) {
+  let hasSettled = false;
+  let firstPaintQueued = false;
+  let latestResult;
+  return (result) => {
+    if (hasSettled) {
+      render(result);
+      return;
+    }
+    latestResult = result;
+    if (firstPaintQueued) return;
+    firstPaintQueued = true;
+    settle(() => {
+      hasSettled = true;
+      render(latestResult);
+    });
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -273,7 +354,7 @@ function renderAccounts(result) {
 // shows its own notice explaining that the page runs with real data only
 // inside Driggsby. Embedded, sample numbers never paint at all — the
 // shipped skeleton holds the layout until the first real results replace
-// it and fade in.
+// it in a dissolve (see "Settling in" above).
 // ---------------------------------------------------------------------------
 
 const standalone = window.parent === window;
@@ -284,12 +365,8 @@ if (standalone) {
 }
 
 if (window.driggsby) {
-  driggsby.watch("get_overview", {}, (result) => {
-    renderOverview(result);
-  });
-  driggsby.watch("list_accounts", {}, (result) => {
-    renderAccounts(result);
-  });
+  driggsby.watch("get_overview", {}, settledRenderer(renderOverview));
+  driggsby.watch("list_accounts", {}, settledRenderer(renderAccounts));
 }
 `;
 // "background" is the template's own page background (styles.css

package/dist/main.js

@@ -3,6 +3,7 @@
 import { homedir } from "node:os";
 import { parseArgv } from "./args.js";
 import { CliError } from "./cli-error.js";
+import { runDelete } from "./deploy/delete-command.js";
 import { runDeploy } from "./deploy/deploy-command.js";
 import { runDev } from "./dev/dev-command.js";
 import { runDevStop } from "./dev/dev-stop.js";
@@ -39,6 +40,8 @@ async function run(argv) {
             return command.stop ? await runDevStop(homedir()) : await runDev();
         case "deploy":
             return await runDeploy({ preview: command.preview });
+        case "delete":
+            return await runDelete({ slug: command.slug, yes: command.yes });
         case "rollback":
             return await runRollback({ toVersion: command.toVersion });
         case "versions":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driggsby",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Set up and build on Driggsby, the MCP server for personal finance.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@driggsby/deploy": "0.3.1",
-    "@driggsby/sdk": "0.3.1"
+    "@driggsby/deploy": "0.3.3",
+    "@driggsby/sdk": "0.3.3"
   }
 }