@masculinecache/wrangler-axi 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 masculinecache
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+# wrangler-axi
+
+Agent-ergonomic TOON wrapper around [Cloudflare Wrangler](https://developers.cloudflare.com/workers/wrangler/) 4.x.
+
+`wrangler-axi` is a thin, [AXI](https://toonformat.dev/)-compliant CLI that wraps the `wrangler` binary and emits
+[TOON](https://toonformat.dev/) on stdout — compact, token-efficient output that agents can consume without a
+JSON-parsing round trip. It stays close to Wrangler's own command surface: anything you can do with `wrangler`
+you can do with `wrangler-axi`, plus predictable list schemas, definitive empty states, aggregate counts, and
+structured errors with actionable suggestions.
+
+## Install
+
+```sh
+npm install -g @masculinecache/wrangler-axi
+```
+
+Requires Node.js >= 20 and the `wrangler` binary available on `PATH` (install it with `npm install -g wrangler`).
+
+## Usage
+
+```
+wrangler-axi <area> <sub> [args]
+```
+
+Run with no arguments to see the home view.
+
+```
+$ wrangler-axi --help
+```
+
+### Global flags
+
+| Flag | Meaning |
+| --- | --- |
+| `--help`, `-h` | Show help (always allowed on every command) |
+| `--version`, `-v` | Print the wrangler-axi version |
+| `--account <id\|name>` | Select the Cloudflare account (forwarded to wrangler) |
+
+Every list command supports `--fields <a,b,c>` to request extra columns and `--limit <n>` to cap rows. `workers versions list` and `workers deployments list` default to `--limit 20` when neither `--limit` nor `--full` is given; `--full` removes the cap.
+
+## Areas
+
+### `whoami`
+
+Report the authenticated identity.
+
+```
+$ wrangler-axi whoami
+identity:
+  email: a@b.c
+  accountId: acc1
+  accountName: Acme
+  loggedIn: yes
+```
+
+When logged out it reports `not authenticated` with help to run `wrangler login`.
+
+### `secrets`
+
+| Sub | Wrangler command | Notes |
+| --- | --- | --- |
+| `list [--name <worker>]` | `secret list --format json` | |
+| `put <key> [--name <worker>]` | `secret put <key> --quiet` | value read from stdin |
+| `delete <key> [--name <worker>] [--force]` | `secret delete` | |
+
+### `kv`
+
+| Sub | Wrangler command |
+| --- | --- |
+| `namespace list` | `kv namespace list` |
+| `namespace create <title>` | `kv namespace create` |
+| `namespace delete <id>` | `kv namespace delete` |
+| `namespace rename <old>` | `kv namespace rename` |
+| `key list --namespace-id <id>\|--binding <b> [--prefix]` | `kv key list` |
+| `key get <key> --namespace-id <id>\|--binding <b> [--text]` | `kv key get` |
+| `key put <key> <value\|--path <p>> --namespace-id <id>\|--binding <b>` | `kv key put` |
+
+### `d1`
+
+| Sub | Wrangler command | Notes |
+| --- | --- | --- |
+| `databases list` | `d1 list --json` | |
+| `query <database> --command <sql>\|--file <f> [--remote] [--yes] [--json]` | `d1 execute` | requires `--command` or `--file` |
+
+### `r2`
+
+| Sub | Wrangler command |
+| --- | --- |
+| `bucket list` | `r2 bucket list` (human output parsed) |
+| `bucket info <name>` | `r2 bucket info --json` |
+| `bucket create <name>` | `r2 bucket create` |
+| `bucket delete <name>` | `r2 bucket delete` |
+| `object get/put/delete <path>` | `r2 object ...` |
+
+### `pages`
+
+| Sub | Wrangler command | Notes |
+| --- | --- | --- |
+| `project list` | `pages project list --json` | |
+| `project create <name>` | `pages project create` | |
+| `project delete <name>` | `pages project delete` | |
+| `deployment list --project-name <n> [--environment <prod\|preview>]` | `pages deployment list --json` | |
+| `deployment create [dir] [--project-name <n>]` | `pages deployment create` | |
+| `deployment delete <id>` | `pages deployment delete` | |
+
+### `workers`
+
+| Sub | Wrangler command |
+| --- | --- |
+| `deploy [path]` | `workers deploy` |
+| `versions list [--name <worker>]` | `versions list --json` |
+| `deployments list [--name <worker>]` | `deployments list --json` |
+| `tail [worker] [--max-entries <n>] [--timeout <sec>]` | `tail --format json` (bounded stream) |
+
+`workers tail` streams live Worker logs with a hard bound and never leaves an
+interactive session behind: it stops at `--max-entries` (default 20) or
+`--timeout` seconds (default 15), then reports which bound fired. Pass-through
+filters `--search`, `--status`, `--method`, `--ip`, `--sampling-rate`,
+`--header`, and `--version-id` narrow the stream; `--json` returns the raw
+bounded lines instead of the compact TOON rows.
+
+`workers deploy` forwards the common single-value, repeatable, and boolean flags from `wrangler deploy`
+(`--name`, `--tag`, `--message`, `--compatibility-date`, `--assets`, `--outdir`, `--outfile`, `--tsconfig`,
+`--secrets-file`, `--dispatch-namespace`, `--compatibility-flags`, `--var`, `--define`, `--alias`, `--routes`,
+`--domains`, `--triggers`, `--no-bundle`, `--latest`, `--minify`, `--dry-run`, `--keep-vars`, `--strict`,
+`--autoconfig`).
+
+## Output
+
+Structured data is emitted as TOON on **stdout**.
+
+```
+$ wrangler-axi secrets list
+count: 1
+secrets[1]{name,type}:
+  API_KEY,text
+```
+
+Errors also go to stdout, in a structured form with an actionable suggestion, and map to a stable exit code:
+
+| Exit | Meaning |
+| --- | --- |
+| `0` | success (including no-ops and empty results) |
+| `1` | runtime error (e.g. not authenticated, not found) |
+| `2` | usage error (unknown flag, missing required flag, unknown area) |
+
+```
+$ wrangler-axi secrets list --bogus x
+error: unknown flag --bogus for `secrets list`
+help: valid flags for `secrets list`: --name, --limit (--help always allowed)
+```
+(exit 2)
+
+Unknown flags fail loudly and list the valid flags so the agent self-corrects in one step. `--help` is always
+allowed. No command prompts interactively — every operation is completable with flags alone.
+
+`wrangler-axi` never runs live mutations without being asked, and it never leaks raw dependency stack traces:
+wrangler errors are translated into the structured error format above.
+
+## Integrations
+
+`wrangler-axi` follows the AXI ambient-context pattern and offers two complementary ways to surface state to an
+agent at session start. Install whichever fits; you only need one.
+
+### Session hook (recommended for Claude Code, Codex, OpenCode)
+
+- **OpenCode**: managed plugin under `~/.config/opencode/plugins/` injecting a compact home-view dashboard
+  (bin path + description + live `whoami`/account state) as ambient system context.
+- **Claude Code**: `SessionStart` hook in `~/.claude/settings.json` (or project `.claude/settings.json`).
+- **Codex**: `SessionStart` hook in `~/.codex/hooks.json` with `[features].hooks = true`.
+
+### Installable skill
+
+A static skill that loads on demand when an agent recognizes a wrangler task — lower overhead, works in any
+agent that supports the Agent Skill format:
+
+```sh
+npx skills add masculinecache/wrangler-axi --skill wrangler-axi
+```
+
+The skill is generated from the same content as the home view so it stays in sync with the CLI.
+
+## Development
+
+```sh
+npm install
+npm run build       # tsc
+npm test            # vitest (all tests use an injected fake runner; no live APIs)
+```
+
+## License
+
+MIT

package/dist/bin/wrangler-axi.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/wrangler-axi.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { run } from "../src/cli.js";
+import { exitCodeForError } from "../src/errors.js";
+const argv = process.argv.slice(2);
+const cwd = process.cwd();
+run(argv, undefined, cwd)
+    .then(({ stdout, exitCode }) => {
+    if (stdout) {
+        process.stdout.write(stdout + "\n");
+    }
+    process.exitCode = exitCode;
+})
+    .catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`wrangler-axi: ${message}\n`);
+    process.exitCode = exitCodeForError(err);
+});

