primitive-admin 1.0.0

package/dist/src/commands/workflows.js

@@ -0,0 +1,876 @@
+import { readFileSync } from "fs";
+import * as TOML from "@iarna/toml";
+import { ApiClient } from "../lib/api-client.js";
+import { getCurrentAppId } from "../lib/config.js";
+import { success, error, info, keyValue, formatTable, formatId, formatDate, formatStatus, formatDuration, json, divider, } from "../lib/output.js";
+function resolveAppId(appId, options) {
+    const resolved = appId || options.app || getCurrentAppId();
+    if (!resolved) {
+        error("No app specified. Use <app-id>, --app, or 'primitive use <app-id>' to set context.");
+        process.exit(1);
+    }
+    return resolved;
+}
+export function registerWorkflowsCommands(program) {
+    const workflows = program
+        .command("workflows")
+        .description("Build multi-step workflows, publish revisions, and monitor runs")
+        .addHelpText("after", `
+Examples:
+  $ primitive workflows list
+  $ primitive workflows create --from-file process-doc.toml
+  $ primitive workflows publish 01HXY...
+  $ primitive workflows runs list 01HXY...
+`);
+    // List workflows
+    workflows
+        .command("list")
+        .description("List workflows")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--status <status>", "Filter by status: draft, active, archived")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listWorkflows(resolvedAppId, {
+                status: options.status,
+            });
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No workflows found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "ID", key: "workflowId", format: formatId },
+                { header: "KEY", key: "workflowKey" },
+                { header: "NAME", key: "name" },
+                { header: "STATUS", key: "status", format: formatStatus },
+                { header: "MODIFIED", key: "modifiedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create workflow
+    workflows
+        .command("create")
+        .description("Create a new workflow")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID")
+        .option("--key <key>", "Workflow key (unique identifier)")
+        .option("--name <name>", "Display name")
+        .option("--description <desc>", "Description")
+        .option("--from-file <path>", "Load workflow from TOML file")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        let payload;
+        if (options.fromFile) {
+            try {
+                const content = readFileSync(options.fromFile, "utf-8");
+                const tomlData = TOML.parse(content);
+                const workflow = tomlData.workflow || tomlData;
+                payload = {
+                    workflowKey: workflow.key || workflow.workflowKey,
+                    name: workflow.name,
+                    description: workflow.description,
+                    steps: tomlData.steps || [],
+                    inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : undefined,
+                    outputSchema: workflow.outputSchema ? JSON.parse(workflow.outputSchema) : undefined,
+                    perUserMaxRunning: workflow.perUserMaxRunning,
+                    perUserMaxQueued: workflow.perUserMaxQueued,
+                    perAppMaxRunning: workflow.perAppMaxRunning,
+                    perAppMaxQueued: workflow.perAppMaxQueued,
+                    queueTtlSeconds: workflow.queueTtlSeconds,
+                    dequeueOrder: workflow.dequeueOrder,
+                };
+            }
+            catch (err) {
+                error(`Failed to read TOML file: ${err.message}`);
+                process.exit(1);
+            }
+        }
+        else {
+            if (!options.key || !options.name) {
+                error("Required: --key, --name (or use --from-file)");
+                process.exit(1);
+            }
+            payload = {
+                workflowKey: options.key,
+                name: options.name,
+                description: options.description,
+                steps: [],
+            };
+        }
+        try {
+            const result = await client.createWorkflow(resolvedAppId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Workflow created: ${result.workflow?.name || options.name}`);
+            keyValue("Workflow ID", result.workflow?.workflowId);
+            keyValue("Key", result.workflow?.workflowKey);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get workflow
+    workflows
+        .command("get")
+        .description("Get workflow details")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getWorkflow(resolvedAppId, workflowId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const wf = result.workflow;
+            keyValue("Workflow ID", wf.workflowId);
+            keyValue("Key", wf.workflowKey);
+            keyValue("Name", wf.name);
+            keyValue("Description", wf.description);
+            keyValue("Status", formatStatus(wf.status));
+            keyValue("Latest Revision", wf.latestRevision || "-");
+            divider();
+            info("Queue Settings:");
+            keyValue("  Per User Max Running", wf.perUserMaxRunning);
+            keyValue("  Per User Max Queued", wf.perUserMaxQueued);
+            keyValue("  Per App Max Running", wf.perAppMaxRunning);
+            keyValue("  Dequeue Order", wf.dequeueOrder);
+            if (result.draft?.steps) {
+                divider();
+                info(`Draft Steps (${result.draft.steps.length}):`);
+                result.draft.steps.forEach((step, idx) => {
+                    console.log(`  ${idx + 1}. ${step.id} (${step.kind})`);
+                });
+            }
+            if (result.revisions && result.revisions.length > 0) {
+                divider();
+                info(`Revisions (${result.revisions.length}):`);
+                console.log(formatTable(result.revisions.slice(0, 5), [
+                    { header: "ID", key: "revisionId", format: formatId },
+                    { header: "PUBLISHED", key: "publishedAt", format: formatDate },
+                ]));
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update workflow
+    workflows
+        .command("update")
+        .description("Update workflow metadata")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Display name")
+        .option("--description <desc>", "Description")
+        .option("--status <status>", "Status: draft, active, archived")
+        .option("--per-user-max-running <n>", "Max running per user")
+        .option("--per-user-max-queued <n>", "Max queued per user")
+        .option("--dequeue-order <order>", "Dequeue order: fifo, lifo")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const payload = {};
+        if (options.name)
+            payload.name = options.name;
+        if (options.description)
+            payload.description = options.description;
+        if (options.status)
+            payload.status = options.status;
+        if (options.perUserMaxRunning)
+            payload.perUserMaxRunning = parseInt(options.perUserMaxRunning);
+        if (options.perUserMaxQueued)
+            payload.perUserMaxQueued = parseInt(options.perUserMaxQueued);
+        if (options.dequeueOrder)
+            payload.dequeueOrder = options.dequeueOrder;
+        if (Object.keys(payload).length === 0) {
+            error("No update options specified.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.updateWorkflow(resolvedAppId, workflowId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Workflow updated.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete workflow
+    workflows
+        .command("delete")
+        .description("Delete or archive a workflow")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--hard", "Permanently delete instead of archive")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const action = options.hard ? "permanently delete" : "archive";
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to ${action} workflow ${workflowId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            if (options.hard) {
+                await client.deleteWorkflow(resolvedAppId, workflowId);
+                success("Workflow deleted.");
+            }
+            else {
+                await client.updateWorkflow(resolvedAppId, workflowId, { status: "archived" });
+                success("Workflow archived.");
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Draft subcommand
+    const draft = workflows.command("draft").description("Manage workflow draft");
+    // Update draft
+    draft
+        .command("update")
+        .description("Update workflow draft steps")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--from-file <path>", "Load steps from TOML file")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.fromFile) {
+            error("--from-file is required");
+            process.exit(1);
+        }
+        let payload;
+        try {
+            const content = readFileSync(options.fromFile, "utf-8");
+            const tomlData = TOML.parse(content);
+            const workflow = tomlData.workflow || tomlData;
+            payload = {
+                steps: tomlData.steps || [],
+                inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : undefined,
+                outputSchema: workflow.outputSchema ? JSON.parse(workflow.outputSchema) : undefined,
+            };
+        }
+        catch (err) {
+            error(`Failed to read TOML file: ${err.message}`);
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.updateWorkflowDraft(resolvedAppId, workflowId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Draft updated.");
+            keyValue("Steps", result.draft?.steps?.length || 0);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Publish workflow
+    workflows
+        .command("publish")
+        .description("Publish the current draft as a new revision")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.publishWorkflow(resolvedAppId, workflowId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Workflow published.");
+            keyValue("Revision ID", result.revision?.revisionId);
+            keyValue("Published At", formatDate(result.revision?.publishedAt));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Preview workflow
+    workflows
+        .command("preview")
+        .description("Run a preview execution of the workflow draft")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--input <json>", "Root input as JSON")
+        .option("--wait", "Wait for completion and show result")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        let rootInput;
+        if (options.input) {
+            try {
+                rootInput = JSON.parse(options.input);
+            }
+            catch {
+                error("Invalid JSON in --input");
+                process.exit(1);
+            }
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.previewWorkflow(resolvedAppId, workflowId, {
+                rootInput,
+            });
+            if (!options.wait) {
+                if (options.json) {
+                    json(result);
+                    return;
+                }
+                success("Preview started.");
+                keyValue("Instance ID", result.instanceId);
+                info("Use 'workflows runs status' to check progress.");
+                return;
+            }
+            // Poll for completion
+            info("Waiting for completion...");
+            let status;
+            const maxAttempts = 60;
+            for (let i = 0; i < maxAttempts; i++) {
+                await new Promise((r) => setTimeout(r, 1000));
+                const statusResult = await client.getPreviewStatus(resolvedAppId, workflowId, result.instanceId);
+                status = statusResult.status;
+                if (status?.status === "completed" || status?.status === "failed") {
+                    break;
+                }
+            }
+            if (options.json) {
+                json({ instanceId: result.instanceId, status });
+                return;
+            }
+            if (status?.status === "completed") {
+                success("Preview completed.");
+                if (status.output) {
+                    console.log("\nOutput:");
+                    console.log(JSON.stringify(status.output, null, 2));
+                }
+                if (status.stepResults) {
+                    divider();
+                    info("Step Results:");
+                    status.stepResults.forEach((step) => {
+                        console.log(`  ${step.id}: ${formatDuration(step.durationMs)} ${step.skipped ? "(skipped)" : ""}`);
+                    });
+                }
+            }
+            else if (status?.status === "failed") {
+                error("Preview failed.");
+                if (status.error) {
+                    console.log("\nError:");
+                    console.log(JSON.stringify(status.error, null, 2));
+                }
+            }
+            else {
+                info("Preview still running. Check status with 'workflows runs status'.");
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Runs subcommand
+    const runs = workflows.command("runs").description("Manage workflow runs");
+    // List runs
+    runs
+        .command("list")
+        .description("List workflow runs")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--status <status>", "Filter by status: pending, running, completed, failed")
+        .option("--limit <n>", "Number of runs to show", "20")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listWorkflowRuns(resolvedAppId, workflowId, {
+                status: options.status,
+                limit: parseInt(options.limit),
+            });
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No runs found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "RUN ID", key: "runId", format: formatId },
+                { header: "STATUS", key: "status", format: formatStatus },
+                { header: "STARTED", key: "startedAt", format: formatDate },
+                { header: "ENDED", key: "endedAt", format: formatDate },
+                { header: "PREVIEW", key: "isPreview", format: (v) => v ? "yes" : "" },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run status
+    runs
+        .command("status")
+        .description("Get status of a workflow run")
+        .argument("<workflow-id>", "Workflow ID")
+        .argument("<run-id>", "Run ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, runId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getWorkflowRunStatus(resolvedAppId, workflowId, runId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const run = result.run;
+            keyValue("Run ID", run.runId);
+            keyValue("Status", formatStatus(run.status));
+            keyValue("Started", formatDate(run.startedAt));
+            keyValue("Ended", formatDate(run.endedAt));
+            keyValue("Preview", run.isPreview ? "yes" : "no");
+            if (result.instanceStatus) {
+                const status = result.instanceStatus;
+                if (status.output) {
+                    divider();
+                    info("Output:");
+                    console.log(JSON.stringify(status.output, null, 2));
+                }
+                if (status.stepResults && status.stepResults.length > 0) {
+                    divider();
+                    info("Step Results:");
+                    status.stepResults.forEach((step) => {
+                        console.log(`  ${step.id}: ${formatDuration(step.durationMs)} ${step.skipped ? "(skipped)" : ""}`);
+                    });
+                }
+                if (status.error) {
+                    divider();
+                    error("Error:");
+                    console.log(JSON.stringify(status.error, null, 2));
+                }
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ============================================
+    // TESTS SUBCOMMAND
+    // ============================================
+    const tests = workflows
+        .command("tests")
+        .description("Manage and run workflow test cases")
+        .addHelpText("after", `
+Examples:
+  $ primitive workflows tests list <workflow-id>
+  $ primitive workflows tests create <workflow-id> --name "Basic test" --vars '{"input":"hello"}'
+  $ primitive workflows tests run <workflow-id> <test-case-id>
+  $ primitive workflows tests run-all <workflow-id>
+`);
+    // List test cases
+    tests
+        .command("list")
+        .description("List test cases for a workflow")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listTestCases(resolvedAppId, "workflow", workflowId);
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No test cases found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "ID", key: "testCaseId", format: formatId },
+                { header: "NAME", key: "name" },
+                { header: "CREATED", key: "createdAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Create test case
+    tests
+        .command("create")
+        .description("Create a test case for a workflow")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Test case name (required)")
+        .option("--vars <json>", "Input variables as JSON (required)")
+        .option("--pattern <regex>", "Expected output pattern (regex)")
+        .option("--contains <json>", "Expected strings to contain (JSON array)")
+        .option("--json-subset <json>", "Expected JSON subset to match")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.name || !options.vars) {
+            error("Required: --name and --vars");
+            process.exit(1);
+        }
+        let inputVariables;
+        try {
+            inputVariables = JSON.parse(options.vars);
+        }
+        catch {
+            error("Invalid JSON in --vars");
+            process.exit(1);
+        }
+        let expectedOutputContains;
+        if (options.contains) {
+            try {
+                expectedOutputContains = JSON.parse(options.contains);
+            }
+            catch {
+                error("Invalid JSON in --contains");
+                process.exit(1);
+            }
+        }
+        let expectedJsonSubset;
+        if (options.jsonSubset) {
+            try {
+                expectedJsonSubset = JSON.parse(options.jsonSubset);
+            }
+            catch {
+                error("Invalid JSON in --json-subset");
+                process.exit(1);
+            }
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.createTestCase(resolvedAppId, "workflow", workflowId, {
+                name: options.name,
+                inputVariables,
+                expectedOutputPattern: options.pattern,
+                expectedOutputContains,
+                expectedJsonSubset,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success(`Test case created: ${result.name}`);
+            keyValue("Test Case ID", result.testCaseId);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get test case
+    tests
+        .command("get")
+        .description("Get test case details")
+        .argument("<workflow-id>", "Workflow ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const result = await client.getTestCase(resolvedAppId, "workflow", workflowId, testCaseId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            keyValue("Test Case ID", result.testCaseId);
+            keyValue("Name", result.name);
+            keyValue("Created", formatDate(result.createdAt));
+            divider();
+            info("Input Variables:");
+            try {
+                const vars = JSON.parse(result.inputVariables || "{}");
+                console.log(JSON.stringify(vars, null, 2));
+            }
+            catch {
+                console.log(result.inputVariables || "{}");
+            }
+            if (result.expectedOutputPattern) {
+                divider();
+                keyValue("Expected Pattern", result.expectedOutputPattern);
+            }
+            if (result.expectedOutputContains) {
+                divider();
+                info("Expected Contains:");
+                try {
+                    console.log(JSON.stringify(JSON.parse(result.expectedOutputContains), null, 2));
+                }
+                catch {
+                    console.log(result.expectedOutputContains);
+                }
+            }
+            if (result.expectedJsonSubset) {
+                divider();
+                info("Expected JSON Subset:");
+                try {
+                    console.log(JSON.stringify(JSON.parse(result.expectedJsonSubset), null, 2));
+                }
+                catch {
+                    console.log(result.expectedJsonSubset);
+                }
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete test case
+    tests
+        .command("delete")
+        .description("Delete a test case")
+        .argument("<workflow-id>", "Workflow ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .action(async (workflowId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            const inquirer = await import("inquirer");
+            const { confirm } = await inquirer.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to delete test case ${testCaseId}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.deleteTestCase(resolvedAppId, "workflow", workflowId, testCaseId);
+            success("Test case deleted.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run a single test case
+    tests
+        .command("run")
+        .description("Run a single test case")
+        .argument("<workflow-id>", "Workflow ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            // Get test case to retrieve its variables
+            const testCase = await client.getTestCase(resolvedAppId, "workflow", workflowId, testCaseId);
+            let variables = {};
+            try {
+                variables = JSON.parse(testCase.inputVariables || "{}");
+            }
+            catch {
+                // Use empty object if parsing fails
+            }
+            const result = await client.executeBlockTest(resolvedAppId, "workflow", workflowId, {
+                variables,
+                testCaseId,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const passed = result.verification?.passed;
+            if (passed) {
+                success("Test PASSED");
+            }
+            else {
+                error("Test FAILED");
+            }
+            keyValue("Duration", formatDuration(result.metrics?.durationMs));
+            if (result.verification) {
+                divider();
+                info("Verification:");
+                const v = result.verification;
+                keyValue("  Passed", v.passed ? "Yes" : "No");
+                keyValue("  Checks", `${v.summary?.passed || 0}/${v.summary?.total || 0} passed`);
+                if (v.checks && v.checks.length > 0) {
+                    console.log();
+                    for (const check of v.checks) {
+                        const icon = check.passed ? "✓" : "✗";
+                        console.log(`  ${icon} ${check.name}`);
+                        if (!check.passed && check.message) {
+                            console.log(`    ${check.message}`);
+                        }
+                    }
+                }
+            }
+            if (result.output) {
+                divider();
+                info("Output:");
+                console.log(typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2));
+            }
+            if (result.error) {
+                divider();
+                error(`Error: ${result.error}`);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run all test cases
+    tests
+        .command("run-all")
+        .description("Run all test cases for a workflow")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            if (!options.json) {
+                info("Running all test cases...");
+            }
+            const result = await client.runAllTestCases(resolvedAppId, "workflow", workflowId, {});
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const { summary, results, comparisonGroup } = result;
+            divider();
+            keyValue("Comparison Group", comparisonGroup);
+            keyValue("Total Tests", summary.total);
+            keyValue("Passed", summary.passed);
+            keyValue("Failed", summary.failed);
+            divider();
+            if (results && results.length > 0) {
+                for (const r of results) {
+                    const passed = r.verification?.passed;
+                    const icon = passed ? "✓" : "✗";
+                    const status = passed ? "PASSED" : "FAILED";
+                    console.log(`${icon} ${r.testCaseName} - ${status}`);
+                    if (!passed && r.verification?.details?.reason) {
+                        console.log(`  ${r.verification.details.reason}`);
+                    }
+                }
+            }
+            // Exit with error code if any tests failed
+            if (summary.failed > 0) {
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // List test runs
+    tests
+        .command("runs")
+        .description("List recent test runs for a workflow")
+        .argument("<workflow-id>", "Workflow ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--limit <n>", "Maximum number of runs to show", "20")
+        .option("--group <group>", "Filter by comparison group")
+        .option("--json", "Output as JSON")
+        .action(async (workflowId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listTestRuns(resolvedAppId, "workflow", workflowId, {
+                limit: parseInt(options.limit),
+                comparisonGroup: options.group,
+            });
+            if (options.json) {
+                json(items);
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No test runs found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "RUN ID", key: "runId", format: formatId },
+                { header: "TEST CASE ID", key: "testCaseId", format: (v) => v ? formatId(v) : "-" },
+                {
+                    header: "PASSED",
+                    key: "verificationPassed",
+                    format: (v) => v === true
+                        ? "Yes"
+                        : v === false
+                            ? "No"
+                            : "-",
+                },
+                { header: "DURATION", key: "durationMs", format: formatDuration },
+                { header: "STARTED", key: "startedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=workflows.js.map