@masculinecache/warp-axi 0.0.0-stage → 0.1.1

package/dist/src/commands/target.js

@@ -0,0 +1,83 @@
+import { callWarpLenient } from "../warp.js";
+import { hasFlag } from "../args.js";
+import { renderError, renderOutput, field } from "../toon.js";
+import { renderListBlock } from "../list.js";
+const targetSubcommands = ["list"];
+const targetSchema = {
+    name: field("name"),
+    type: field("type"),
+    id: field("target_id"),
+};
+function renderTargetHelp() {
+    return [
+        `usage: warp-axi target <subcommand> [flags]`,
+        ``,
+        `Subcommands:`,
+        `  list                 List infrastructure targets`,
+        ``,
+        `Flags:`,
+        `  --json               Raw JSON output`,
+        `  --help               Show this help`,
+    ];
+}
+export const targetArea = {
+    name: "target",
+    description: "Infrastructure target management",
+    help: renderTargetHelp(),
+    async run(ctx, args) {
+        if (args.length === 0) {
+            return { stdout: renderTargetHelp().join("\n"), exitCode: 0 };
+        }
+        const [sub, ...rest] = args;
+        if (!targetSubcommands.includes(sub)) {
+            return {
+                stdout: renderError(`unknown target subcommand '${sub}'`, "VALIDATION_ERROR", [
+                    `Available: ${targetSubcommands.join(", ")}`,
+                ]),
+                exitCode: 1,
+            };
+        }
+        const useJson = hasFlag(rest, "--json");
+        if (sub === "list") {
+            const warpArgs = ["target", "list"];
+            if (useJson)
+                warpArgs.push("--json");
+            try {
+                const result = await callWarpLenient(ctx.runner, warpArgs);
+                if (useJson)
+                    return { stdout: result.stdout.trim(), exitCode: 0 };
+                const lines = result.stdout.trim().split("\n").filter((l) => l.trim());
+                if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+                    return {
+                        stdout: renderOutput([`targets: no infrastructure targets configured`]),
+                        exitCode: 0,
+                    };
+                }
+                const items = lines.map((line) => {
+                    const parts = line.split(/\s{2,}/);
+                    return {
+                        name: parts[0] ?? "",
+                        type: parts[1] ?? "",
+                        target_id: parts[2] ?? "",
+                    };
+                });
+                return {
+                    stdout: renderOutput([
+                        renderListBlock({
+                            noun: "targets",
+                            items,
+                            schema: targetSchema,
+                            empty: "targets: no infrastructure targets configured",
+                        }),
+                    ]),
+                    exitCode: 0,
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { stdout: renderError(message, "UNKNOWN"), exitCode: 1 };
+            }
+        }
+        return { stdout: renderTargetHelp().join("\n"), exitCode: 0 };
+    },
+};

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

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

package/dist/src/commands/tunnel.js