package/dist/src/args.d.ts

@@ -0,0 +1,19 @@
+/** Return the value for --flag (space or = form) without removing it. */
+export declare function getFlag(args: string[], name: string): string | undefined;
+/** Take and remove --flag value (space or = form); returns value or undefined. */
+export declare function takeFlag(args: string[], flag: string): string | undefined;
+export declare function hasFlag(args: string[], flag: string): boolean;
+/** True iff a boolean flag is present and not negated as `--no-<flag>`. */
+export declare function takeBoolFlag(args: string[], flag: string): boolean;
+export declare function getAllFlags(args: string[]): string[];
+export declare function takeAllFlags(args: string[], flags: string[]): string[];
+export declare function pushRepeated(base: string[], flag: string, values: string[]): void;
+/**
+ * Return the first non-flag positional token at/after startIndex.
+ * Skips `--` and token values that follow a flag.
+ */
+export declare function getPositional(args: string[], startIndex?: number): string | undefined;
+export declare function requireNumber(raw: string | undefined, label: string): number;
+export declare function takeNumber(args: string[], label: string): number | undefined;
+/** Throw VALIDATION_ERROR if a flag needs a value but none is present. */
+export declare function requireFlagValue(value: string | undefined, flag: string): string;

package/dist/src/args.js

@@ -0,0 +1,105 @@
+import { AxiError } from "axi-sdk-js";
+/**
+ * Split an argv token into its flag name and any inline `=value`, if present.
+ */
+function flagParts(arg) {
+    if (arg.startsWith("--")) {
+        const eq = arg.indexOf("=");
+        if (eq !== -1) {
+            return { name: arg.slice(0, eq), value: arg.slice(eq + 1) };
+        }
+    }
+    return { name: arg };
+}
+/** Return the value for --flag (space or = form) without removing it. */
+export function getFlag(args, name) {
+    for (let i = 0; i < args.length; i++) {
+        const { name: n, value } = flagParts(args[i]);
+        if (n === name) {
+            return value !== undefined ? value : args[i + 1];
+        }
+    }
+    return undefined;
+}
+/** Take and remove --flag value (space or = form); returns value or undefined. */
+export function takeFlag(args, flag) {
+    for (let i = 0; i < args.length; i++) {
+        const { name, value } = flagParts(args[i]);
+        if (name === flag) {
+            if (value !== undefined) {
+                args.splice(i, 1);
+                return value;
+            }
+            const val = args[i + 1];
+            args.splice(i, 2);
+            return val;
+        }
+    }
+    return undefined;
+}
+export function hasFlag(args, flag) {
+    return args.some((a) => flagParts(a).name === flag);
+}
+/** True iff a boolean flag is present and not negated as `--no-<flag>`. */
+export function takeBoolFlag(args, flag) {
+    const i = args.findIndex((a) => flagParts(a).name === flag);
+    if (i === -1) {
+        return false;
+    }
+    args.splice(i, 1);
+    return true;
+}
+export function getAllFlags(args) {
+    return args.filter((a) => a.startsWith("-")).map((a) => flagParts(a).name);
+}
+export function takeAllFlags(args, flags) {
+    const found = [];
+    for (let i = args.length - 1; i >= 0; i--) {
+        const { name } = flagParts(args[i]);
+        if (flags.includes(name)) {
+            found.unshift(args.splice(i, 1)[0]);
+        }
+    }
+    return found;
+}
+export function pushRepeated(base, flag, values) {
+    for (const v of values) {
+        base.push(flag, v);
+    }
+}
+/**
+ * Return the first non-flag positional token at/after startIndex.
+ * Skips `--` and token values that follow a flag.
+ */
+export function getPositional(args, startIndex = 0) {
+    for (let i = startIndex; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--") {
+            continue;
+        }
+        if (!a.startsWith("-")) {
+            return a;
+        }
+    }
+    return undefined;
+}
+export function requireNumber(raw, label) {
+    if (raw === undefined || raw === "" || Number.isNaN(Number(raw))) {
+        throw new AxiError(`${label} must be a number`, "VALIDATION_ERROR");
+    }
+    return Number(raw);
+}
+export function takeNumber(args, label) {
+    const raw = takeFlag(args, label);
+    if (raw === undefined) {
+        return undefined;
+    }
+    return requireNumber(raw, label);
+}
+/** Throw VALIDATION_ERROR if a flag needs a value but none is present. */
+export function requireFlagValue(value, flag) {
+    if (value === undefined || value === "") {
+        throw new AxiError(`${flag} requires a value`, "VALIDATION_ERROR");
+    }
+    return value;
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,27 @@
+import { type WranglerRunner } from "./wrangler.js";
+/** Shared context passed to every command. */
+export interface CommandContext {
+    runner: WranglerRunner;
+    account?: string;
+    cwd?: string;
+}
+/** A top-level area command (whoami, workers, ...). */
+export interface CommandArea {
+    name: string;
+    aliases?: string[];
+    description: string;
+    help: string[];
+    run(ctx: CommandContext, args: string[]): Promise<{
+        stdout: string;
+        exitCode: number;
+    }>;
+}
+export declare function topHelp(runnerNote: string): string;
+/**
+ * Dispatch one CLI invocation. Returns the text to write to stdout and the
+ * exit code. Does not process.exit — the caller (bin entry) decides that.
+ */
+export declare function run(argv: string[], runner?: WranglerRunner, cwd?: string): Promise<{
+    stdout: string;
+    exitCode: number;
+}>;

package/dist/src/cli.js

@@ -0,0 +1,101 @@
+import { AxiError, exitCodeForError } from "./errors.js";
+import { realRunner } from "./wrangler.js";
+import { renderError, renderHelp, renderOutput } from "./toon.js";
+import { VERSION } from "./version.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { workersCommand } from "./commands/workers.js";
+import { secretsCommand } from "./commands/secrets.js";
+import { kvCommand } from "./commands/kv.js";
+import { d1Command } from "./commands/d1.js";
+import { r2Command } from "./commands/r2.js";
+import { pagesCommand } from "./commands/pages.js";
+const areas = [
+    whoamiCommand,
+    workersCommand,
+    secretsCommand,
+    kvCommand,
+    d1Command,
+    r2Command,
+    pagesCommand,
+];
+function findArea(name) {
+    return areas.find((a) => a.name === name || (a.aliases?.includes(name) ?? false));
+}
+export function topHelp(runnerNote) {
+    const lines = areas.map((a) => `Run \`wrangler-axi ${a.name}\` — ${a.description}`);
+    lines.unshift("Run `wrangler-axi <area> <sub> [args]`");
+    lines.unshift("Global flags: --help, --version, --account <id|name>");
+    lines.push("Run `wrangler-axi <area> --help` for a specific area");
+    return renderHelp(lines);
+}
+/**
+ * Dispatch one CLI invocation. Returns the text to write to stdout and the
+ * exit code. Does not process.exit — the caller (bin entry) decides that.
+ */
+export async function run(argv, runner = realRunner, cwd) {
+    const ctx = { runner, cwd };
+    // Global --version / -v at top level.
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+        return {
+            stdout: renderOutput([
+                `bin: wrangler-axi`,
+                `description: Agent-ergonomic TOON wrapper around Cloudflare Wrangler`,
+                topHelp(""),
+            ]),
+            exitCode: 0,
+        };
+    }
+    if (argv[0] === "--version" || argv[0] === "-v") {
+        return { stdout: `wrangler-axi: ${VERSION}`, exitCode: 0 };
+    }
+    let args = argv.slice();
+    const areaName = args[0];
+    if (areaName === undefined) {
+        return { stdout: topHelp(""), exitCode: 0 };
+    }
+    const area = findArea(areaName);
+    if (!area) {
+        const err = new AxiError(`Unknown area "${areaName}"`, "VALIDATION_ERROR", [
+            `Valid areas: ${areas.map((a) => a.name).join(", ")}`,
+            "Run `wrangler-axi --help` for usage",
+        ]);
+        return { stdout: asError(err), exitCode: exitCodeForError(err) };
+    }
+    try {
+        // Pull --account off globally (any position).
+        const accountIdx = args.findIndex((a) => a === "--account" || a.startsWith("--account="));
+        if (accountIdx !== -1) {
+            const raw = args[accountIdx];
+            if (raw.startsWith("--account=")) {
+                ctx.account = raw.slice("--account=".length);
+                args.splice(accountIdx, 1);
+            }
+            else {
+                if (accountIdx + 1 >= args.length) {
+                    throw new AxiError("Missing value for --account flag", "VALIDATION_ERROR", ["Run `wrangler-axi --help` for usage"]);
+                }
+                ctx.account = args[accountIdx + 1];
+                args.splice(accountIdx, 2);
+            }
+        }
+        const rest = args.slice(1);
+        // Area-level --help (explicit only: help as the first arg after the area, e.g.
+        // `wrangler-axi workers --help`). A `--help` after a subcommand is dispatched
+        // to that subcommand so each has its own contextual help.
+        if (rest[0] === "--help" || rest[0] === "-h") {
+            return { stdout: renderHelp(area.help), exitCode: 0 };
+        }
+        const result = await area.run(ctx, rest);
+        return result;
+    }
+    catch (err) {
+        if (err instanceof AxiError) {
+            return { stdout: asError(err), exitCode: exitCodeForError(err) };
+        }
+        const unexpected = new AxiError(err instanceof Error ? err.message : String(err), "UNKNOWN");
+        return { stdout: asError(unexpected), exitCode: 1 };
+    }
+}
+function asError(err) {
+    return renderError(err.message, err.code, err.suggestions);
+}

