@bpmnkit/cli 0.0.9

package/dist/help.js

@@ -0,0 +1,117 @@
+import { readFileSync } from "node:fs";
+import { bold, cyan, dim, green } from "./color.js";
+const GLOBAL_FLAGS = [
+    {
+        name: "profile",
+        short: "p",
+        description: "Profile to use",
+        type: "string",
+        placeholder: "NAME",
+    },
+    {
+        name: "output",
+        short: "o",
+        description: "Output format: table|json|yaml",
+        type: "string",
+        default: "table",
+        placeholder: "FORMAT",
+    },
+    { name: "no-color", description: "Disable colored output", type: "boolean" },
+    { name: "debug", description: "Print debug information", type: "boolean" },
+    { name: "help", short: "h", description: "Show help for this command", type: "boolean" },
+];
+const VERSION = (() => {
+    try {
+        const url = new URL("../package.json", import.meta.url);
+        const pkg = JSON.parse(readFileSync(url, "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+})();
+const BINARY = "casen";
+export function printVersion() {
+    process.stdout.write(`${BINARY} ${VERSION}\n`);
+}
+export function printGlobalHelp(groups, colors) {
+    process.stdout.write(`${bold(`${BINARY} — Camunda v2 REST API CLI`, colors)}\n\n`);
+    process.stdout.write(`${bold("USAGE", colors)}\n`);
+    process.stdout.write(`  ${BINARY} <resource> <command> [args] [flags]\n\n`);
+    process.stdout.write(`${bold("RESOURCES", colors)}\n`);
+    const maxName = groups.reduce((m, g) => Math.max(m, g.name.length), 0);
+    for (const g of groups) {
+        const aliases = g.aliases?.length ? dim(` (${g.aliases.join(", ")})`, colors) : "";
+        process.stdout.write(`  ${cyan(g.name.padEnd(maxName), colors)}${aliases}  ${g.description}\n`);
+    }
+    process.stdout.write(`\n${bold("FLAGS", colors)}\n`);
+    printFlags(GLOBAL_FLAGS, colors);
+    process.stdout.write(`\n${bold("EXAMPLES", colors)}\n`);
+    process.stdout.write(`  ${dim("# List active process instances", colors)}\n`);
+    process.stdout.write(`  ${BINARY} process-instance list --filter '{"state":"ACTIVE"}'\n\n`);
+    process.stdout.write(`  ${dim("# Switch profile", colors)}\n`);
+    process.stdout.write(`  ${BINARY} profile use production\n\n`);
+    process.stdout.write(`  ${dim("# Enable shell completions (zsh)", colors)}\n`);
+    process.stdout.write(`  ${BINARY} completion zsh > ~/.zfunc/_casen\n\n`);
+    process.stdout.write(`${dim(`Run \`${BINARY} <resource> --help\` for resource-level help.`, colors)}\n`);
+}
+export function printGroupHelp(group, colors) {
+    const aliases = group.aliases?.length ? ` (${group.aliases.join(", ")})` : "";
+    process.stdout.write(`${bold(`${BINARY} ${group.name}`, colors)}${aliases} — ${group.description}\n\n`);
+    process.stdout.write(`${bold("USAGE", colors)}\n`);
+    process.stdout.write(`  ${BINARY} ${group.name} <command> [args] [flags]\n\n`);
+    process.stdout.write(`${bold("COMMANDS", colors)}\n`);
+    const maxName = group.commands.reduce((m, c) => Math.max(m, c.name.length), 0);
+    for (const cmd of group.commands) {
+        const aliases = cmd.aliases?.length ? dim(` (${cmd.aliases.join(", ")})`, colors) : "";
+        process.stdout.write(`  ${cyan(cmd.name.padEnd(maxName), colors)}${aliases}  ${cmd.description}\n`);
+    }
+    process.stdout.write(`\n${bold("FLAGS", colors)}\n`);
+    printFlags(GLOBAL_FLAGS, colors);
+    process.stdout.write(`\n${dim(`Run \`${BINARY} ${group.name} <command> --help\` for command details.`, colors)}\n`);
+}
+export function printCommandHelp(group, cmd, colors) {
+    process.stdout.write(`${bold(`${BINARY} ${group.name} ${cmd.name}`, colors)} — ${cmd.description}\n\n`);
+    // Usage
+    const argPart = cmd.args
+        ? cmd.args.map((a) => (a.required ? `<${a.name}>` : `[${a.name}]`)).join(" ")
+        : "";
+    process.stdout.write(`${bold("USAGE", colors)}\n`);
+    process.stdout.write(`  ${BINARY} ${group.name} ${cmd.name}${argPart ? ` ${argPart}` : ""} [flags]\n\n`);
+    // Args
+    if (cmd.args?.length) {
+        process.stdout.write(`${bold("ARGUMENTS", colors)}\n`);
+        const maxName = cmd.args.reduce((m, a) => Math.max(m, a.name.length), 0);
+        for (const arg of cmd.args) {
+            const req = arg.required ? "" : dim(" (optional)", colors);
+            process.stdout.write(`  ${cyan(`<${arg.name}>`.padEnd(maxName + 2), colors)}${req}  ${arg.description}\n`);
+        }
+        process.stdout.write("\n");
+    }
+    // Flags
+    const allFlags = [...(cmd.flags ?? []), ...GLOBAL_FLAGS];
+    process.stdout.write(`${bold("FLAGS", colors)}\n`);
+    printFlags(allFlags, colors);
+    // Examples
+    if (cmd.examples?.length) {
+        process.stdout.write(`\n${bold("EXAMPLES", colors)}\n`);
+        for (const ex of cmd.examples) {
+            process.stdout.write(`  ${dim(`# ${ex.description}`, colors)}\n`);
+            process.stdout.write(`  ${green(ex.command, colors)}\n\n`);
+        }
+    }
+}
+function printFlags(flags, colors) {
+    const entries = flags.map((f) => {
+        const shortPart = f.short ? `-${f.short}, ` : "    ";
+        const placeholder = f.placeholder ? ` <${f.placeholder}>` : "";
+        const longPart = `--${f.name}${placeholder}`;
+        return { shortPart, longPart, description: f.description, def: f.default };
+    });
+    const maxLong = entries.reduce((m, e) => Math.max(m, e.longPart.length), 0);
+    for (const { shortPart, longPart, description, def } of entries) {
+        const defPart = def !== undefined ? dim(` (default: ${def})`, colors) : "";
+        process.stdout.write(`  ${dim(shortPart, colors)}${cyan(longPart.padEnd(maxLong), colors)}  ${description}${defPart}\n`);
+    }
+}
+//# sourceMappingURL=help.js.map

package/dist/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from "./run.js";
+await run(process.argv.slice(2));
+//# sourceMappingURL=index.js.map

package/dist/output.js

@@ -0,0 +1,262 @@
+import { bold, cyan, dim, green, red, shouldUseColor, stateColor } from "./color.js";
+// ─── Formatting helpers ────────────────────────────────────────────────────────
+/** Format an ISO date string to a readable local time. */
+function fmtDate(v) {
+    if (!v)
+        return "—";
+    const d = new Date(String(v));
+    if (Number.isNaN(d.getTime()))
+        return String(v);
+    return d.toLocaleString("en-US", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+}
+/** Format a value for table display. */
+function formatCell(value, transform) {
+    if (transform)
+        return transform(value);
+    if (value === null || value === undefined)
+        return "—";
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+/** Truncate a string to maxLen, appending "…" if truncated. */
+function truncate(s, maxLen) {
+    if (maxLen > 0 && s.length > maxLen)
+        return `${s.slice(0, maxLen - 1)}…`;
+    return s;
+}
+/** Strip ANSI escape codes to get the visual width of a string. */
+function visibleLength(s) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: needed for ANSI stripping
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+/** Pad a string to visually fill `width` characters (accounting for ANSI codes). */
+function padEnd(s, width) {
+    const vis = visibleLength(s);
+    return vis < width ? s + " ".repeat(width - vis) : s;
+}
+// ─── YAML serializer ──────────────────────────────────────────────────────────
+function toYaml(value, indent = 0) {
+    const pad = "  ".repeat(indent);
+    if (value === null || value === undefined)
+        return "null\n";
+    if (typeof value === "boolean")
+        return `${value}\n`;
+    if (typeof value === "number")
+        return `${value}\n`;
+    if (typeof value === "string") {
+        if (/[\n:#{}"',]/.test(value))
+            return `"${value.replace(/"/g, '\\"')}"\n`;
+        return `${value}\n`;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]\n";
+        return value.map((item) => `${pad}- ${toYaml(item, indent + 1).trimStart()}`).join("");
+    }
+    if (typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj);
+        if (keys.length === 0)
+            return "{}\n";
+        return keys.map((k) => `${pad}${k}: ${toYaml(obj[k], indent + 1).trimStart()}`).join("");
+    }
+    return `${String(value)}\n`;
+}
+// ─── Table renderer ───────────────────────────────────────────────────────────
+function printTable(rows, columns, colors) {
+    if (rows.length === 0) {
+        process.stdout.write(dim("No results.\n", colors));
+        return;
+    }
+    // Calculate column widths
+    const widths = columns.map((col) => {
+        const dataMax = rows.reduce((max, row) => {
+            const raw = formatCell(row[col.key], col.transform);
+            const cell = col.maxWidth ? truncate(raw, col.maxWidth) : raw;
+            return Math.max(max, visibleLength(cell));
+        }, 0);
+        return Math.max(col.header.length, dataMax);
+    });
+    // Header
+    const header = columns
+        .map((col, i) => padEnd(bold(col.header, colors), widths[i] ?? col.header.length))
+        .join("  ");
+    process.stdout.write(`${header}\n`);
+    process.stdout.write(`${dim("─".repeat(visibleLength(header)), colors)}\n`);
+    // Rows
+    for (const row of rows) {
+        const line = columns
+            .map((col, i) => {
+            const width = widths[i] ?? col.maxWidth ?? 20;
+            const raw = formatCell(row[col.key], col.transform);
+            const cell = col.maxWidth ? truncate(raw, col.maxWidth) : raw;
+            // Apply state colors automatically
+            const colored = col.key === "state" || col.key === "errorState" ? stateColor(cell, colors) : cell;
+            return padEnd(colored, width);
+        })
+            .join("  ");
+        process.stdout.write(`${line}\n`);
+    }
+}
+/** Print a single object as aligned key-value pairs. */
+function printKV(obj, colors) {
+    const entries = Object.entries(obj).filter(([, v]) => v !== undefined);
+    const keyWidth = entries.reduce((max, [k]) => Math.max(max, k.length), 0);
+    for (const [k, v] of entries) {
+        const label = padEnd(cyan(k, colors), keyWidth);
+        const value = v === null || v === undefined ? dim("—", colors) : String(v);
+        process.stdout.write(`${label}  ${value}\n`);
+    }
+}
+/** Recursively flatten an object for KV display. Arrays of objects are expanded with [i] keys. */
+function flattenForDisplay(obj, prefix = "") {
+    if (typeof obj !== "object" || obj === null)
+        return { value: obj };
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (Array.isArray(v)) {
+            if (v.length === 0) {
+                result[key] = "[]";
+            }
+            else if (v.every((item) => typeof item !== "object" || item === null)) {
+                result[key] = v.join(", ");
+            }
+            else {
+                for (let i = 0; i < v.length; i++) {
+                    const elem = v[i];
+                    if (typeof elem === "object" && elem !== null) {
+                        Object.assign(result, flattenForDisplay(elem, `${key}[${i}]`));
+                    }
+                    else {
+                        result[`${key}[${i}]`] = elem;
+                    }
+                }
+            }
+        }
+        else if (typeof v === "object" && v !== null) {
+            Object.assign(result, flattenForDisplay(v, key));
+        }
+        else {
+            result[key] = v;
+        }
+    }
+    return result;
+}
+// ─── OutputWriter factory ────────────────────────────────────────────────────
+export function createOutputWriter(format, noColor) {
+    const colors = shouldUseColor(noColor);
+    return {
+        format,
+        isInteractive: process.stdout.isTTY === true,
+        printList(data, columns) {
+            // Unwrap { items: [...], page: {...} } envelope
+            let items;
+            let total;
+            if (typeof data === "object" &&
+                data !== null &&
+                "items" in data &&
+                Array.isArray(data.items)) {
+                items = data.items;
+                const page = data.page;
+                if (typeof page === "object" && page !== null && "totalItems" in page) {
+                    total = page.totalItems;
+                }
+            }
+            else if (Array.isArray(data)) {
+                items = data;
+            }
+            else {
+                items = [data];
+            }
+            if (format === "json") {
+                process.stdout.write(`${JSON.stringify(items, null, 2)}\n`);
+                return;
+            }
+            if (format === "yaml") {
+                process.stdout.write(toYaml(items));
+                return;
+            }
+            printTable(items, columns, colors);
+            const count = total !== undefined ? total : items.length;
+            process.stdout.write(`\n${dim(`${count} ${count === 1 ? "item" : "items"}`, colors)}\n`);
+        },
+        printItem(data) {
+            if (format === "json") {
+                process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+                return;
+            }
+            if (format === "yaml") {
+                process.stdout.write(toYaml(data));
+                return;
+            }
+            const obj = typeof data === "object" && data !== null
+                ? flattenForDisplay(data)
+                : { value: String(data) };
+            printKV(obj, colors);
+        },
+        print(data) {
+            if (format === "json") {
+                process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+                return;
+            }
+            if (format === "yaml") {
+                process.stdout.write(toYaml(data));
+                return;
+            }
+            if (typeof data === "string") {
+                process.stdout.write(`${data}\n`);
+                return;
+            }
+            process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+        },
+        ok(msg) {
+            process.stdout.write(`${green("✓", colors)} ${msg}\n`);
+        },
+        info(msg) {
+            process.stdout.write(`${dim("→", colors)} ${msg}\n`);
+        },
+    };
+}
+/** Date transformer for use in ColumnDef. */
+export const dateTransform = fmtDate;
+/** An OutputWriter that discards all output (used when --raw suppresses formatted output). */
+export function createNullWriter() {
+    return {
+        format: "table",
+        isInteractive: false,
+        printList() { },
+        printItem() { },
+        print() { },
+        ok() { },
+        info() { },
+    };
+}
+/** Print a raw HTTP response (status, headers, body) to stdout. */
+export function printRawResponse(raw, noColor) {
+    const colors = shouldUseColor(noColor);
+    const statusFn = raw.status >= 200 && raw.status < 300 ? green : red;
+    process.stdout.write(`${statusFn(`HTTP ${raw.status}`, colors)}\n`);
+    for (const [k, v] of Object.entries(raw.headers)) {
+        process.stdout.write(`${cyan(k, colors)}: ${v}\n`);
+    }
+    process.stdout.write("\n");
+    // Pretty-print JSON body if possible, otherwise raw text
+    try {
+        const parsed = JSON.parse(raw.body);
+        process.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
+    }
+    catch {
+        process.stdout.write(`${raw.body}\n`);
+    }
+}
+//# sourceMappingURL=output.js.map