@@ -0,0 +1,112 @@
+import { callWarp, callWarpLenient } from "../warp.js";
+import { takeBoolFlag } from "../args.js";
+import { wantsHelp, validateFlags } from "../util.js";
+import { renderDetail, renderHelp, field, custom } from "../toon.js";
+import { renderListBlock } from "../list.js";
+const TUNNEL_SCHEMA = {
+    cidr: custom((item) => {
+        const cidr = item.cidr ?? item.address;
+        return cidr ? String(cidr) : String(item.route ?? "unknown");
+    }),
+    description: field("description"),
+    type: field("type"),
+    via: field("via"),
+};
+const STATS_SCHEMA = {
+    rx: field("rx"),
+    tx: field("tx"),
+};
+const RAW_SCHEMA = {
+    raw: field("raw"),
+};
+function parseTunnelDump(text) {
+    try {
+        const data = JSON.parse(text);
+        if (Array.isArray(data))
+            return data;
+        if (data.routes)
+            return data.routes;
+        if (data.tunnels)
+            return data.tunnels;
+        return [data];
+    }
+    catch {
+        const items = [];
+        let current = {};
+        for (const line of text.split("\n")) {
+            const m = line.match(/^\s*(.+?):\s+(.+)$/);
+            if (m) {
+                current[m[1].trim().toLowerCase().replace(/\s+/g, "_")] = m[2].trim();
+            }
+            else if (line.trim() === "" && Object.keys(current).length > 0) {
+                items.push(current);
+                current = {};
+            }
+        }
+        if (Object.keys(current).length > 0)
+            items.push(current);
+        return items;
+    }
+}
+export const tunnelArea = {
+    name: "tunnel",
+    aliases: ["split-tunnel", "routes"],
+    description: "Show split tunnel configuration and routes",
+    help: [
+        "usage: warp-axi tunnel <subcommand> [options]",
+        "",
+        "Subcommands:",
+        "  dump        List all split tunnel routes",
+        "  stats       Show tunnel traffic statistics",
+        "",
+        "Flags:",
+        "  --json      Use warp-cli --json for structured output",
+    ],
+    async run(ctx, args) {
+        if (wantsHelp(args))
+            return { stdout: renderHelp(this.help), exitCode: 0 };
+        const sub = args.shift();
+        switch (sub) {
+            case "dump":
+                return tunnelDump(ctx, args);
+            case "stats":
+                return tunnelStats(ctx, args);
+            default:
+                return { stdout: renderHelp(this.help), exitCode: 0 };
+        }
+    },
+};
+async function tunnelDump(ctx, args) {
+    const useJson = takeBoolFlag(args, "--json");
+    validateFlags(args, ["--json"], "tunnel dump");
+    const warpArgs = ["tunnel", "dump"];
+    if (useJson)
+        warpArgs.push("--json");
+    const result = await callWarpLenient(ctx.runner, warpArgs);
+    const items = parseTunnelDump(result.stdout);
+    return {
+        stdout: renderListBlock({
+            noun: "routes",
+            items,
+            schema: TUNNEL_SCHEMA,
+            empty: "routes: no split tunnel routes configured",
+            truncatedHint: "Run `warp-axi tunnel dump --json` for the full set",
+        }),
+        exitCode: 0,
+    };
+}
+async function tunnelStats(ctx, args) {
+    const useJson = takeBoolFlag(args, "--json");
+    validateFlags(args, ["--json"], "tunnel stats");
+    const warpArgs = ["tunnel", "stats"];
+    if (useJson)
+        warpArgs.push("--json");
+    const result = await callWarp(ctx.runner, warpArgs);
+    try {
+        const data = JSON.parse(result.stdout);
+        return { stdout: renderDetail("stats", data, STATS_SCHEMA), exitCode: 0 };
+    }
+    catch {
+        return { stdout: renderDetail("stats", { raw: result.stdout }, RAW_SCHEMA), exitCode: 0 };
+    }
+}

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

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

package/dist/src/commands/vnet.js

@@ -0,0 +1,106 @@
+import { callWarp, callWarpLenient } from "../warp.js";
+import { hasFlag } from "../args.js";
+import { renderError, renderOutput, field, boolYesNo } from "../toon.js";
+import { renderListBlock } from "../list.js";
+const vnetSubcommands = ["add", "remove", "list"];
+const vnetSchema = {
+    name: field("name"),
+    id: field("vnet_id"),
+    is_default: boolYesNo("is_default"),
+};
+function renderVnetHelp() {
+    return [
+        `usage: warp-axi vnet <subcommand> [flags]`,
+        ``,
+        `Subcommands:`,
+        `  add <name>           Create a virtual network`,
+        `  remove <name>        Remove a virtual network`,
+        `  list                 List virtual networks`,
+        ``,
+        `Flags:`,
+        `  --json               Raw JSON output`,
+        `  --help               Show this help`,
+    ];
+}
+export const vnetArea = {
+    name: "vnet",
+    description: "Virtual network management",
+    help: renderVnetHelp(),
+    async run(ctx, args) {
+        if (args.length === 0) {
+            return { stdout: renderVnetHelp().join("\n"), exitCode: 0 };
+        }
+        const [sub, ...rest] = args;
+        if (!vnetSubcommands.includes(sub)) {
+            return {
+                stdout: renderError(`unknown vnet subcommand '${sub}'`, "VALIDATION_ERROR", [
+                    `Available: ${vnetSubcommands.join(", ")}`,
+                ]),
+                exitCode: 1,
+            };
+        }
+        const useJson = hasFlag(rest, "--json");
+        if (sub === "list") {
+            const warpArgs = ["virtual-network", "list"];
+            if (useJson)
+                warpArgs.push("--json");
+            try {
+                const result = await callWarpLenient(ctx.runner, warpArgs);
+                if (useJson)
+                    return { stdout: result.stdout.trim(), exitCode: 0 };
+                const lines = result.stdout.trim().split("\n").filter((l) => l.trim());
+                if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+                    return {
+                        stdout: renderOutput([`vnets: no virtual networks configured`]),
+                        exitCode: 0,
+                    };
+                }
+                const items = lines.map((line) => {
+                    const parts = line.split(/\s{2,}/);
+                    return {
+                        name: parts[0] ?? "",
+                        vnet_id: parts[1] ?? "",
+                        is_default: parts[2]?.toLowerCase() === "true" || parts[2]?.toLowerCase() === "yes",
+                    };
+                });
+                return {
+                    stdout: renderOutput([
+                        renderListBlock({
+                            noun: "vnets",
+                            items,
+                            schema: vnetSchema,
+                            empty: "vnets: no virtual networks configured",
+                        }),
+                    ]),
+                    exitCode: 0,
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { stdout: renderError(message, "UNKNOWN"), exitCode: 1 };
+            }
+        }
+        if (sub === "add" || sub === "remove") {
+            const positionalArgs = rest.filter((a) => !a.startsWith("--"));
+            const name = positionalArgs[0];
+            if (!name) {
+                return {
+                    stdout: renderError(`vnet ${sub} requires a name`, "VALIDATION_ERROR", [
+                        `Usage: warp-axi vnet ${sub} <name>`,
+                    ]),
+                    exitCode: 1,
+                };
+            }
+            const warpArgs = ["virtual-network", sub, name];
+            try {
+                const result = await callWarp(ctx.runner, warpArgs);
+                return { stdout: result.stdout.trim(), exitCode: 0 };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { stdout: renderError(message, "UNKNOWN"), exitCode: 1 };
+            }
+        }
+        return { stdout: renderVnetHelp().join("\n"), exitCode: 0 };
+    },
+};

