@bpmnkit/cli 0.0.9

package/dist/commands/settings.js

@@ -0,0 +1,138 @@
+import { clearAuditLog, getActiveName, getAuditLog, getSettings, saveSettings, } from "@bpmnkit/profiles";
+export const settingsGroup = {
+    name: "settings",
+    description: "Manage CLI settings and audit log",
+    commands: [
+        {
+            name: "show",
+            description: "Show current settings",
+            examples: [{ description: "Show settings", command: "casen settings show" }],
+            async run(ctx) {
+                const settings = getSettings();
+                ctx.output.info(`audit-log-size:  ${settings.auditLogSize}`);
+            },
+        },
+        {
+            name: "set",
+            description: "Change a setting",
+            args: [
+                {
+                    name: "key",
+                    description: "Setting name: audit-log-size",
+                    required: true,
+                    enum: ["audit-log-size"],
+                },
+                { name: "value", description: "New value", required: true },
+            ],
+            examples: [
+                { description: "Keep last 25 actions", command: "casen settings set audit-log-size 25" },
+                { description: "Disable audit log", command: "casen settings set audit-log-size 0" },
+            ],
+            async run(ctx) {
+                const key = ctx.positional[0];
+                const rawValue = ctx.positional[1];
+                if (!key)
+                    throw new Error("Missing required argument: <key>");
+                if (rawValue === undefined)
+                    throw new Error("Missing required argument: <value>");
+                if (key === "audit-log-size") {
+                    const n = Number(rawValue);
+                    if (Number.isNaN(n) || n < 0)
+                        throw new Error("audit-log-size must be a non-negative integer");
+                    saveSettings({ auditLogSize: Math.floor(n) });
+                    ctx.output.ok(`audit-log-size = ${Math.floor(n)}`);
+                }
+                else {
+                    throw new Error(`Unknown setting: "${key}". Valid: audit-log-size`);
+                }
+            },
+        },
+        {
+            name: "audit-log",
+            aliases: ["log"],
+            description: "Show the audit log for the active (or specified) profile",
+            flags: [
+                { name: "profile", description: "Profile name (defaults to active)", type: "string" },
+                { name: "limit", description: "Max entries to show (default: all)", type: "number" },
+            ],
+            columns: [
+                { key: "timestamp", header: "TIME", maxWidth: 24 },
+                { key: "profile", header: "PROFILE", maxWidth: 20 },
+                { key: "command", header: "COMMAND", maxWidth: 40 },
+                { key: "status", header: "STATUS", maxWidth: 8 },
+            ],
+            examples: [
+                { description: "Show audit log for active profile", command: "casen settings audit-log" },
+                {
+                    description: "Show audit log for a specific profile",
+                    command: "casen settings audit-log --profile prod",
+                },
+            ],
+            async run(ctx) {
+                const profileFilter = ctx.flags.profile ?? getActiveName() ?? undefined;
+                const limit = ctx.flags.limit;
+                const entries = getAuditLog(profileFilter);
+                const display = limit !== undefined && limit > 0 ? entries.slice(-limit) : entries;
+                if (display.length === 0) {
+                    ctx.output.info(profileFilter
+                        ? `No audit log entries for profile "${profileFilter}".`
+                        : "No audit log entries.");
+                    return;
+                }
+                ctx.output.printList({
+                    items: display.map((e) => ({
+                        timestamp: e.timestamp.replace("T", " ").slice(0, 19),
+                        profile: profileFilter ?? "(all)",
+                        command: `${e.group} ${e.command}${e.positional.length ? ` ${e.positional.join(" ")}` : ""}`,
+                        status: e.status,
+                    })),
+                }, [
+                    { key: "timestamp", header: "TIME", maxWidth: 20 },
+                    { key: "profile", header: "PROFILE", maxWidth: 20 },
+                    { key: "command", header: "COMMAND", maxWidth: 50 },
+                    { key: "status", header: "STATUS", maxWidth: 8 },
+                ]);
+            },
+        },
+        {
+            name: "audit-log-clear",
+            aliases: ["log-clear"],
+            description: "Clear the audit log for the active (or specified) profile",
+            flags: [
+                {
+                    name: "profile",
+                    description: "Profile name to clear (defaults to active; use --all to clear all)",
+                    type: "string",
+                },
+                {
+                    name: "all",
+                    description: "Clear audit log for all profiles",
+                    type: "boolean",
+                    default: false,
+                },
+            ],
+            examples: [
+                {
+                    description: "Clear audit log for active profile",
+                    command: "casen settings audit-log-clear",
+                },
+                {
+                    description: "Clear all audit logs",
+                    command: "casen settings audit-log-clear --all",
+                },
+            ],
+            async run(ctx) {
+                const clearAll = ctx.flags.all === true;
+                if (clearAll) {
+                    clearAuditLog();
+                    ctx.output.ok("Cleared audit log for all profiles");
+                    return;
+                }
+                const profileName = ctx.flags.profile ?? getActiveName() ?? undefined;
+                clearAuditLog(profileName);
+                ctx.output.ok(profileName ? `Cleared audit log for profile "${profileName}"` : "Cleared audit log");
+            },
+        },
+    ],
+};
+//# sourceMappingURL=settings.js.map

