driggsby 0.3.2 → 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/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.2",
+  "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.2",
-    "@driggsby/sdk": "0.3.2"
+    "@driggsby/deploy": "0.3.3",
+    "@driggsby/sdk": "0.3.3"
   }
 }