package/dist/src/errors.d.ts

@@ -0,0 +1,2 @@
+export { AxiError, exitCodeForError } from "axi-sdk-js";
+export { mapWarpError } from "./warp.js";

package/dist/src/errors.js

@@ -0,0 +1,2 @@
+export { AxiError, exitCodeForError } from "axi-sdk-js";
+export { mapWarpError } from "./warp.js";

package/dist/src/format.d.ts

@@ -0,0 +1,8 @@
+export interface CountLineOptions {
+    count: number;
+    limit?: number;
+    totalCount?: number;
+    apiLimitHit?: boolean;
+    displayLimit?: number;
+}
+export declare function formatCountLine(opts: CountLineOptions): string;

package/dist/src/format.js

@@ -0,0 +1,16 @@
+export function formatCountLine(opts) {
+    const { count, limit, totalCount, apiLimitHit, displayLimit } = opts;
+    if (apiLimitHit) {
+        return `count: ${count}+ (api limit reached)`;
+    }
+    if (totalCount !== undefined && totalCount >= count) {
+        return `count: ${count} of ${totalCount} total`;
+    }
+    if (displayLimit !== undefined && count > displayLimit) {
+        return `count: ${count} (showing first ${displayLimit})`;
+    }
+    if (limit !== undefined && count === limit && count > 0) {
+        return `count: ${count} (showing first ${count})`;
+    }
+    return `count: ${count}`;
+}

package/dist/src/list.d.ts

@@ -0,0 +1,11 @@
+import { type Schema } from "./toon.js";
+export interface ListBlockOptions {
+    noun: string;
+    items: unknown[];
+    schema: Schema;
+    limit?: number;
+    totalCount?: number;
+    empty: string;
+    truncatedHint?: string;
+}
+export declare function renderListBlock(opts: ListBlockOptions): string;

package/dist/src/list.js

@@ -0,0 +1,17 @@
+import { formatCountLine } from "./format.js";
+import { renderHelp, renderList } from "./toon.js";
+export function renderListBlock(opts) {
+    const { noun, items, schema, limit, totalCount, empty, truncatedHint } = opts;
+    const display = limit !== undefined ? items.slice(0, limit) : items;
+    const total = totalCount ?? items.length;
+    const countLine = formatCountLine({ count: total, limit, displayLimit: display.length });
+    if (items.length === 0) {
+        return [countLine, empty].filter(Boolean).join("\n");
+    }
+    const blocks = [countLine];
+    blocks.push(renderList(`${noun}[${display.length}]`, display, schema));
+    if (truncatedHint && limit !== undefined && items.length > limit) {
+        blocks.push(renderHelp([truncatedHint]));
+    }
+    return blocks.filter(Boolean).join("\n");
+}