package/dist/commands/shared.js

@@ -0,0 +1,196 @@
+// ─── Shared flag specs ────────────────────────────────────────────────────────
+export const FILTER_FLAG = {
+    name: "filter",
+    short: "f",
+    description: "Filter as JSON object",
+    type: "string",
+    placeholder: "JSON",
+    json: true,
+};
+export const DATA_FLAG = {
+    name: "data",
+    short: "d",
+    description: "Request body as JSON",
+    type: "string",
+    required: true,
+    placeholder: "JSON",
+    json: true,
+};
+export const DATA_OPT_FLAG = {
+    name: "data",
+    short: "d",
+    description: "Request body as JSON",
+    type: "string",
+    placeholder: "JSON",
+    json: true,
+};
+export const LIMIT_FLAG = {
+    name: "limit",
+    short: "l",
+    description: "Maximum number of results",
+    type: "number",
+    default: 20,
+    presets: [5, 10, 20, 50, 100, 200, 500],
+};
+export const SORT_FLAG = {
+    name: "sort-by",
+    description: "Sort field",
+    type: "string",
+    placeholder: "FIELD",
+};
+export const SORT_ORDER_FLAG = {
+    name: "sort-order",
+    description: "Sort order",
+    type: "string",
+    default: "asc",
+    enum: ["asc", "desc"],
+};
+// ─── JSON helpers ─────────────────────────────────────────────────────────────
+/**
+ * Parse a JSON flag value. Returns undefined for falsy values.
+ * Throws a descriptive error on invalid JSON.
+ */
+export function parseJson(value, flagName) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON for --${flagName}: ${err instanceof Error ? err.message : String(err)}\n\nGot: ${value}`);
+    }
+}
+/** Build a search body from --filter, --limit, --sort-by, --sort-order flags. */
+export function buildSearchBody(ctx) {
+    const filter = parseJson(ctx.flags.filter, "filter");
+    const limit = ctx.flags.limit;
+    const sortBy = ctx.flags["sort-by"];
+    const sortOrder = ctx.flags["sort-order"];
+    const body = {};
+    if (filter)
+        body.filter = filter;
+    if (limit !== undefined)
+        body.page = { limit };
+    if (sortBy)
+        body.sort = [{ field: sortBy, order: sortOrder ?? "asc" }];
+    return Object.keys(body).length > 0 ? body : undefined;
+}
+// ─── Command factories ────────────────────────────────────────────────────────
+/** Factory for a "list" command that calls a search method. */
+export function makeListCmd(opts) {
+    const filterFlag = opts.filterFields
+        ? { ...FILTER_FLAG, fields: opts.filterFields }
+        : FILTER_FLAG;
+    return {
+        name: opts.name ?? "list",
+        aliases: opts.aliases,
+        description: opts.description,
+        columns: opts.columns,
+        flags: [filterFlag, LIMIT_FLAG, SORT_FLAG, SORT_ORDER_FLAG, ...(opts.extraFlags ?? [])],
+        examples: opts.examples,
+        async run(ctx) {
+            const client = await ctx.getClient();
+            const body = buildSearchBody(ctx);
+            const result = await opts.search(client, body);
+            ctx.output.printList(result, opts.columns);
+        },
+    };
+}
+/** Factory for a "get" command that takes a key positional argument. */
+export function makeGetCmd(opts) {
+    return {
+        name: opts.name ?? "get",
+        aliases: opts.aliases,
+        description: opts.description,
+        args: [
+            {
+                name: opts.argName,
+                description: opts.argDesc ?? `${opts.argName} to retrieve`,
+                required: true,
+            },
+        ],
+        examples: opts.examples,
+        async run(ctx) {
+            const key = ctx.positional[0];
+            if (!key)
+                throw new Error(`Missing required argument: <${opts.argName}>`);
+            const client = await ctx.getClient();
+            const result = await opts.get(client, key);
+            ctx.output.printItem(result);
+        },
+    };
+}
+/** Factory for a "delete" command that takes a key positional argument. */
+export function makeDeleteCmd(opts) {
+    return {
+        name: opts.name ?? "delete",
+        aliases: opts.aliases,
+        description: opts.description,
+        args: [{ name: opts.argName, description: `${opts.argName} to delete`, required: true }],
+        flags: opts.extraFlags ? [DATA_OPT_FLAG, ...opts.extraFlags] : undefined,
+        examples: opts.examples,
+        async run(ctx) {
+            const key = ctx.positional[0];
+            if (!key)
+                throw new Error(`Missing required argument: <${opts.argName}>`);
+            const body = opts.extraFlags
+                ? parseJson(ctx.flags.data, "data")
+                : undefined;
+            const client = await ctx.getClient();
+            await opts.delete(client, key, body);
+            const msg = opts.successMsg ? opts.successMsg(key) : `Deleted ${key}`;
+            ctx.output.ok(msg);
+        },
+    };
+}
+/** Factory for a "create" command that posts a body. */
+export function makeCreateCmd(opts) {
+    const dataFlag = opts.bodyFields ? { ...DATA_FLAG, fields: opts.bodyFields } : DATA_FLAG;
+    return {
+        name: opts.name ?? "create",
+        aliases: opts.aliases,
+        description: opts.description,
+        flags: [dataFlag, ...(opts.extraFlags ?? [])],
+        examples: opts.examples,
+        async run(ctx) {
+            const raw = ctx.flags.data;
+            const body = parseJson(raw, "data") ?? {};
+            const client = await ctx.getClient();
+            const result = await opts.create(client, body);
+            if (result !== undefined && result !== null) {
+                ctx.output.printItem(result);
+            }
+            else {
+                ctx.output.ok(opts.successMsg ?? "Created successfully.");
+            }
+        },
+    };
+}
+/** Factory for an "update" command that patches a resource by key. */
+export function makeUpdateCmd(opts) {
+    const dataFlag = opts.bodyFields ? { ...DATA_FLAG, fields: opts.bodyFields } : DATA_FLAG;
+    return {
+        name: opts.name ?? "update",
+        aliases: opts.aliases,
+        description: opts.description,
+        args: [{ name: opts.argName, description: `${opts.argName} to update`, required: true }],
+        flags: [dataFlag, ...(opts.extraFlags ?? [])],
+        examples: opts.examples,
+        async run(ctx) {
+            const key = ctx.positional[0];
+            if (!key)
+                throw new Error(`Missing required argument: <${opts.argName}>`);
+            const raw = ctx.flags.data;
+            const body = parseJson(raw, "data") ?? {};
+            const client = await ctx.getClient();
+            const result = await opts.update(client, key, body);
+            if (result !== undefined && result !== null) {
+                ctx.output.printItem(result);
+            }
+            else {
+                ctx.output.ok(`Updated ${key}.`);
+            }
+        },
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/worker.js

@@ -0,0 +1,135 @@
+/**
+ * A simple job worker that polls for jobs of a given type and auto-completes
+ * them with a configurable variables payload. Intended for local development
+ * and learning — lets users try out the job-worker concept without writing code.
+ *
+ * Flow:
+ *   1. POST /jobs/activation  — activate up to N jobs (long-polling)
+ *   2. POST /jobs/{key}/completion — complete each job with sample variables
+ *   3. Repeat until Ctrl+C
+ */
+export const workerCmd = {
+    name: "worker",
+    description: "Run a simple job worker that auto-completes jobs of a given type",
+    args: [
+        {
+            name: "type",
+            description: "Job type to subscribe to (matches the task definition type in BPMN)",
+            required: true,
+        },
+    ],
+    flags: [
+        {
+            name: "variables",
+            short: "v",
+            description: "Variables to return when completing each job (JSON object)",
+            type: "string",
+            placeholder: "JSON",
+            default: '{"result":"sample-value"}',
+            json: true,
+        },
+        {
+            name: "timeout",
+            short: "t",
+            description: "Job activation lock timeout in milliseconds",
+            type: "number",
+            default: 30000,
+        },
+        {
+            name: "max-jobs",
+            short: "m",
+            description: "Maximum number of jobs to activate per poll",
+            type: "number",
+            default: 32,
+        },
+    ],
+    examples: [
+        {
+            description: "Subscribe to jobs of type 'payment-service'",
+            command: "casen job worker payment-service",
+        },
+        {
+            description: "Return custom variables on completion",
+            command: 'casen job worker payment-service --variables \'{"status":"ok","amount":100}\'',
+        },
+    ],
+    async run(ctx) {
+        const jobType = ctx.positional[0];
+        if (!jobType)
+            throw new Error("Missing required argument: <type>");
+        const timeout = ctx.flags.timeout ?? 30000;
+        const maxJobs = ctx.flags["max-jobs"] ?? 32;
+        let variables = { result: "sample-value" };
+        const rawVars = ctx.flags.variables;
+        if (rawVars && typeof rawVars === "string") {
+            try {
+                const parsed = JSON.parse(rawVars);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    variables = parsed;
+                }
+                else {
+                    throw new Error("--variables must be a JSON object");
+                }
+            }
+            catch (err) {
+                throw new Error(`Invalid --variables JSON: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        const client = await ctx.getClient();
+        ctx.output.info(`Starting worker for job type "${jobType}"`);
+        ctx.output.info(`Completing jobs with: ${JSON.stringify(variables)}`);
+        ctx.output.info("Press Ctrl+C to stop\n");
+        let running = true;
+        let completed = 0;
+        process.once("SIGINT", () => {
+            running = false;
+        });
+        while (running) {
+            let result;
+            try {
+                result = (await client.job.activateJobs({
+                    type: jobType,
+                    worker: "casen-worker",
+                    timeout,
+                    maxJobsToActivate: maxJobs,
+                    requestTimeout: 20000, // 20 s long poll
+                }));
+            }
+            catch (err) {
+                if (!running)
+                    break;
+                // On 503 / backpressure, wait briefly before retrying
+                ctx.output.info(`Poll error: ${err instanceof Error ? err.message : String(err)} — retrying in 5 s`);
+                await delay(5000);
+                continue;
+            }
+            const jobs = result?.jobs ?? [];
+            for (const job of jobs) {
+                if (!running)
+                    break;
+                ctx.output.info(`Activated job ${job.jobKey}  process=${job.processDefinitionId}  element=${job.elementId}  instance=${job.processInstanceKey}`);
+                if (Object.keys(job.variables ?? {}).length > 0) {
+                    ctx.output.info(`  Input variables: ${JSON.stringify(job.variables)}`);
+                }
+                try {
+                    await client.job.completeJob(job.jobKey, { variables });
+                    completed++;
+                    ctx.output.ok(`Completed job ${job.jobKey} (total: ${completed})`);
+                }
+                catch (err) {
+                    ctx.output.info(`Failed to complete job ${job.jobKey}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // When no jobs were returned, the long-poll already waited; loop immediately.
+            // When jobs were found, yield the event loop briefly before the next poll.
+            if (jobs.length > 0) {
+                await delay(100);
+            }
+        }
+        ctx.output.info(`\nWorker stopped. Completed ${completed} job(s).`);
+    },
+};
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=worker.js.map

package/dist/completion.js

@@ -0,0 +1,89 @@
+// ─── Runtime completion ────────────────────────────────────────────────────────
+/**
+ * Return newline-separated completion suggestions for the given cursor
+ * position and word list. Called when the binary runs with --complete.
+ *
+ * Protocol: casen --complete <cursorWordIndex> -- <words...>
+ */
+export function getRuntimeCompletions(groups, cursorIdx, words) {
+    // words[0] is the binary itself; strip it
+    const tokens = words.slice(1);
+    const pos = cursorIdx - 1; // adjust for stripped binary
+    const partial = tokens[pos] ?? "";
+    // Position 0: completing the resource group name
+    if (pos === 0) {
+        const names = groups.flatMap((g) => [g.name, ...(g.aliases ?? [])]);
+        return names.filter((n) => n.startsWith(partial));
+    }
+    // Find which group is selected
+    const groupToken = tokens[0] ?? "";
+    const group = groups.find((g) => g.name === groupToken || g.aliases?.includes(groupToken));
+    if (!group)
+        return [];
+    // Position 1: completing the command name
+    if (pos === 1) {
+        const names = group.commands.flatMap((c) => [c.name, ...(c.aliases ?? [])]);
+        return names.filter((n) => n.startsWith(partial));
+    }
+    // Position 2+: completing flags for the active command
+    const cmdToken = tokens[1] ?? "";
+    const cmd = group.commands.find((c) => c.name === cmdToken || c.aliases?.includes(cmdToken));
+    if (!cmd)
+        return [];
+    // Suggest flags
+    if (partial.startsWith("--") || partial === "") {
+        const flagNames = (cmd.flags ?? []).map((f) => `--${f.name}`);
+        const globalFlags = ["--profile", "--output", "--no-color", "--debug", "--help"];
+        return [...flagNames, ...globalFlags].filter((f) => f.startsWith(partial));
+    }
+    return [];
+}
+// ─── Shell scripts ────────────────────────────────────────────────────────────
+export function getBashScript() {
+    return `# bash completion for casen
+# Add to ~/.bash_completion or source in ~/.bashrc:
+#   eval "$(casen completion bash)"
+
+_casen_complete() {
+  local cur_word
+  cur_word="\${COMP_WORDS[COMP_CWORD]}"
+  local completions
+  completions=$(casen --complete $COMP_CWORD -- "\${COMP_WORDS[@]}" 2>/dev/null)
+  COMPREPLY=($(compgen -W "$completions" -- "$cur_word"))
+}
+complete -F _casen_complete casen
+`;
+}
+export function getZshScript() {
+    return `#compdef casen
+# zsh completion for casen
+# Add to a directory in your \$fpath, e.g.:
+#   mkdir -p ~/.zfunc && casen completion zsh > ~/.zfunc/_casen
+# Then ensure the directory is in your fpath before compinit:
+#   fpath=(~/.zfunc $fpath)
+#   autoload -Uz compinit && compinit
+
+_casen() {
+  local -a completions
+  IFS=$'\\n' completions=( $(casen --complete $((CURRENT - 1)) -- "\${words[@]}" 2>/dev/null) )
+  compadd -a completions
+}
+
+_casen
+`;
+}
+export function getFishScript() {
+    return `# fish completion for casen
+# Copy to ~/.config/fish/completions/casen.fish or run:
+#   casen completion fish > ~/.config/fish/completions/casen.fish
+
+function __casen_complete
+  set -l cmd (commandline -opc)
+  set -l pos (count $cmd)
+  casen --complete $pos -- $cmd 2>/dev/null
+end
+
+complete -c casen -f -a '(__casen_complete)'
+`;
+}
+//# sourceMappingURL=completion.js.map