package/dist/src/commands/d1.d.ts

@@ -0,0 +1,2 @@
+import type { CommandArea } from "../cli.js";
+export declare const d1Command: CommandArea;

package/dist/src/commands/d1.js

@@ -0,0 +1,149 @@
+import { AxiError } from "../errors.js";
+import { callWrangler, parseJson } from "../wrangler.js";
+import { takeAllFlags, takeFlag, takeNumber } from "../args.js";
+import { validateFlags, wantsHelp } from "../util.js";
+import { addExtraDefs, parseFields, } from "../fields.js";
+import { custom, field, renderDetail, renderHelp } from "../toon.js";
+import { renderListBlock } from "../list.js";
+const dbAvailable = {
+    created: { def: field("created_at") },
+    uuid: { def: field("uuid") },
+};
+const DATABASE_FLAGS = ["--json"];
+export const d1Command = {
+    name: "d1",
+    description: "manage D1 databases (list, query)",
+    help: [
+        "Usage: wrangler-axi d1 <databases|query> [args]",
+        "  databases list  — list D1 databases",
+        "  query <name>    — run a SQL command against a database",
+        "Example: wrangler-axi d1 databases list",
+        "Example: wrangler-axi d1 query my-db --command 'SELECT * FROM users'",
+    ],
+    async run(ctx, args) {
+        const sub = args[0];
+        if (sub === undefined || wantsHelp(args)) {
+            return { stdout: renderHelp(d1Command.help), exitCode: 0 };
+        }
+        const rest = args.slice(1);
+        switch (sub) {
+            case "databases":
+                return databases(ctx, rest);
+            case "query":
+                return query(ctx, rest);
+            default:
+                throw new AxiError(`Unknown d1 subcommand "${sub}"`, "VALIDATION_ERROR", [
+                    "Run `wrangler-axi d1 --help` for valid subcommands",
+                ]);
+        }
+    },
+};
+async function databases(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi d1 databases list [--fields] [--limit] [--full] [--json]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub !== undefined && sub !== "list" && !sub.startsWith("-")) {
+        throw new AxiError(`Unknown d1 databases subcommand "${sub}"`, "VALIDATION_ERROR", [
+            "Run `wrangler-axi d1 databases --help` for valid subcommands",
+        ]);
+    }
+    const listArgs = sub === "list" ? args.slice(1) : args;
+    const json = takeAllFlags(listArgs, ["--json"]).length > 0;
+    const full = takeAllFlags(listArgs, ["--full"]).length > 0;
+    validateFlags(listArgs, ["--fields", "--limit", "--full", "--json"], "d1 databases list");
+    const wArgs = ["d1", "list", "--json"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const limit = full ? undefined : takeNumber(listArgs, "--limit");
+    const fieldsArg = takeFlag(listArgs, "--fields");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout, exitCode: 0 };
+    }
+    const items = parseJson(stdout, "d1 databases");
+    const { extraDefs } = parseFields(fieldsArg, dbAvailable);
+    const schema = addExtraDefs({
+        name: field("name"),
+        id: field("id"),
+    }, extraDefs);
+    return {
+        stdout: renderListBlock({
+            noun: "databases",
+            items,
+            schema,
+            limit,
+            empty: "databases: no D1 databases found",
+            truncatedHint: "Run `wrangler-axi d1 databases list --json` for the full set",
+        }),
+        exitCode: 0,
+    };
+}
+async function query(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi d1 query <database> [--command <sql> | --file <path>]",
+                "Flags: --command <sql>, --file <path>, --local/--remote, --json",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const json = takeAllFlags(args, ["--json"]).length > 0;
+    validateFlags(args, ["--command", "--file", "--local", "--remote", "--yes", "--json"], "d1 query");
+    // Take value-consuming flags before extracting the positional db name.
+    const command = takeFlag(args, "--command");
+    const file = takeFlag(args, "--file");
+    const db = args.filter((a) => !a.startsWith("-"))[0];
+    if (!db) {
+        throw new AxiError("d1 query requires a database name", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi d1 query <database> --command <sql>|--file <f>",
+        ]);
+    }
+    if (!command && !file) {
+        throw new AxiError("d1 query requires --command or --file", "VALIDATION_ERROR", [
+            "Run `wrangler-axi d1 query --help` for usage",
+        ]);
+    }
+    const wArgs = ["d1", "execute", db];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    if (command) {
+        wArgs.push("--command", command);
+    }
+    else {
+        wArgs.push("--file", file);
+    }
+    const remote = takeAllFlags(args, ["--remote"]).length > 0;
+    if (remote) {
+        wArgs.push("--remote");
+    }
+    else {
+        wArgs.push("--local");
+    }
+    if (takeAllFlags(args, ["--yes"]).length > 0) {
+        wArgs.push("-y");
+    }
+    if (json) {
+        wArgs.push("--json");
+    }
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout, exitCode: 0 };
+    }
+    return {
+        stdout: renderDetail("query", { database: db, status: "executed" }, {
+            database: custom((d) => d.database),
+            status: custom((d) => d.status),
+            output: custom(() => stdout.trim() || "(no rows)"),
+        }),
+        exitCode: 0,
+    };
+}

package/dist/src/commands/kv.d.ts

@@ -0,0 +1,2 @@
+import type { CommandArea } from "../cli.js";
+export declare const kvCommand: CommandArea;