@masculinecache/wrangler-axi 0.1.0

package/dist/src/commands/pages.js

@@ -0,0 +1,337 @@
+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, relativeTime, renderDetail, renderHelp } from "../toon.js";
+import { renderListBlock } from "../list.js";
+const projectAvailable = {
+    created: { def: relativeTime("created_on", "created") },
+    domains: { def: field("domains") },
+};
+const deploymentAvailable = {
+    created: { def: relativeTime("created_on", "created") },
+    environment: { def: field("environment") },
+    latest: { def: field("latest_stage") },
+};
+export const pagesCommand = {
+    name: "pages",
+    description: "manage Cloudflare Pages projects and deployments",
+    help: [
+        "Usage: wrangler-axi pages <project|deployment> <sub> [args]",
+        "  project    — list/create/delete Pages projects",
+        "  deployment — list Pages deployments",
+        "Example: wrangler-axi pages project list",
+        "Example: wrangler-axi pages deployment list --project-name my-site",
+    ],
+    async run(ctx, args) {
+        const sub = args[0];
+        if (sub === undefined || wantsHelp(args)) {
+            return { stdout: renderHelp(pagesCommand.help), exitCode: 0 };
+        }
+        const rest = args.slice(1);
+        switch (sub) {
+            case "project":
+                return project(ctx, rest);
+            case "deployment":
+                return deployment(ctx, rest);
+            default:
+                throw new AxiError(`Unknown pages subcommand "${sub}"`, "VALIDATION_ERROR", [
+                    "Run `wrangler-axi pages --help` for valid subcommands",
+                ]);
+        }
+    },
+};
+async function project(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages project <list|create|delete> [args]",
+                "  list                 — list Pages projects",
+                "  create <name>        — create a project",
+                "  delete <name>        — delete a project",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub === undefined || sub.startsWith("-")) {
+        throw new AxiError("pages project requires a subcommand", "VALIDATION_ERROR", [
+            "Run `wrangler-axi pages project --help` for valid subcommands",
+        ]);
+    }
+    const rest = args.slice(1);
+    switch (sub) {
+        case "list":
+            return projectList(ctx, rest);
+        case "create":
+            return projectCreate(ctx, rest);
+        case "delete":
+            return projectDelete(ctx, rest);
+        default:
+            throw new AxiError(`Unknown pages project subcommand "${sub}"`, "VALIDATION_ERROR", [
+                "Run `wrangler-axi pages project --help` for valid subcommands",
+            ]);
+    }
+}
+async function projectList(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages project list [--fields] [--limit] [--full] [--json]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const json = takeAllFlags(args, ["--json"]).length > 0;
+    const full = takeAllFlags(args, ["--full"]).length > 0;
+    validateFlags(args, ["--fields", "--limit", "--full", "--json"], "pages project list");
+    const wArgs = ["pages", "project", "list", "--json"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const limit = full ? undefined : takeNumber(args, "--limit");
+    const fieldsArg = takeFlag(args, "--fields");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout, exitCode: 0 };
+    }
+    const items = parseJson(stdout, "pages projects");
+    const { extraDefs } = parseFields(fieldsArg, projectAvailable);
+    const schema = addExtraDefs({
+        name: field("name"),
+        domains: field("domains"),
+    }, extraDefs);
+    return {
+        stdout: renderListBlock({
+            noun: "projects",
+            items,
+            schema,
+            limit,
+            empty: "projects: no Pages projects found",
+            truncatedHint: "Run `wrangler-axi pages project list --json` for the full set",
+        }),
+        exitCode: 0,
+    };
+}
+async function projectCreate(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages project create <name> [--json]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, ["--json"], "pages project create");
+    // wrangler's `pages project create` rejects --json and prints human output
+    // only, so --json is a wrapper-side escape hatch here.
+    const json = takeAllFlags(args, ["--json"]).length > 0;
+    const name = args.filter((a) => !a.startsWith("-"))[0];
+    if (!name) {
+        throw new AxiError("pages project create requires a project name", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi pages project create <name>",
+        ]);
+    }
+    const wArgs = ["pages", "project", "create", name];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout: JSON.stringify({ name, status: "created" }, null, 2), exitCode: 0 };
+    }
+    return {
+        stdout: renderDetail("project", { name, status: "created" }, {
+            name: custom((d) => d.name),
+            status: custom((d) => d.status),
+        }),
+        exitCode: 0,
+    };
+}
+async function projectDelete(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages project delete <name> [--force]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, ["--force"], "pages project delete");
+    const name = args.filter((a) => !a.startsWith("-"))[0];
+    if (!name) {
+        throw new AxiError("pages project delete requires a project name", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi pages project delete <name>",
+        ]);
+    }
+    const wArgs = ["pages", "project", "delete", name];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    if (takeAllFlags(args, ["--force"]).length > 0) {
+        wArgs.push("-f");
+    }
+    await callWrangler(ctx.runner, wArgs);
+    return {
+        stdout: renderDetail("project", { name, status: "deleted" }, {
+            name: custom((d) => d.name),
+            status: custom((d) => d.status),
+        }),
+        exitCode: 0,
+    };
+}
+async function deployment(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages deployment <list|create|delete> [args]",
+                "  list   — list deployments for a project",
+                "  create [dir] — deploy a directory",
+                "  delete <id>  — delete a deployment",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub === undefined || sub.startsWith("-")) {
+        throw new AxiError("pages deployment requires a subcommand", "VALIDATION_ERROR", [
+            "Run `wrangler-axi pages deployment --help` for valid subcommands",
+        ]);
+    }
+    const rest = args.slice(1);
+    switch (sub) {
+        case "list":
+            return deploymentList(ctx, rest);
+        case "create":
+            return deploymentCreate(ctx, rest);
+        case "delete":
+            return deploymentDelete(ctx, rest);
+        default:
+            throw new AxiError(`Unknown pages deployment subcommand "${sub}"`, "VALIDATION_ERROR", [
+                "Run `wrangler-axi pages deployment --help` for valid subcommands",
+            ]);
+    }
+}
+async function deploymentList(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages deployment list --project-name <name> [--environment production|preview] [--fields] [--limit] [--full] [--json]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const json = takeAllFlags(args, ["--json"]).length > 0;
+    const full = takeAllFlags(args, ["--full"]).length > 0;
+    validateFlags(args, ["--project-name", "--environment", "--fields", "--limit", "--full", "--json"], "pages deployment list");
+    const projectName = takeFlag(args, "--project-name");
+    if (!projectName) {
+        throw new AxiError("pages deployment list requires --project-name", "VALIDATION_ERROR", [
+            "Run `wrangler-axi pages deployment list --help` for usage",
+        ]);
+    }
+    const wArgs = ["pages", "deployment", "list", "--project-name", projectName];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const env = takeFlag(args, "--environment");
+    if (env) {
+        wArgs.push("--environment", env);
+    }
+    wArgs.push("--json");
+    const limit = full ? undefined : takeNumber(args, "--limit");
+    const fieldsArg = takeFlag(args, "--fields");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (json) {
+        return { stdout, exitCode: 0 };
+    }
+    const items = parseJson(stdout, "pages deployments");
+    const { extraDefs } = parseFields(fieldsArg, deploymentAvailable);
+    const schema = addExtraDefs({
+        id: field("id"),
+        url: field("url"),
+        created: relativeTime("created_on", "created"),
+    }, extraDefs);
+    return {
+        stdout: renderListBlock({
+            noun: "deployments",
+            items,
+            schema,
+            limit,
+            empty: "deployments: no deployments found for this project",
+            truncatedHint: "Run `wrangler-axi pages deployment list --project-name <name> --json` for the full set",
+        }),
+        exitCode: 0,
+    };
+}
+async function deploymentCreate(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages deployment create [directory] [--project-name <name>]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, ["--project-name"], "pages deployment create");
+    // Take value-consuming flags before extracting the positional directory.
+    const projectName = takeFlag(args, "--project-name");
+    const dir = args.filter((a) => !a.startsWith("-"))[0];
+    const wArgs = ["pages", "deployment", "create"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    if (dir) {
+        wArgs.push(dir);
+    }
+    if (projectName) {
+        wArgs.push("--project-name", projectName);
+    }
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    return {
+        stdout: renderDetail("deployment", { project: projectName ?? "(default)", status: "deployed" }, {
+            project: custom((d) => d.project),
+            status: custom((d) => d.status),
+            output: custom(() => stdout.trim() || "(no output)"),
+        }),
+        exitCode: 0,
+    };
+}
+async function deploymentDelete(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi pages deployment delete <deployment-id> [--project-name <name>] [--force]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, ["--project-name", "--force"], "pages deployment delete");
+    // Take value-consuming flags before extracting the positional id.
+    const projectName = takeFlag(args, "--project-name");
+    const id = args.filter((a) => !a.startsWith("-"))[0];
+    if (!id) {
+        throw new AxiError("pages deployment delete requires a deployment id", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi pages deployment delete <id>",
+        ]);
+    }
+    const wArgs = ["pages", "deployment", "delete", id];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    if (projectName) {
+        wArgs.push("--project-name", projectName);
+    }
+    if (takeAllFlags(args, ["--force"]).length > 0) {
+        wArgs.push("-f");
+    }
+    await callWrangler(ctx.runner, wArgs);
+    return {
+        stdout: renderDetail("deployment", { id, status: "deleted" }, {
+            id: custom((d) => d.id),
+            status: custom((d) => d.status),
+        }),
+        exitCode: 0,
+    };
+}

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

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

