@bpmnkit/cli 0.0.9

package/dist/commands/connector.js

@@ -0,0 +1,172 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+export const connectorGroup = {
+    name: "connector",
+    description: "Generate Camunda REST connector element templates from OpenAPI specs",
+    commands: [
+        {
+            name: "generate",
+            description: "Generate connector templates from a local OpenAPI spec or catalog entry",
+            flags: [
+                {
+                    name: "swagger",
+                    short: "s",
+                    description: "Path to a local OpenAPI/Swagger file (YAML or JSON)",
+                    type: "string",
+                },
+                {
+                    name: "api",
+                    description: "Catalog API id (e.g. github, stripe). Use 'connector catalog' to list.",
+                    type: "string",
+                },
+                {
+                    name: "output",
+                    short: "o",
+                    description: "Output directory (default: ./connector-templates)",
+                    type: "string",
+                },
+                { name: "base-url", description: "Override the base URL from the spec", type: "string" },
+                {
+                    name: "id-prefix",
+                    description: "Reverse-DNS id prefix (default: io.generated)",
+                    type: "string",
+                },
+                {
+                    name: "filter",
+                    description: "Regex filter on operationId/summary (case-insensitive)",
+                    type: "string",
+                },
+                {
+                    name: "expand-body",
+                    description: "Decompose top-level request body properties into individual fields",
+                    type: "boolean",
+                    default: false,
+                },
+                {
+                    name: "auth",
+                    description: "Default auth type: noAuth, apiKey, basic, bearer, oauth-client-credentials-flow",
+                    type: "string",
+                },
+                {
+                    name: "format",
+                    description: "Output format: one-per-op (default) or array (single file)",
+                    type: "string",
+                },
+                {
+                    name: "dry-run",
+                    description: "Print templates to stdout without writing files",
+                    type: "boolean",
+                    default: false,
+                },
+            ],
+            examples: [
+                {
+                    description: "Generate from a local file",
+                    command: "casen connector generate --swagger ./petstore.yaml --output ./out",
+                },
+                {
+                    description: "Generate from the GitHub catalog entry",
+                    command: "casen connector generate --api github --output ./out --filter issues",
+                },
+                {
+                    description: "Dry run (print to stdout)",
+                    command: "casen connector generate --swagger ./spec.yaml --dry-run",
+                },
+            ],
+            async run(ctx) {
+                // Lazy import so the CLI doesn't load yaml on startup
+                const { generate, generateFromUrl, CATALOG, getCatalogEntry } = await import("@bpmnkit/connector-gen");
+                const swaggerPath = ctx.flags.swagger;
+                const apiId = ctx.flags.api;
+                const outputDir = ctx.flags.output ?? "./connector-templates";
+                const baseUrl = ctx.flags["base-url"];
+                const idPrefix = ctx.flags["id-prefix"] ?? "io.generated";
+                const filter = ctx.flags.filter;
+                const expandBody = ctx.flags["expand-body"] === true;
+                const authFlag = ctx.flags.auth;
+                const format = ctx.flags.format ?? "one-per-op";
+                const dryRun = ctx.flags["dry-run"] === true;
+                const validAuth = [
+                    "noAuth",
+                    "apiKey",
+                    "basic",
+                    "bearer",
+                    "oauth-client-credentials-flow",
+                ];
+                if (authFlag && !validAuth.includes(authFlag)) {
+                    throw new Error(`Unknown --auth value "${authFlag}". Valid: ${validAuth.join(", ")}`);
+                }
+                const defaultAuthType = authFlag;
+                if (!swaggerPath && !apiId) {
+                    throw new Error("Provide either --swagger <file> or --api <id>. Use 'casen connector catalog' to list catalog entries.");
+                }
+                if (swaggerPath && apiId) {
+                    throw new Error("Use either --swagger or --api, not both.");
+                }
+                const opts = { idPrefix, baseUrl, expandBody, filter, defaultAuthType };
+                if (swaggerPath) {
+                    const absPath = resolve(swaggerPath);
+                    const text = await readFile(absPath, "utf8");
+                    const templates = generate(text, opts);
+                    if (dryRun) {
+                        ctx.output.print(templates);
+                        ctx.output.info(`Would generate ${templates.length} template(s)`);
+                        return;
+                    }
+                    const { writeTemplates } = await import("@bpmnkit/connector-gen");
+                    const files = await writeTemplates(templates, { outputDir: resolve(outputDir), format });
+                    ctx.output.ok(`Generated ${files.length} template(s) → ${resolve(outputDir)}`);
+                    for (const f of files)
+                        ctx.output.info(`  ${f}`);
+                    return;
+                }
+                // API catalog path
+                if (!apiId)
+                    return;
+                const entry = getCatalogEntry(apiId);
+                if (!entry) {
+                    const ids = CATALOG.map((e) => e.id).join(", ");
+                    throw new Error(`Unknown catalog entry "${apiId}". Available: ${ids}`);
+                }
+                ctx.output.info(`Downloading spec for "${entry.name}" …`);
+                const { generateFromUrl: _gfu } = { generateFromUrl };
+                const { templates, files } = await generateFromUrl(entry.url, {
+                    ...opts,
+                    idPrefix: opts.idPrefix === "io.generated" ? entry.idPrefix : opts.idPrefix,
+                    defaultAuthType: opts.defaultAuthType ?? entry.defaultAuth,
+                    ...(dryRun ? {} : { outputDir: resolve(outputDir), format }),
+                });
+                if (dryRun) {
+                    ctx.output.print(templates);
+                    ctx.output.info(`Would generate ${templates.length} template(s)`);
+                    return;
+                }
+                ctx.output.ok(`Generated ${files.length} template(s) → ${resolve(outputDir)}`);
+                for (const f of files)
+                    ctx.output.info(`  ${f}`);
+            },
+        },
+        {
+            name: "catalog",
+            description: "List available API catalog entries",
+            examples: [{ description: "Show all catalog entries", command: "casen connector catalog" }],
+            async run(ctx) {
+                const { CATALOG } = await import("@bpmnkit/connector-gen");
+                ctx.output.printList({
+                    items: CATALOG.map((e) => ({
+                        id: e.id,
+                        name: e.name,
+                        auth: e.defaultAuth,
+                        description: e.description,
+                    })),
+                }, [
+                    { key: "id", header: "ID", maxWidth: 16 },
+                    { key: "name", header: "NAME", maxWidth: 30 },
+                    { key: "auth", header: "AUTH", maxWidth: 32 },
+                    { key: "description", header: "DESCRIPTION", maxWidth: 60 },
+                ]);
+            },
+        },
+    ],
+};
+//# sourceMappingURL=connector.js.map