package/dist/src/stdin.d.ts

@@ -0,0 +1,2 @@
+export declare function readStdin(): Promise<string>;
+export declare function isStdinTTY(): boolean;

package/dist/src/stdin.js

@@ -0,0 +1,12 @@
+export async function readStdin() {
+    if (isStdinTTY())
+        return "";
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString().trim();
+}
+export function isStdinTTY() {
+    return process.stdin.isTTY ?? false;
+}

package/dist/src/toon.d.ts

@@ -0,0 +1,24 @@
+import { encode } from "@toon-format/toon";
+export { encode };
+export interface FieldDef {
+    render: (item: any) => any;
+    as?: string;
+}
+export interface Schema {
+    [outputKey: string]: FieldDef;
+}
+export declare function field(key: string, as?: string): FieldDef;
+export declare function pluck(key: string, subkey: string, as?: string): FieldDef;
+export declare function joinArray(key: string, subkey: string, as?: string, empty?: string): FieldDef;
+export declare function relativeTime(key: string, as?: string): FieldDef;
+export declare function boolYesNo(key: string, as?: string): FieldDef;
+export declare function mapEnum(key: string, map: Record<string, string>, fallback?: string, as?: string): FieldDef;
+export declare function lower(key: string, as?: string): FieldDef;
+export declare function checksSummary(key: string, as?: string): FieldDef;
+export declare function custom(fn: (item: any) => any, as?: string): FieldDef;
+export declare function extract(item: any, schema: Schema): Record<string, unknown>;
+export declare function renderList(label: string, items: unknown[], schema: Schema): string;
+export declare function renderDetail(label: string, item: unknown, schema: Schema): string;
+export declare function renderHelp(lines: string[]): string;
+export declare function renderError(message: string, code: string, suggestions?: string[]): string;
+export declare function renderOutput(blocks: Array<string | undefined>): string;

package/dist/src/toon.js