package/dist/src/commands/r2.js

@@ -0,0 +1,289 @@
+import { AxiError, stripAnsi } 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 bucketAvailable = {
+    created: { def: field("creation_date") },
+};
+/**
+ * Parse wrangler's human `r2 bucket list` output. Wrangler 4.x rejects
+ * `--json` for this command; it prints one `label: value` block per bucket
+ * (name, creation_date), optionally ANSI-colored when attached to a TTY.
+ */
+function parseBucketListOutput(stdout) {
+    const clean = stripAnsi(stdout);
+    const buckets = [];
+    let current = {};
+    for (const line of clean.split("\n")) {
+        const m = /^(name|creation_date):\s*(.*)$/.exec(line);
+        if (!m) {
+            continue;
+        }
+        if (m[1] === "name") {
+            if (current.name !== undefined) {
+                buckets.push(current);
+            }
+            current = { name: m[2] };
+        }
+        else if (current.name !== undefined) {
+            current.creation_date = m[2];
+        }
+    }
+    if (current.name !== undefined) {
+        buckets.push(current);
+    }
+    return buckets;
+}
+export const r2Command = {
+    name: "r2",
+    description: "manage R2 buckets (list, info, object pass-through)",
+    help: [
+        "Usage: wrangler-axi r2 <bucket|object> <sub> [args]",
+        "  bucket list / info <name>   — list or inspect R2 buckets",
+        "  object get/put/delete <path> — pass-through object operations",
+        "Note: wrangler has no `r2 object list`; listing objects is not supported.",
+        "Example: wrangler-axi r2 bucket list",
+        "Example: wrangler-axi r2 bucket info my-bucket",
+    ],
+    async run(ctx, args) {
+        const sub = args[0];
+        if (sub === undefined || wantsHelp(args)) {
+            return { stdout: renderHelp(r2Command.help), exitCode: 0 };
+        }
+        const rest = args.slice(1);
+        switch (sub) {
+            case "bucket":
+                return bucket(ctx, rest);
+            case "object":
+                return object(ctx, rest);
+            default:
+                throw new AxiError(`Unknown r2 subcommand "${sub}"`, "VALIDATION_ERROR", [
+                    "Run `wrangler-axi r2 --help` for valid subcommands",
+                ]);
+        }
+    },
+};
+async function bucket(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi r2 bucket <list|info|create|delete> [args]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub === undefined || sub.startsWith("-")) {
+        throw new AxiError("r2 bucket requires a subcommand", "VALIDATION_ERROR", [
+            "Run `wrangler-axi r2 bucket --help` for valid subcommands",
+        ]);
+    }
+    const rest = args.slice(1);
+    switch (sub) {
+        case "list":
+            return bucketList(ctx, rest);
+        case "info":
+            return bucketInfo(ctx, rest);
+        case "create":
+            return bucketCreate(ctx, rest);
+        case "delete":
+            return bucketDelete(ctx, rest);
+        default:
+            throw new AxiError(`Unknown r2 bucket subcommand "${sub}"`, "VALIDATION_ERROR", [
+                "Run `wrangler-axi r2 bucket --help` for valid subcommands",
+            ]);
+    }
+}
+async function bucketList(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi r2 bucket list [--fields] [--limit] [--full] [--json]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const json = takeAllFlags(args, ["--json"]).length > 0;
+    const full = takeAllFlags(args, ["--full"]).length > 0;
+    validateFlags(args, ["--fields", "--limit", "--full", "--json"], "r2 bucket list");
+    // wrangler's `r2 bucket list` rejects --json; parse its human output and
+    // provide the wrapper-side --json escape hatch from the parsed items.
+    const wArgs = ["r2", "bucket", "list"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const limit = full ? undefined : takeNumber(args, "--limit");
+    const fieldsArg = takeFlag(args, "--fields");
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    const items = parseBucketListOutput(stdout);
+    if (json) {
+        return { stdout: JSON.stringify(items, null, 2), exitCode: 0 };
+    }
+    const { extraDefs } = parseFields(fieldsArg, bucketAvailable);
+    const schema = addExtraDefs({
+        name: field("name"),
+        created: field("creation_date"),
+    }, extraDefs);
+    return {
+        stdout: renderListBlock({
+            noun: "buckets",
+            items,
+            schema,
+            limit,
+            empty: "buckets: no R2 buckets found",
+            truncatedHint: "Run `wrangler-axi r2 bucket list --json` for the full set",
+        }),
+        exitCode: 0,
+    };
+}
+async function bucketInfo(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi r2 bucket info <name>",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, [], "r2 bucket info");
+    const name = args.filter((a) => !a.startsWith("-"))[0];
+    if (!name) {
+        throw new AxiError("r2 bucket info requires a bucket name", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi r2 bucket info <name>",
+        ]);
+    }
+    const wArgs = ["r2", "bucket", "info", name, "--json"];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    const data = parseJson(stdout, "r2 bucket");
+    return {
+        stdout: renderDetail("bucket", data, {
+            name: custom((b) => b.name ?? name),
+            location: custom((b) => b.location ?? "unknown"),
+            storage_class: custom((b) => b.storage_class ?? "unknown"),
+            size: custom((b) => b.size ?? 0),
+        }),
+        exitCode: 0,
+    };
+}
+async function bucketCreate(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi r2 bucket create <name>",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, [], "r2 bucket create");
+    const name = args.filter((a) => !a.startsWith("-"))[0];
+    if (!name) {
+        throw new AxiError("r2 bucket create requires a bucket name", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi r2 bucket create <name>",
+        ]);
+    }
+    const wArgs = ["r2", "bucket", "create", name];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    await callWrangler(ctx.runner, wArgs);
+    return {
+        stdout: renderDetail("bucket", { name, status: "created" }, {
+            name: custom((d) => d.name),
+            status: custom((d) => d.status),
+        }),
+        exitCode: 0,
+    };
+}
+async function bucketDelete(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi r2 bucket delete <name> [--force]",
+            ]),
+            exitCode: 0,
+        };
+    }
+    validateFlags(args, ["--force"], "r2 bucket delete");
+    const name = args.filter((a) => !a.startsWith("-"))[0];
+    if (!name) {
+        throw new AxiError("r2 bucket delete requires a bucket name", "VALIDATION_ERROR", [
+            "Usage: wrangler-axi r2 bucket delete <name>",
+        ]);
+    }
+    const wArgs = ["r2", "bucket", "delete", name];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    if (takeAllFlags(args, ["--force"]).length > 0) {
+        wArgs.push("-f");
+    }
+    await callWrangler(ctx.runner, wArgs);
+    return {
+        stdout: renderDetail("bucket", { name, status: "deleted" }, {
+            name: custom((d) => d.name),
+            status: custom((d) => d.status),
+        }),
+        exitCode: 0,
+    };
+}
+async function object(ctx, args) {
+    if (wantsHelp(args)) {
+        return {
+            stdout: renderHelp([
+                "Usage: wrangler-axi r2 object <get|put|delete> <objectPath>",
+                "Pass-through to wrangler r2 object. Use --binding or --bucket to target.",
+                "Note: listing objects is not supported (wrangler has no r2 object list).",
+            ]),
+            exitCode: 0,
+        };
+    }
+    const sub = args[0];
+    if (sub === undefined || sub.startsWith("-")) {
+        throw new AxiError("r2 object requires a subcommand", "VALIDATION_ERROR", [
+            "Run `wrangler-axi r2 object --help` for valid subcommands",
+        ]);
+    }
+    if (sub === "list") {
+        throw new AxiError("r2 object list is not supported — wrangler has no native object listing command", "VALIDATION_ERROR", ["Use `wrangler-axi r2 bucket info <name>` to inspect a bucket"]);
+    }
+    const rest = args.slice(1);
+    // Take value-consuming flags before extracting the positional object path.
+    const flagValues = {};
+    for (const f of ["--binding", "--bucket", "--text", "--file", "--path", "--ttl"]) {
+        flagValues[f] = takeFlag(rest, f);
+    }
+    const objectPath = rest.filter((a) => !a.startsWith("-"))[0];
+    if (!objectPath) {
+        throw new AxiError(`r2 object ${sub} requires an object path`, "VALIDATION_ERROR", [
+            `Usage: wrangler-axi r2 object ${sub} <path>`,
+        ]);
+    }
+    validateFlags(rest, ["--binding", "--bucket", "--text", "--file", "--path", "--json", "--ttl"], `r2 object ${sub}`);
+    const wArgs = ["r2", "object", sub, objectPath];
+    if (ctx.account) {
+        wArgs.push("--account", ctx.account);
+    }
+    for (const [f, v] of Object.entries(flagValues)) {
+        if (v !== undefined) {
+            wArgs.push(f, v);
+        }
+    }
+    const { stdout } = await callWrangler(ctx.runner, wArgs);
+    if (takeAllFlags(rest, ["--json"]).length > 0) {
+        return { stdout, exitCode: 0 };
+    }
+    return {
+        stdout: renderDetail("object", { path: objectPath, status: sub }, {
+            path: custom((d) => d.path),
+            status: custom((d) => d.status),
+            output: custom(() => stdout.trim() || "(no output)"),
+        }),
+        exitCode: 0,
+    };
+}

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

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