package/dist/commands/index.js

@@ -0,0 +1,47 @@
+import { adminCommandGroups } from "../generated/admin-commands.js";
+import { decisionDefinitionGroup, decisionRequirementsGroup, generatedCommandGroups, jobGroup, processDefinitionGroup, userTaskGroup, } from "../generated/commands.js";
+import { getDmnReqsXmlCmd, getDmnXmlCmd, getStartFormCmd, getUserTaskFormCmd, getXmlCmd, renderBpmnCmd, } from "./bpmn.js";
+import { completionGroup } from "./completion.js";
+import { connectorGroup } from "./connector.js";
+import { profileGroup } from "./profile.js";
+import { computeRelations } from "./relations.js";
+import { settingsGroup } from "./settings.js";
+import { workerCmd } from "./worker.js";
+// Inject custom commands into generated groups without modifying generated files.
+// Also remove the broken generated get-x-m-l commands (return text/xml, not JSON)
+// and replace getstart-form / get-form with ASCII-rendering variants.
+const customisedGroups = generatedCommandGroups.map((g) => {
+    if (g === processDefinitionGroup) {
+        const commands = g.commands.filter((c) => c.name !== "get-x-m-l" && c.name !== "getstart-form");
+        return { ...g, commands: [...commands, getXmlCmd, renderBpmnCmd, getStartFormCmd] };
+    }
+    if (g === decisionDefinitionGroup) {
+        const commands = g.commands.filter((c) => c.name !== "get-x-m-l");
+        return { ...g, commands: [...commands, getDmnXmlCmd] };
+    }
+    if (g === decisionRequirementsGroup) {
+        const commands = g.commands.filter((c) => c.name !== "get-x-m-l");
+        return { ...g, commands: [...commands, getDmnReqsXmlCmd] };
+    }
+    if (g === userTaskGroup) {
+        const commands = g.commands.filter((c) => c.name !== "get-form");
+        return { ...g, commands: [...commands, getUserTaskFormCmd] };
+    }
+    if (g === jobGroup) {
+        return { ...g, commands: [...g.commands, workerCmd] };
+    }
+    return g;
+});
+const allGroups = [
+    profileGroup,
+    settingsGroup,
+    connectorGroup,
+    ...customisedGroups,
+    ...adminCommandGroups,
+    completionGroup,
+];
+// Sort alphabetically by name for the main menu
+export const commandGroups = allGroups.sort((a, b) => a.name.localeCompare(b.name));
+// Compute follow-up relations between commands based on shared field/arg names
+computeRelations(commandGroups);
+//# sourceMappingURL=index.js.map

