primitive-admin 1.1.0-alpha.4 → 1.1.0-alpha.40

package/dist/src/commands/integrations.js

@@ -1,8 +1,10 @@
 import { readFileSync } from "fs";
 import * as TOML from "@iarna/toml";
+import chalk from "chalk";
 import { ApiClient } from "../lib/api-client.js";
 import { resolveAppId } from "../lib/config.js";
-import { success, error, info, keyValue, formatTable, formatId, formatDate, formatStatus, formatDuration, json, divider, } from "../lib/output.js";
+import { success, error, info, warn, keyValue, result as printResult, formatTable, formatId, formatDate, formatStatus, formatDuration, json, divider, } from "../lib/output.js";
+import { confirmPrompt } from "../lib/confirm-prompt.js";
 export function registerIntegrationsCommands(program) {
     const integrations = program
         .command("integrations")
@@ -12,7 +14,10 @@ Examples:
   $ primitive integrations list
   $ primitive integrations create --from-file weather-api.toml
   $ primitive integrations test 01HXY...
-  $ primitive integrations secrets add 01HXY... --data '{"apiKey":"..."}'
+
+Storing secrets for an integration (integration secrets are deprecated):
+  $ primitive secrets set MY_API_KEY --value <value>
+  # then reference it in integration config via {{secrets.MY_API_KEY}}
 `);
     // List integrations
     integrations
@@ -134,24 +139,24 @@ Examples:
                 json(result);
                 return;
             }
-            keyValue("Integration ID", result.integrationId);
-            keyValue("Key", result.integrationKey);
-            keyValue("Name", result.displayName);
-            keyValue("Description", result.description);
-            keyValue("Status", formatStatus(result.status));
-            keyValue("Timeout", result.timeoutMs ? `${result.timeoutMs}ms` : "-");
+            printResult("Integration ID", result.integrationId);
+            printResult("Key", result.integrationKey);
+            printResult("Name", result.displayName);
+            printResult("Description", result.description);
+            printResult("Status", formatStatus(result.status));
+            printResult("Timeout", result.timeoutMs ? `${result.timeoutMs}ms` : "-");
             if (result.requestConfig) {
                 divider();
                 info("Request Config:");
-                keyValue("  Base URL", result.requestConfig.baseUrl);
-                keyValue("  Allowed Methods", result.requestConfig.allowedMethods?.join(", ") || "all");
-                keyValue("  Allowed Paths", result.requestConfig.allowedPaths?.join(", ") || "all");
-                keyValue("  Response Passthrough", result.requestConfig.responsePassthrough);
+                printResult("  Base URL", result.requestConfig.baseUrl);
+                printResult("  Allowed Methods", result.requestConfig.allowedMethods?.join(", ") || "all");
+                printResult("  Allowed Paths", result.requestConfig.allowedPaths?.join(", ") || "all");
+                printResult("  Response Passthrough", result.requestConfig.responsePassthrough);
                 if (result.requestConfig.bodyMode) {
-                    keyValue("  Body Mode", result.requestConfig.bodyMode);
+                    printResult("  Body Mode", result.requestConfig.bodyMode);
                 }
                 if (result.requestConfig.multipartFieldMapping?.length) {
-                    keyValue("  Multipart Fields", result.requestConfig.multipartFieldMapping
+                    printResult("  Multipart Fields", result.requestConfig.multipartFieldMapping
                         .map((f) => `${f.fieldName} (${f.type}${f.attachmentIndex != null ? `, attachment[${f.attachmentIndex}]` : ""})`)
                         .join(", "));
                 }
@@ -214,15 +219,14 @@ Examples:
         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} integration ${integrationId}?`,
-                    default: false,
-                },
-            ]);
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Are you sure you want to ${action} integration ${integrationId}?`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
             if (!confirm) {
                 info("Cancelled.");
                 return;
@@ -304,17 +308,24 @@ Examples:
     // List integration logs
     integrations
         .command("logs")
-        .description("View integration request logs")
+        .description("View integration request logs (includes workflow-initiated calls; filter with --source workflow|user|admin|test)")
         .argument("<integration-id>", "Integration ID")
         .option("--app <app-id>", "App ID (uses current app if not specified)")
         .option("--limit <n>", "Number of logs to show", "20")
+        .option("--source <source>", "Filter by call source: user, admin, test, or workflow")
         .option("--json", "Output as JSON")
         .action(async (integrationId, options) => {
         const resolvedAppId = resolveAppId(undefined, options);
         const client = new ApiClient();
         try {
+            const validSources = new Set(["user", "admin", "test", "workflow"]);
+            if (options.source && !validSources.has(options.source)) {
+                error(`Invalid --source value '${options.source}'. Must be one of: user, admin, test, workflow.`);
+                process.exit(1);
+            }
             const logs = await client.listIntegrationLogs(resolvedAppId, integrationId, {
                 limit: parseInt(options.limit),
+                ...(options.source && { source: options.source }),
             });
             if (options.json) {
                 json(logs);
@@ -326,10 +337,13 @@ Examples:
             }
             console.log(formatTable(logs, [
                 { header: "TIME", key: "timestamp", format: formatDate },
+                { header: "SOURCE", key: "source", format: (v) => v || "user" },
                 { header: "METHOD", key: "method" },
                 { header: "PATH", key: "path" },
                 { header: "STATUS", key: "status" },
                 { header: "DURATION", key: "durationMs", format: formatDuration },
+                { header: "WORKFLOW", key: "workflowKey", format: (v) => v || "" },
+                { header: "RUN", key: "runId", format: (v) => (v ? formatId(v) : "") },
                 { header: "TRACE", key: "traceId", format: formatId },
             ]));
         }
@@ -339,7 +353,16 @@ Examples:
         }
     });
     // Secrets subcommand
-    const secrets = integrations.command("secrets").description("Manage integration secrets");
+    //
+    // Integration secrets are deprecated. New secrets can no longer be created
+    // (the `add` subcommand below is hidden from help and the command manifest,
+    // but kept registered so scripted callers still get a clear deprecation
+    // error — see issue #1026). The modern path is App Secrets:
+    //   primitive secrets set <key> --value <value>
+    // then reference them in integration config via {{secrets.KEY}}.
+    const secrets = integrations
+        .command("secrets")
+        .description("Manage integration secrets (deprecated — use `primitive secrets set` and reference {{secrets.KEY}} in integration config instead)");
     // List secrets
     secrets
         .command("list")
@@ -351,6 +374,7 @@ Examples:
         const resolvedAppId = resolveAppId(undefined, options);
         const client = new ApiClient();
         try {
+            warn("Integration secrets are deprecated. Use App Secrets with {{secrets.KEY}} templates instead.");
             const secretsList = await client.listIntegrationSecrets(resolvedAppId, integrationId);
             if (options.json) {
                 json(secretsList);
@@ -374,60 +398,523 @@ Examples:
         }
     });
     // Add secret
+    //
+    // Deprecated and disabled: hidden from `--help` and the command manifest
+    // (issue #1026) so the CLI no longer advertises a command that can never
+    // succeed, but still registered so an explicit/scripted invocation gets the
+    // clear deprecation error below rather than an "unknown command" error.
     secrets
-        .command("add")
-        .description("Add a secret to an integration")
+        .command("add", { hidden: true })
+        .description("Add a secret to an integration (deprecated — use `primitive secrets set`)")
         .argument("<integration-id>", "Integration ID")
         .option("--app <app-id>", "App ID (uses current app if not specified)")
         .option("--data <json>", "Secret data as JSON (e.g., '{\"apiKey\":\"...\"}' )")
         .option("--summary <text>", "Description of the secret")
         .option("--json", "Output as JSON")
+        .action(async () => {
+        error("Integration secrets are deprecated and can no longer be created.");
+        info("Use App Secrets with {{secrets.KEY}} templates in defaultHeaders or staticQuery instead.");
+        info("See: primitive secrets set <key> --value <value>");
+        process.exit(1);
+    });
+    // Archive secret
+    secrets
+        .command("archive")
+        .description("Archive a secret")
+        .argument("<integration-id>", "Integration ID")
+        .argument("<secret-id>", "Secret ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .action(async (integrationId, secretId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            await client.archiveIntegrationSecret(resolvedAppId, integrationId, secretId);
+            success("Secret archived.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ============================================
+    // TESTS SUBCOMMAND
+    // ============================================
+    const tests = integrations
+        .command("tests")
+        .description("Manage and run integration test cases")
+        .addHelpText("after", `
+Examples:
+  $ primitive integrations tests list <integration-id>
+  $ primitive integrations tests create <integration-id> --name "Basic test" --input '{"method":"GET","path":"/get"}'
+  $ primitive integrations tests run <integration-id> <test-case-id>
+  $ primitive integrations tests run-all <integration-id>
+  $ primitive integrations tests run-all <integration-id> --test-cases 01ABC,01DEF,01GHI
+`);
+    // List test cases
+    tests
+        .command("list")
+        .description("List test cases for an integration")
+        .argument("<integration-id>", "Integration ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (integrationId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listTestCases(resolvedAppId, "integration", integrationId);
+            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: "CONFIG", key: "configId", format: (v) => v ? formatId(v) : "-" },
+                { 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 an integration")
+        .argument("<integration-id>", "Integration ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Test case name (required)")
+        .option("--input <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("--config <config-id>", "Config ID to use for this test")
+        .option("--evaluator-prompt <prompt-id>", "Evaluator prompt ID")
+        .option("--evaluator-config <config-id>", "Evaluator config ID")
+        .option("--json", "Output as JSON")
         .action(async (integrationId, options) => {
         const resolvedAppId = resolveAppId(undefined, options);
-        if (!options.data) {
-            error("--data is required (JSON object with secret values)");
+        if (!options.name || !options.input) {
+            error("Required: --name and --input");
             process.exit(1);
         }
-        let secretData;
+        let inputVariables;
         try {
-            secretData = JSON.parse(options.data);
+            inputVariables = JSON.parse(options.input);
         }
         catch {
-            error("Invalid JSON in --data");
+            error("Invalid JSON in --input");
             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.addIntegrationSecret(resolvedAppId, integrationId, {
-                secretData,
-                secretSummary: options.summary,
+            const result = await client.createTestCase(resolvedAppId, "integration", integrationId, {
+                name: options.name,
+                inputVariables,
+                expectedOutputPattern: options.pattern,
+                expectedOutputContains,
+                expectedJsonSubset,
+                configId: options.config,
+                evaluatorPromptId: options.evaluatorPrompt,
+                evaluatorConfigId: options.evaluatorConfig,
             });
             if (options.json) {
                 json(result);
                 return;
             }
-            success("Secret added.");
-            keyValue("Secret ID", result?.secretId);
-            keyValue("Version", result?.version);
+            success(`Test case created: ${result.name}`);
+            keyValue("Test Case ID", result.testCaseId);
         }
         catch (err) {
             error(err.message);
             process.exit(1);
         }
     });
-    // Archive secret
-    secrets
-        .command("archive")
-        .description("Archive a secret")
+    // Get test case
+    tests
+        .command("get")
+        .description("Get test case details")
         .argument("<integration-id>", "Integration ID")
-        .argument("<secret-id>", "Secret ID")
+        .argument("<test-case-id>", "Test Case ID")
         .option("--app <app-id>", "App ID (uses current app if not specified)")
-        .action(async (integrationId, secretId, options) => {
+        .option("--json", "Output as JSON")
+        .action(async (integrationId, testCaseId, options) => {
         const resolvedAppId = resolveAppId(undefined, options);
         const client = new ApiClient();
         try {
-            await client.archiveIntegrationSecret(resolvedAppId, integrationId, secretId);
-            success("Secret archived.");
+            const result = await client.getTestCase(resolvedAppId, "integration", integrationId, testCaseId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            printResult("Test Case ID", result.testCaseId);
+            printResult("Name", result.name);
+            printResult("Config ID", result.configId || "-");
+            printResult("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();
+                printResult("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);
+                }
+            }
+            if (result.evaluatorPromptId) {
+                divider();
+                printResult("Evaluator Prompt", result.evaluatorPromptId);
+                printResult("Evaluator Config", result.evaluatorConfigId || "-");
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Update test case
+    tests
+        .command("update")
+        .description("Update a test case")
+        .argument("<integration-id>", "Integration ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--name <name>", "Test case name")
+        .option("--input <json>", "Input variables as JSON")
+        .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("--config <config-id>", "Config ID to use for this test")
+        .option("--clear-pattern", "Clear expected pattern")
+        .option("--clear-contains", "Clear expected contains")
+        .option("--clear-json-subset", "Clear expected JSON subset")
+        .option("--json", "Output as JSON")
+        .action(async (integrationId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const payload = {};
+        if (options.name)
+            payload.name = options.name;
+        if (options.input) {
+            try {
+                payload.inputVariables = JSON.parse(options.input);
+            }
+            catch {
+                error("Invalid JSON in --input");
+                process.exit(1);
+            }
+        }
+        if (options.clearPattern) {
+            payload.expectedOutputPattern = null;
+        }
+        else if (options.pattern) {
+            payload.expectedOutputPattern = options.pattern;
+        }
+        if (options.clearContains) {
+            payload.expectedOutputContains = null;
+        }
+        else if (options.contains) {
+            try {
+                payload.expectedOutputContains = JSON.parse(options.contains);
+            }
+            catch {
+                error("Invalid JSON in --contains");
+                process.exit(1);
+            }
+        }
+        if (options.clearJsonSubset) {
+            payload.expectedJsonSubset = null;
+        }
+        else if (options.jsonSubset) {
+            try {
+                payload.expectedJsonSubset = JSON.parse(options.jsonSubset);
+            }
+            catch {
+                error("Invalid JSON in --json-subset");
+                process.exit(1);
+            }
+        }
+        if (options.config)
+            payload.configId = options.config;
+        if (Object.keys(payload).length === 0) {
+            error("No update options specified.");
+            process.exit(1);
+        }
+        const client = new ApiClient();
+        try {
+            const result = await client.updateTestCase(resolvedAppId, "integration", integrationId, testCaseId, payload);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            success("Test case updated.");
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Delete test case
+    tests
+        .command("delete")
+        .description("Delete a test case")
+        .argument("<integration-id>", "Integration 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 (integrationId, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        if (!options.yes) {
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Are you sure you want to delete test case ${testCaseId}?`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
+            if (!confirm) {
+                info("Cancelled.");
+                return;
+            }
+        }
+        const client = new ApiClient();
+        try {
+            await client.deleteTestCase(resolvedAppId, "integration", integrationId, 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("<integration-id>", "Integration ID")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--config <config-id>", "Override config ID")
+        .option("--json", "Output as JSON")
+        .action(async (integrationId, 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, "integration", integrationId, testCaseId);
+            let variables = {};
+            try {
+                variables = JSON.parse(testCase.inputVariables || "{}");
+            }
+            catch {
+                // Use empty object if parsing fails
+            }
+            const result = await client.executeBlockTest(resolvedAppId, "integration", integrationId, {
+                variables,
+                testCaseId,
+                configId: options.config || testCase.configId,
+            });
+            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 ? chalk.green("Yes") : chalk.red("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 ? chalk.green("\u2713") : chalk.red("\u2717");
+                        console.log(`  ${icon} ${check.name}`);
+                        if (!check.passed && check.message) {
+                            console.log(`    ${chalk.dim(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}`);
+            }
+            if (!passed) {
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run all test cases (or a specific group)
+    tests
+        .command("run-all")
+        .description("Run all test cases for an integration, or a specific subset")
+        .argument("<integration-id>", "Integration ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--config <config-id>", "Override config ID for all tests")
+        .option("--test-cases <ids>", "Comma-separated list of test case IDs to run (runs only these)")
+        .option("--json", "Output as JSON")
+        .action(async (integrationId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            // Parse test case IDs if provided
+            let testCaseIds;
+            if (options.testCases) {
+                testCaseIds = options.testCases.split(",").map((id) => id.trim()).filter(Boolean);
+                if (testCaseIds.length === 0) {
+                    error("No valid test case IDs provided in --test-cases");
+                    process.exit(1);
+                }
+            }
+            if (!options.json) {
+                if (testCaseIds) {
+                    info(`Running ${testCaseIds.length} selected test case(s)...`);
+                }
+                else {
+                    info("Running all test cases...");
+                }
+            }
+            const result = await client.runAllTestCases(resolvedAppId, "integration", integrationId, {
+                overrideConfigId: options.config,
+                testCaseIds,
+            });
+            if (options.json) {
+                json(result);
+                return;
+            }
+            const { summary, runs, comparisonGroup } = result;
+            divider();
+            keyValue("Comparison Group", comparisonGroup);
+            keyValue("Total Tests", summary.total);
+            keyValue("Passed", chalk.green(summary.passed));
+            keyValue("Failed", summary.failed > 0 ? chalk.red(summary.failed) : "0");
+            divider();
+            if (runs && runs.length > 0) {
+                for (const r of runs) {
+                    const passed = r.verification?.passed;
+                    const icon = passed ? chalk.green("\u2713") : chalk.red("\u2717");
+                    const status = passed ? "PASSED" : "FAILED";
+                    console.log(`${icon} ${r.testCaseName} - ${status}`);
+                    if (!passed && r.verification?.details?.reason) {
+                        console.log(`  ${chalk.dim(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 an integration")
+        .argument("<integration-id>", "Integration 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 (integrationId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listTestRuns(resolvedAppId, "integration", integrationId, {
+                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
+                        ? chalk.green("Yes")
+                        : v === false
+                            ? chalk.red("No")
+                            : "-",
+                },
+                { header: "DURATION", key: "durationMs", format: formatDuration },
+                { header: "STARTED", key: "startedAt", format: formatDate },
+            ]));
         }
         catch (err) {
             error(err.message);