package/dist/profile-tui.js

@@ -0,0 +1,229 @@
+import { deleteProfile, getActiveName, listProfiles, useProfile } from "@bpmnkit/profiles";
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+const CSI = "\x1b[";
+const HIDE_CURSOR = `${CSI}?25l`;
+const SHOW_CURSOR = `${CSI}?25h`;
+const ALT_ON = `${CSI}?1049h`;
+const ALT_OFF = `${CSI}?1049l`;
+const CLEAR = `${CSI}2J${CSI}H`;
+function inv(s) {
+    return `${CSI}7m${s}${CSI}m`;
+}
+function bold(s) {
+    return `${CSI}1m${s}${CSI}m`;
+}
+function dim(s) {
+    return `${CSI}2m${s}${CSI}m`;
+}
+function green(s) {
+    return `${CSI}32m${s}${CSI}m`;
+}
+function red(s) {
+    return `${CSI}31m${s}${CSI}m`;
+}
+function cyan(s) {
+    return `${CSI}36m${s}${CSI}m`;
+}
+/** Strip ANSI codes to get visible length. */
+function vlen(s) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: needed for ANSI stripping
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+/** Truncate and pad to exactly n visible characters. */
+function fit(s, n) {
+    if (s.length > n)
+        return `${s.slice(0, n - 1)}…`;
+    return s.padEnd(n);
+}
+function loadRows() {
+    const profiles = listProfiles();
+    const activeName = getActiveName();
+    const rows = profiles.map((p) => ({
+        name: p.name,
+        apiType: p.apiType,
+        url: (p.config.baseUrl ?? ""),
+        authType: p.config.auth?.type ?? "—",
+        createdAt: p.createdAt ? p.createdAt.slice(0, 10) : "—",
+    }));
+    return { rows, activeName };
+}
+// ─── Render ───────────────────────────────────────────────────────────────────
+function render(state) {
+    const { rows, activeName, cursor, selected, message, confirmDelete } = state;
+    const termCols = process.stdout.columns ?? 80;
+    // Fixed cols: 2 indent + 3 chk + 1 sp + 1 active + 1 sp + 16 name + 1 sp + 8 auth + 1 sp + 10 date = 44
+    const urlWidth = Math.max(16, termCols - 53);
+    const out = [];
+    out.push("");
+    out.push(`  ${bold("casen — Profile Manager")}  ${dim(`${rows.length} profile${rows.length !== 1 ? "s" : ""}`)}`);
+    out.push("");
+    if (rows.length === 0) {
+        out.push(dim("  No profiles yet."));
+        out.push(dim("  Create one with: casen profile create <name> ..."));
+        out.push("");
+    }
+    else {
+        // Header
+        const hdr = `  ${dim("   ")} ${dim(" ")} ${dim(fit("NAME", 16))} ` +
+            `${dim(fit("API", 6))} ${dim(fit("BASE URL", urlWidth))} ${dim(fit("AUTH", 8))} ${dim("CREATED")}`;
+        out.push(hdr);
+        out.push(dim(`  ${"─".repeat(termCols - 4)}`));
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            if (!row)
+                continue;
+            const isCursor = i === cursor;
+            const isSel = selected.has(i);
+            const isActive = row.name === activeName;
+            const chk = isSel ? green("[✓]") : dim("[ ]");
+            const act = isActive ? green("●") : " ";
+            const name = fit(row.name, 16);
+            const api = fit(row.apiType, 6);
+            const url = fit(row.url, urlWidth);
+            const auth = fit(row.authType, 8);
+            const date = row.createdAt;
+            // Build the line without leading spaces so inverse spans full width
+            const content = `  ${chk} ${act} ${name} ${api} ${url} ${auth} ${date}`;
+            // Pad to terminal width so inverse video fills the row
+            const visible = vlen(content);
+            const padded = content + " ".repeat(Math.max(0, termCols - visible - 1));
+            out.push(isCursor ? inv(padded) : padded);
+        }
+        out.push("");
+    }
+    // Status / help bar
+    if (confirmDelete) {
+        const n = selected.size;
+        out.push(red(`  Delete ${n} profile${n !== 1 ? "s" : ""}? [y/N] `));
+    }
+    else if (message) {
+        out.push(`  ${message}`);
+    }
+    else {
+        out.push(`${dim("  ")}${dim("↑↓")} navigate  ${dim("space")} select  ${cyan("d")} delete  ${cyan("u")} activate  ${cyan("q")} quit`);
+    }
+    process.stdout.write(`${CLEAR}${out.join("\n")}\n`);
+}
+// ─── Key handling ─────────────────────────────────────────────────────────────
+function handleKey(key, state, done) {
+    // Confirmation prompt
+    if (state.confirmDelete) {
+        if (key === "y" || key === "Y") {
+            const names = [...state.selected]
+                .map((i) => state.rows[i]?.name)
+                .filter((n) => n !== undefined);
+            for (const name of names)
+                deleteProfile(name);
+            const { rows, activeName } = loadRows();
+            state.rows = rows;
+            state.activeName = activeName;
+            state.selected.clear();
+            state.cursor = Math.min(state.cursor, Math.max(0, rows.length - 1));
+            state.message = green(`✓ Deleted: ${names.join(", ")}`);
+            state.confirmDelete = false;
+        }
+        else {
+            state.confirmDelete = false;
+            state.message = "";
+        }
+        render(state);
+        return;
+    }
+    state.message = "";
+    switch (key) {
+        case "\x1b[A": // up arrow
+            if (state.rows.length > 0)
+                state.cursor = (state.cursor - 1 + state.rows.length) % state.rows.length;
+            break;
+        case "\x1b[B": // down arrow
+            if (state.rows.length > 0)
+                state.cursor = (state.cursor + 1) % state.rows.length;
+            break;
+        case " ": // toggle selection
+            if (state.rows.length > 0) {
+                if (state.selected.has(state.cursor))
+                    state.selected.delete(state.cursor);
+                else
+                    state.selected.add(state.cursor);
+            }
+            break;
+        case "d":
+        case "D": {
+            // If nothing selected, select current row
+            if (state.selected.size === 0 && state.rows.length > 0) {
+                state.selected.add(state.cursor);
+            }
+            if (state.selected.size > 0)
+                state.confirmDelete = true;
+            break;
+        }
+        case "u":
+        case "U":
+        case "\r":
+        case "\n": {
+            const row = state.rows[state.cursor];
+            if (row) {
+                useProfile(row.name);
+                state.activeName = row.name;
+                state.message = green(`✓ Now using "${row.name}"`);
+            }
+            break;
+        }
+        case "q":
+        case "Q":
+        case "\x03": // Ctrl+C
+        case "\x1b": // ESC
+            done();
+            return;
+    }
+    render(state);
+}
+// ─── Entry point ──────────────────────────────────────────────────────────────
+export async function runProfileManager() {
+    // Non-interactive fallback (piped / no TTY)
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        const profiles = listProfiles();
+        const activeName = getActiveName();
+        if (profiles.length === 0) {
+            process.stdout.write("No profiles. Create one with: casen profile create <name> ...\n");
+            return;
+        }
+        for (const p of profiles) {
+            const active = p.name === activeName ? " (active)" : "";
+            const date = p.createdAt ? `  ${p.createdAt.slice(0, 10)}` : "";
+            process.stdout.write(`${p.name}${active}${date}\n`);
+        }
+        return;
+    }
+    process.stdout.write(ALT_ON + HIDE_CURSOR);
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        process.stdout.write(ALT_OFF + SHOW_CURSOR);
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+    };
+    process.on("exit", cleanup);
+    const { rows, activeName } = loadRows();
+    const state = {
+        rows,
+        activeName,
+        cursor: 0,
+        selected: new Set(),
+        message: "",
+        confirmDelete: false,
+    };
+    render(state);
+    await new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (key) => handleKey(key, state, resolve));
+    });
+    cleanup();
+    process.removeListener("exit", cleanup);
+}
+//# sourceMappingURL=profile-tui.js.map