package/dist/commands/profile.js

@@ -0,0 +1,325 @@
+import { readFileSync } from "node:fs";
+import { deleteProfile, getActiveName, getActiveProfile, getConfigFilePath, getProfile, listProfiles, saveProfile, useProfile, } from "@bpmnkit/profiles";
+const API_TYPE_FLAG = {
+    name: "api-type",
+    description: "API type: c8 (default) or admin",
+    type: "string",
+    default: "c8",
+    placeholder: "TYPE",
+};
+const AUTH_FLAGS = [
+    {
+        name: "base-url",
+        description: "API base URL",
+        type: "string",
+        required: true,
+        placeholder: "URL",
+    },
+    {
+        name: "auth-type",
+        description: "Authentication type: bearer|oauth2|basic|none",
+        type: "string",
+        required: true,
+        placeholder: "TYPE",
+    },
+    {
+        name: "token",
+        description: "Bearer token (auth-type=bearer)",
+        type: "string",
+        placeholder: "TOKEN",
+    },
+    { name: "client-id", description: "OAuth2 client ID", type: "string", placeholder: "ID" },
+    {
+        name: "client-secret",
+        description: "OAuth2 client secret",
+        type: "string",
+        placeholder: "SECRET",
+    },
+    {
+        name: "token-url",
+        description: "OAuth2 token endpoint URL",
+        type: "string",
+        placeholder: "URL",
+    },
+    {
+        name: "audience",
+        description: "OAuth2 audience (auth-type=oauth2, default: zeebe.camunda.io)",
+        type: "string",
+        placeholder: "AUDIENCE",
+    },
+    { name: "username", description: "Basic auth username", type: "string", placeholder: "USER" },
+    { name: "password", description: "Basic auth password", type: "string", placeholder: "PASS" },
+];
+// ─── Camunda Cloud credentials file parser ────────────────────────────────────
+/** Parse a shell file of `export KEY='VALUE'` lines into a key-value map. */
+function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const match = trimmed.match(/^(?:export\s+)?([A-Z_][A-Z0-9_]*)=(.*)/);
+        if (!match)
+            continue;
+        const key = match[1] ?? "";
+        let value = (match[2] ?? "").trim();
+        if ((value.startsWith("'") && value.endsWith("'")) ||
+            (value.startsWith('"') && value.endsWith('"'))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/** Detect the API type from a parsed env map. Returns "admin" if Console vars present, else "c8". */
+function detectApiType(env) {
+    return env.CAMUNDA_CONSOLE_CLIENT_ID || env.CAMUNDA_CONSOLE_BASE_URL ? "admin" : "c8";
+}
+/** Build a CamundaClientInput from a Camunda Console (Admin API) env map. */
+function configFromConsoleEnv(env) {
+    const baseUrl = env.CAMUNDA_CONSOLE_BASE_URL;
+    if (!baseUrl) {
+        throw new Error("CAMUNDA_CONSOLE_BASE_URL not found in credentials file. " +
+            "Make sure you are using a Camunda Console credentials export.");
+    }
+    const clientId = env.CAMUNDA_CONSOLE_CLIENT_ID ?? "";
+    const clientSecret = env.CAMUNDA_CONSOLE_CLIENT_SECRET ?? "";
+    const tokenUrl = env.CAMUNDA_OAUTH_URL ?? "";
+    const audience = env.CAMUNDA_CONSOLE_OAUTH_AUDIENCE ?? "";
+    if (!clientId || !clientSecret || !tokenUrl) {
+        throw new Error("Missing required credentials. Expected: " +
+            "CAMUNDA_CONSOLE_CLIENT_ID, CAMUNDA_CONSOLE_CLIENT_SECRET, CAMUNDA_OAUTH_URL.");
+    }
+    return { baseUrl, auth: { type: "oauth2", clientId, clientSecret, tokenUrl, audience } };
+}
+/** Build a CamundaClientInput from a parsed Camunda Cloud credentials env map. */
+function configFromCloudEnv(env) {
+    const restAddress = env.ZEEBE_REST_ADDRESS;
+    if (!restAddress) {
+        throw new Error("ZEEBE_REST_ADDRESS not found in credentials file. " +
+            "Make sure you are using a Camunda Cloud credentials export.");
+    }
+    const baseUrl = restAddress.endsWith("/v2") ? restAddress : `${restAddress}/v2`;
+    const clientId = env.CAMUNDA_CLIENT_ID ?? env.ZEEBE_CLIENT_ID ?? "";
+    const clientSecret = env.CAMUNDA_CLIENT_SECRET ?? env.ZEEBE_CLIENT_SECRET ?? "";
+    const tokenUrl = env.CAMUNDA_OAUTH_URL ?? env.ZEEBE_AUTHORIZATION_SERVER_URL ?? "";
+    const audience = env.CAMUNDA_TOKEN_AUDIENCE ?? "zeebe.camunda.io";
+    if (!clientId || !clientSecret || !tokenUrl) {
+        throw new Error("Missing required credentials. Expected: " +
+            "CAMUNDA_CLIENT_ID (or ZEEBE_CLIENT_ID), " +
+            "CAMUNDA_CLIENT_SECRET (or ZEEBE_CLIENT_SECRET), " +
+            "CAMUNDA_OAUTH_URL (or ZEEBE_AUTHORIZATION_SERVER_URL).");
+    }
+    return { baseUrl, auth: { type: "oauth2", clientId, clientSecret, tokenUrl, audience } };
+}
+/** Read all of stdin as a string. */
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+// ─── Auth builder ─────────────────────────────────────────────────────────────
+function buildAuth(flags) {
+    const type = flags["auth-type"];
+    switch (type) {
+        case "bearer": {
+            const token = flags.token;
+            if (!token)
+                throw new Error("--token is required for --auth-type bearer");
+            return { type: "bearer", token };
+        }
+        case "oauth2": {
+            const clientId = flags["client-id"];
+            const clientSecret = flags["client-secret"];
+            const tokenUrl = flags["token-url"];
+            if (!clientId || !clientSecret || !tokenUrl) {
+                throw new Error("--client-id, --client-secret, and --token-url are required for --auth-type oauth2");
+            }
+            const audience = flags.audience ?? "zeebe.camunda.io";
+            return { type: "oauth2", clientId, clientSecret, tokenUrl, audience };
+        }
+        case "basic": {
+            const username = flags.username;
+            const password = flags.password;
+            if (!username || !password)
+                throw new Error("--username and --password are required for --auth-type basic");
+            return { type: "basic", username, password };
+        }
+        case "none":
+            return { type: "none" };
+        default:
+            throw new Error(`Unknown --auth-type "${type}". Valid: bearer|oauth2|basic|none`);
+    }
+}
+export const profileGroup = {
+    name: "profile",
+    description: "Manage connection profiles",
+    commands: [
+        {
+            name: "create",
+            description: "Create or update a profile",
+            args: [{ name: "name", description: "Profile name", required: true }],
+            flags: [API_TYPE_FLAG, ...AUTH_FLAGS],
+            examples: [
+                {
+                    description: "Bearer token profile",
+                    command: "casen profile create local --base-url http://localhost:8080/v2 --auth-type bearer --token my-token",
+                },
+                {
+                    description: "OAuth2 profile for Camunda SaaS",
+                    command: "casen profile create prod --base-url https://cluster.camunda.io/v2 --auth-type oauth2 --client-id id --client-secret secret --token-url https://login.cloud.camunda.io/oauth/token",
+                },
+                {
+                    description: "Admin API profile",
+                    command: "casen profile create admin-prod --api-type admin --base-url https://api.cloud.camunda.io --auth-type oauth2 --client-id id --client-secret secret --token-url https://login.cloud.camunda.io/oauth/token",
+                },
+            ],
+            async run(ctx) {
+                const name = ctx.positional[0];
+                if (!name)
+                    throw new Error("Missing required argument: <name>");
+                const baseUrl = ctx.flags["base-url"];
+                if (!baseUrl)
+                    throw new Error("--base-url is required");
+                const auth = buildAuth(ctx.flags);
+                const rawApiType = ctx.flags["api-type"] ?? "c8";
+                const apiType = rawApiType === "admin" ? "admin" : "c8";
+                const config = { baseUrl, auth };
+                saveProfile(name, config, apiType);
+                ctx.output.ok(`Profile "${name}" saved [${apiType}] (${getConfigFilePath()})`);
+            },
+        },
+        {
+            name: "list",
+            aliases: ["ls"],
+            description: "List all profiles",
+            examples: [{ description: "List profiles", command: "casen profile list" }],
+            async run(ctx) {
+                const profiles = listProfiles();
+                const active = getActiveName();
+                if (profiles.length === 0) {
+                    ctx.output.info("No profiles. Create one with: casen profile create <name> ...");
+                    return;
+                }
+                ctx.output.printList({
+                    items: profiles.map((p) => ({
+                        active: p.name === active ? "●" : " ",
+                        name: p.name,
+                        apiType: p.apiType,
+                        baseUrl: p.config.baseUrl ?? "(from env/file)",
+                        authType: p.config.auth?.type ?? "—",
+                    })),
+                }, [
+                    { key: "active", header: " " },
+                    { key: "name", header: "NAME" },
+                    { key: "apiType", header: "API" },
+                    { key: "baseUrl", header: "BASE URL", maxWidth: 50 },
+                    { key: "authType", header: "AUTH TYPE" },
+                ]);
+            },
+        },
+        {
+            name: "use",
+            description: "Switch the active profile",
+            args: [{ name: "name", description: "Profile name", required: true }],
+            examples: [
+                { description: "Activate production profile", command: "casen profile use production" },
+            ],
+            async run(ctx) {
+                const name = ctx.positional[0];
+                if (!name)
+                    throw new Error("Missing required argument: <name>");
+                if (!useProfile(name)) {
+                    throw new Error(`Profile "${name}" not found. Run \`casen profile list\` to see available profiles.`);
+                }
+                ctx.output.ok(`Now using profile "${name}"`);
+            },
+        },
+        {
+            name: "show",
+            description: "Show profile details",
+            args: [{ name: "name", description: "Profile name (defaults to active)", required: false }],
+            examples: [
+                { description: "Show active profile", command: "casen profile show" },
+                { description: "Show specific profile", command: "casen profile show production" },
+            ],
+            async run(ctx) {
+                const name = ctx.positional[0];
+                const profile = name ? getProfile(name) : getActiveProfile();
+                if (!profile) {
+                    throw new Error(name
+                        ? `Profile "${name}" not found.`
+                        : "No active profile. Create one with: casen profile create <name> ...");
+                }
+                const active = getActiveName();
+                const isActive = profile.name === active;
+                ctx.output.info(`Profile: ${profile.name}${isActive ? " (active)" : ""}`);
+                ctx.output.printItem(profile.config);
+            },
+        },
+        {
+            name: "import",
+            description: "Import a profile from a Camunda Cloud or Console credentials file (auto-detected)",
+            args: [
+                { name: "name", description: "Profile name", required: true },
+                {
+                    name: "file",
+                    description: "Path to credentials file (use - for stdin)",
+                    required: true,
+                },
+            ],
+            examples: [
+                {
+                    description: "Import C8 credentials",
+                    command: "casen profile import prod ./camunda-credentials.sh",
+                },
+                {
+                    description: "Import Admin API credentials",
+                    command: "casen profile import admin ./console-credentials.sh",
+                },
+                {
+                    description: "Import from stdin",
+                    command: "cat credentials.sh | casen profile import prod -",
+                },
+            ],
+            async run(ctx) {
+                const name = ctx.positional[0];
+                if (!name)
+                    throw new Error("Missing required argument: <name>");
+                const filePath = ctx.positional[1];
+                if (!filePath)
+                    throw new Error("Missing required argument: <file>");
+                const content = filePath === "-" ? await readStdin() : readFileSync(filePath, "utf8");
+                const env = parseEnvFile(content);
+                const apiType = detectApiType(env);
+                const config = apiType === "admin" ? configFromConsoleEnv(env) : configFromCloudEnv(env);
+                saveProfile(name, config, apiType);
+                ctx.output.ok(`Profile "${name}" imported [${apiType}] (${getConfigFilePath()})`);
+                ctx.output.info(`baseUrl: ${config.baseUrl ?? ""}`);
+            },
+        },
+        {
+            name: "delete",
+            aliases: ["rm"],
+            description: "Delete a profile",
+            args: [{ name: "name", description: "Profile name", required: true }],
+            examples: [{ description: "Delete a profile", command: "casen profile delete old-profile" }],
+            async run(ctx) {
+                const name = ctx.positional[0];
+                if (!name)
+                    throw new Error("Missing required argument: <name>");
+                if (!deleteProfile(name)) {
+                    throw new Error(`Profile "${name}" not found.`);
+                }
+                ctx.output.ok(`Deleted profile "${name}"`);
+            },
+        },
+    ],
+};
+//# sourceMappingURL=profile.js.map

package/dist/commands/relations.js

@@ -0,0 +1,28 @@
+import { buildRelations } from "@bpmnkit/api";
+/**
+ * Auto-detect follow-up relations between commands using the shared
+ * buildRelations() from @bpmnkit/api. Converts CommandGroups to generic
+ * RelationSources, computes the graph, and wires results back to commands.
+ * Mutates commands in-place.
+ */
+export function computeRelations(allGroups) {
+    // Convert to generic RelationSources
+    const sources = allGroups.flatMap((group) => group.commands.map((cmd) => ({
+        groupName: group.name,
+        commandName: cmd.name,
+        description: cmd.description,
+        outputFields: cmd.columns?.map((c) => c.key) ?? [],
+        inputParams: cmd.args?.map((a) => a.name) ?? [],
+    })));
+    const relationsMap = buildRelations(sources);
+    // Apply results back to commands
+    for (const group of allGroups) {
+        for (const cmd of group.commands) {
+            const relations = relationsMap.get(`${group.name}/${cmd.name}`);
+            if (relations) {
+                cmd.relations = relations;
+            }
+        }
+    }
+}
+//# sourceMappingURL=relations.js.map