@@ -0,0 +1,140 @@
+import { encode } from "@toon-format/toon";
+export { encode };
+function formatRelativeTime(iso) {
+    if (!iso)
+        return "unknown";
+    const then = new Date(iso).getTime();
+    if (Number.isNaN(then))
+        return "unknown";
+    const diffSec = Math.floor((Date.now() - then) / 1000);
+    if (diffSec < 60)
+        return "just now";
+    const min = Math.floor(diffSec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hour = Math.floor(min / 60);
+    if (hour < 24)
+        return `${hour}h ago`;
+    const day = Math.floor(hour / 24);
+    if (day < 30)
+        return `${day}d ago`;
+    const month = Math.floor(day / 30);
+    if (month < 12)
+        return `${month}mo ago`;
+    return `${Math.floor(month / 12)}y ago`;
+}
+function rec(item) {
+    return (item ?? {});
+}
+export function field(key, as) {
+    return {
+        render: (item) => rec(item)[key] ?? null,
+        ...(as ? { as } : {}),
+    };
+}
+export function pluck(key, subkey, as) {
+    return {
+        render: (item) => {
+            const val = rec(item)[key];
+            if (val && typeof val === "object")
+                return rec(val)[subkey] ?? null;
+            return null;
+        },
+        ...(as ? { as } : {}),
+    };
+}
+export function joinArray(key, subkey, as, empty = "none") {
+    return {
+        render: (item) => {
+            const val = rec(item)[key];
+            if (!Array.isArray(val) || val.length === 0)
+                return empty;
+            return val
+                .map((x) => (typeof x === "string" ? x : rec(x)[subkey]))
+                .filter(Boolean)
+                .join(",");
+        },
+        ...(as ? { as } : {}),
+    };
+}
+export function relativeTime(key, as) {
+    return {
+        render: (item) => {
+            const iso = rec(item)[key];
+            return typeof iso === "string" ? formatRelativeTime(iso) : "unknown";
+        },
+        ...(as ? { as } : {}),
+    };
+}
+export function boolYesNo(key, as) {
+    return {
+        render: (item) => (rec(item)[key] ? "yes" : "no"),
+        ...(as ? { as } : {}),
+    };
+}
+export function mapEnum(key, map, fallback, as) {
+    return {
+        render: (item) => {
+            const val = rec(item)[key];
+            const str = val == null ? undefined : String(val);
+            if (str !== undefined && Object.prototype.hasOwnProperty.call(map, str))
+                return map[str];
+            return fallback ?? str ?? "none";
+        },
+        ...(as ? { as } : {}),
+    };
+}
+export function lower(key, as) {
+    return {
+        render: (item) => {
+            const v = rec(item)[key];
+            return typeof v === "string" ? v.toLowerCase() : v ?? null;
+        },
+        ...(as ? { as } : {}),
+    };
+}
+export function checksSummary(key, as) {
+    return {
+        render: (item) => {
+            const checks = rec(item)[key];
+            if (!Array.isArray(checks))
+                return "none";
+            const passed = checks.filter((c) => rec(c).conclusion === "SUCCESS" || rec(c).conclusion === "NEUTRAL").length;
+            return `${passed}/${checks.length} pass`;
+        },
+        ...(as ? { as } : {}),
+    };
+}
+export function custom(fn, as) {
+    return {
+        render: fn,
+        ...(as ? { as } : {}),
+    };
+}
+export function extract(item, schema) {
+    const out = {};
+    for (const [label, def] of Object.entries(schema)) {
+        out[label] = def.render(item);
+    }
+    return out;
+}
+export function renderList(label, items, schema) {
+    return encode({ [label]: items.map((i) => extract(i, schema)) });
+}
+export function renderDetail(label, item, schema) {
+    return encode({ [label]: extract(item, schema) });
+}
+export function renderHelp(lines) {
+    if (lines.length === 0)
+        return "";
+    return `help[${lines.length}]:\n${lines.map((l) => `  ${l}`).join("\n")}`;
+}
+export function renderError(message, code, suggestions = []) {
+    const err = encode({ error: message, code });
+    if (suggestions.length > 0)
+        return `${err}\n${renderHelp(suggestions)}`;
+    return err;
+}
+export function renderOutput(blocks) {
+    return blocks.filter(Boolean).join("\n");
+}

package/dist/src/util.d.ts

@@ -0,0 +1,2 @@
+export declare function validateFlags(args: string[], valid: string[], commandName: string): void;
+export declare function wantsHelp(args: string[]): boolean;

package/dist/src/util.js

@@ -0,0 +1,17 @@
+import { AxiError } from "axi-sdk-js";
+const ALWAYS_ALLOWED = new Set(["--help", "-h", "--json"]);
+export function validateFlags(args, valid, commandName) {
+    const validSet = new Set([...valid, ...ALWAYS_ALLOWED]);
+    const unknown = [];
+    for (const arg of args) {
+        if (arg.startsWith("--") && !validSet.has(arg)) {
+            unknown.push(arg);
+        }
+    }
+    if (unknown.length > 0) {
+        throw new AxiError("VALIDATION_ERROR", `Unknown flag(s) for ${commandName}: ${unknown.join(", ")}`, [`Valid flags: ${valid.sort().join(", ")}`, "Run with --help for usage"]);
+    }
+}
+export function wantsHelp(args) {
+    return args.includes("--help") || args.includes("-h");
+}

package/dist/src/version.d.ts

@@ -0,0 +1 @@
+export declare function readPackageVersion(): string;

package/dist/src/version.js

@@ -0,0 +1,22 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+let cached;
+export function readPackageVersion() {
+    if (cached)
+        return cached;
+    const dir = dirname(fileURLToPath(import.meta.url));
+    for (let d = dir; d !== "/"; d = dirname(d)) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(d, "package.json"), "utf8"));
+            if (pkg.version) {
+                cached = String(pkg.version);
+                return cached;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return "0.0.0";
+}

package/dist/src/warp.d.ts

@@ -0,0 +1,19 @@
+export interface WarpResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface WarpRunner {
+    run(args: string[], options?: {
+        input?: string;
+    }): Promise<WarpResult>;
+}
+import { AxiError } from "axi-sdk-js";
+export declare function realRunner(cwd?: string): WarpRunner;
+export declare function callWarp(runner: WarpRunner, args: string[], options?: {
+    input?: string;
+}): Promise<WarpResult>;
+export declare function callWarpLenient(runner: WarpRunner, args: string[], options?: {
+    input?: string;
+}): Promise<WarpResult>;
+export declare function mapWarpError(stderr: string, _exitCode: number): AxiError;