primitive-admin 1.1.0-alpha.9 → 1.1.0

package/dist/src/commands/scripts.js

@@ -0,0 +1,688 @@
+import { join } from "path";
+import { ApiClient } from "../lib/api-client.js";
+import { getCurrentAppId, resolveAppId } from "../lib/config.js";
+import chalk from "chalk";
+import { success, error, info, warn, dim, keyValue, result as printResult, formatTable, formatId, formatDate, formatDuration, json, divider, } from "../lib/output.js";
+import { requireTestCaseInputVariables } from "../lib/test-case-variables.js";
+import { resolveSyncDir } from "../lib/sync-paths.js";
+import { listLocalTestCaseFiles, readManagedTestCases, scanLocalTestCases, } from "../lib/local-test-cases.js";
+import { normalizeCliListEnvelope, wholeListEnvelope, } from "../lib/paginate.js";
+import { pageCursorOption, pageLimitOption, parsePageLimit, printEmptyPage, printPageHint, } from "../lib/list-options.js";
+/**
+ * Resolve a user-supplied script reference (either a `scriptId` or the
+ * script's `name`) to its `scriptId`. Scripts are named handles, so the CLI
+ * accepts a name for convenience the way `sync` refers to them by name; the
+ * block-testing API keys on `scriptId` (the block id). If a raw id matches an
+ * existing script it is used directly; otherwise we list the app's scripts and
+ * match on name (case-sensitive, then case-insensitive as a fallback).
+ *
+ * The server enforces name uniqueness by EXACT match, so `foo` and `FOO` can
+ * both exist. Input `Foo` then matches neither exactly and falls through to the
+ * case-insensitive step with two candidates — where picking one is arbitrary.
+ * That is a silent wrong-target write for `update`/`configs activate` and an
+ * unrecoverable one for `delete`, so an ambiguous fallback is an error naming
+ * the candidates. A single case-insensitive match still resolves, keeping the
+ * convenience behavior every command already relies on.
+ */
+export async function resolveScriptId(client, appId, ref) {
+    return (await resolveScript(client, appId, ref)).scriptId;
+}
+/**
+ * The same resolution, keeping the script's NAME as well as its id. The name is
+ * what the local tree is keyed by (`transforms/<name>.rhai` and its
+ * `transforms/<name>.tests/` sidecar), so a verb that has to look at the
+ * authored files cannot work from the block id alone (#3061).
+ */
+export async function resolveScript(client, appId, ref) {
+    const { items } = await client.listScripts(appId);
+    const found = (s) => ({ scriptId: s.scriptId, name: String(s.name) });
+    const byId = items.find((s) => s.scriptId === ref);
+    if (byId)
+        return found(byId);
+    const byName = items.find((s) => s.name === ref);
+    if (byName)
+        return found(byName);
+    const byNameCi = items.filter((s) => String(s.name).toLowerCase() === ref.toLowerCase());
+    if (byNameCi.length === 1)
+        return found(byNameCi[0]);
+    if (byNameCi.length > 1) {
+        const candidates = byNameCi
+            .map((s) => String(s.name))
+            .sort()
+            .join(", ");
+        throw new Error(`Script name is ambiguous: ${ref}. Did you mean: ${candidates}? ` +
+            `Names differing only in case must be given exactly, or by scriptId.`);
+    }
+    throw new Error(`Script not found: ${ref}`);
+}
+/**
+ * Every registered test case of a script, draining the cursor (#3061).
+ *
+ * The listing endpoint returns 50 per page. Classifying local files against
+ * page one alone would call every case that happens to live on page two
+ * unregistered — a push the user does not need, and a count that contradicts
+ * the tree. `firstPage` is the page a caller already fetched for its own
+ * output, so accounting for the rest costs a call only when there IS a rest.
+ */
+async function drainTestCases(params) {
+    const items = [];
+    let cursor;
+    let page = params.firstPage;
+    const seenCursors = new Set();
+    for (;;) {
+        if (!page) {
+            page = await params.client.listTestCases(params.appId, "script", params.scriptId, cursor ? { cursor } : {});
+        }
+        items.push(...(page.items || []));
+        const next = page.nextCursor;
+        // A server that keeps handing back the same cursor must not spin forever.
+        if (!next || seenCursors.has(next))
+            break;
+        seenCursors.add(next);
+        cursor = next;
+        page = undefined;
+    }
+    return items;
+}
+/**
+ * Name the case files under `transforms/<name>.tests/` that the server has
+ * never been told about (#3061).
+ *
+ * The test verbs run the REGISTERED set, so an authored-but-unpushed case
+ * contributes nothing to `Total Tests` — and, before this, nothing to the
+ * output either: `Total Tests: 3 / Failed: 0` beside four case files reads as
+ * a pass for a case that never executed. Printing the file count next to the
+ * registered total is what makes the two numbers disagree out loud, and the
+ * files are named individually so the remedy is one `config push` away rather
+ * than a bisect.
+ *
+ * Everything it prints goes to stderr, including under `--json`: stderr cannot
+ * corrupt a payload, and a scripted caller is exactly who cannot see a case
+ * silently not running. The payload carries the same list.
+ *
+ * The tree it scans is the one `config push` would push from — since #3154
+ * that is the environment's, and there is no longer any way to ask for a
+ * different one.
+ *
+ * Returns the paths named, for that payload. A local tree it cannot read is
+ * reported as such rather than swallowed — this whole issue is about silence.
+ */
+async function reportUnregisteredLocalTestCases(params) {
+    const relativeDir = `transforms/${params.scriptName}.tests`;
+    try {
+        // The tree belongs to the environment, and the environment names exactly
+        // one app (#3152/#3153/#3154) — so the local half of this comparison is
+        // always the same app's case files as the server half, and the scan runs
+        // unconditionally. The `--app`-shaped skip this used to need went with the
+        // flag (adjudicated finding F2).
+        const configDir = resolveSyncDir();
+        const testsDir = join(configDir, "transforms", `${params.scriptName}.tests`);
+        // No sidecar directory, no question to answer — and no listing call for a
+        // suite whose cases are only ever server-side.
+        if (listLocalTestCaseFiles(testsDir).length === 0)
+            return [];
+        const registered = await drainTestCases({
+            client: params.client,
+            appId: params.appId,
+            scriptId: params.scriptId,
+            firstPage: params.registered,
+        });
+        const scan = scanLocalTestCases({
+            testsDir,
+            registered,
+            managed: readManagedTestCases(configDir),
+            managedPrefix: `script/${params.scriptName}`,
+        });
+        if (scan.unregistered.length === 0)
+            return [];
+        keyValue("Local Case Files", `${scan.localFiles.length} (${scan.unregistered.length} not registered)`);
+        warn(`${scan.unregistered.length} local case file(s) in ${relativeDir}/ did not run — not registered:`);
+        for (const file of scan.unregistered) {
+            dim(`    ${relativeDir}/${file}`);
+        }
+        warn("'primitive config push' registers local case files; run it, then run the tests again.");
+        return scan.unregistered.map((file) => `${relativeDir}/${file}`);
+    }
+    catch (err) {
+        warn(`Could not check ${relativeDir}/ for unregistered case files: ${err.message}`);
+        return [];
+    }
+}
+export function registerScriptsCommands(program) {
+    const scripts = program
+        .command("scripts")
+        .description("Inspect Rhai scripts (transforms), their versions, and tests")
+        .addHelpText("after", `
+Examples:
+  $ primitive scripts list
+  $ primitive scripts get my-transform
+  # Deleting: remove transforms/my-transform.rhai and run 'primitive config push --prune'.
+  $ primitive scripts configs list my-transform
+  $ primitive scripts tests list my-transform
+  $ primitive scripts tests run my-transform <test-case-id>
+  $ primitive scripts tests run-all my-transform
+
+Scripts (transforms) are authored as transforms/<name>.rhai files and applied
+with 'config push'. Test cases live under transforms/<name>.tests/*.toml and
+round-trip through 'config pull' / 'config push'. Both the script reference and
+the test commands accept either a script id or a script name.
+`);
+    // Server-side configuration is authored in TOML and applied with `config push`
+    // (issue #2645) — this group no longer carries config-setting flags.
+    scripts.addHelpText("after", `
+Configuration lives in transforms/<name>.rhai:
+  $ primitive config fields transform        # the file's keys, types and defaults
+  $ primitive config create transform <key>  # scaffold one locally
+  $ primitive config set transform/<key> <path>=<value>
+  $ primitive config push --only transform/<key>
+`);
+    // List scripts
+    scripts
+        .command("list")
+        .description("List scripts (transforms) for an app")
+        .argument("[app-id]", "App ID (uses current app if not specified)")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (appId, options) => {
+        const resolvedAppId = resolveAppId(appId, options);
+        const client = new ApiClient();
+        try {
+            const { items } = await client.listScripts(resolvedAppId);
+            if (options.json) {
+                json(wholeListEnvelope(items));
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No scripts found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "ID", key: "scriptId", format: formatId },
+                { header: "NAME", key: "name" },
+                {
+                    header: "ACTIVE CONFIG",
+                    key: "activeConfigId",
+                    format: (v) => (v ? formatId(v) : "-"),
+                },
+                { header: "MODIFIED", key: "modifiedAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get a script
+    scripts
+        .command("get")
+        .description("Get a script's details and versions")
+        .argument("<script>", "Script ID or name")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (script, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const result = await client.getScript(resolvedAppId, scriptId);
+            if (options.json) {
+                json(result);
+                return;
+            }
+            printResult("Script ID", result.scriptId);
+            printResult("Name", result.name);
+            printResult("Description", result.description || "-");
+            printResult("Active Config", result.activeConfigId || "-");
+            printResult("Created", formatDate(result.createdAt));
+            const configs = Array.isArray(result.configs) ? result.configs : [];
+            if (configs.length > 0) {
+                divider();
+                info("Versions:");
+                console.log(formatTable(configs, [
+                    { header: "CONFIG ID", key: "configId", format: formatId },
+                    { header: "NAME", key: "configName" },
+                    { header: "STATUS", key: "status" },
+                    {
+                        header: "ACTIVE",
+                        key: "configId",
+                        format: (v) => v === result.activeConfigId ? chalk.green("Yes") : "-",
+                    },
+                    { header: "CONTENT HASH", key: "contentHash", format: formatId },
+                ]));
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ============================================
+    // CONFIGS (VERSIONS) SUBCOMMAND
+    // ============================================
+    const configs = scripts
+        .command("configs")
+        .description("Inspect a script's versioned configs");
+    configs
+        .command("list")
+        .description("List a script's versions (configs)")
+        .argument("<script>", "Script ID or name")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (script, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const header = await client.getScript(resolvedAppId, scriptId);
+            const { items } = await client.listScriptConfigs(resolvedAppId, scriptId);
+            if (options.json) {
+                json(wholeListEnvelope(items));
+                return;
+            }
+            if (!items || items.length === 0) {
+                info("No versions found.");
+                return;
+            }
+            console.log(formatTable(items, [
+                { header: "CONFIG ID", key: "configId", format: formatId },
+                { header: "NAME", key: "configName" },
+                { header: "STATUS", key: "status" },
+                {
+                    header: "ACTIVE",
+                    key: "configId",
+                    format: (v) => v === header.activeConfigId ? chalk.green("Yes") : "-",
+                },
+                { header: "CONTENT HASH", key: "contentHash", format: formatId },
+                { header: "CREATED", key: "createdAt", format: formatDate },
+            ]));
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get one version. `list` says which versions exist; this says what one of
+    // them holds — the body the server would run. A transform is authored as
+    // `transforms/<name>.rhai` and applied by `config push`, so this is the read
+    // that answers "is what is running what I committed?" for a single version.
+    configs
+        .command("get")
+        .description("Show one version (config) of a script as the server has it")
+        .argument("<script>", "Script ID or name")
+        .argument("<config>", "Config ID or name")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--json", "Output as JSON")
+        .action(async (script, config, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const header = await client.getScript(resolvedAppId, scriptId);
+            const { items } = await client.listScriptConfigs(resolvedAppId, scriptId);
+            const found = (items ?? []).find((c) => c.configId === config || c.configName === config);
+            if (!found) {
+                error(`Script '${script}' has no version '${config}'. Run 'primitive scripts configs list ${script}' to see them.`);
+                process.exit(1);
+            }
+            if (options.json) {
+                json(found);
+                return;
+            }
+            keyValue("Config ID", found.configId);
+            keyValue("Name", found.configName);
+            keyValue("Status", found.status);
+            keyValue("Active", found.configId === header.activeConfigId ? "Yes" : "No");
+            if (found.contentHash)
+                keyValue("Content Hash", found.contentHash);
+            if (found.createdAt)
+                keyValue("Created", formatDate(found.createdAt));
+            if (typeof found.body === "string") {
+                divider();
+                info("Body:");
+                console.log(found.body);
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // ============================================
+    // TESTS SUBCOMMAND — script block testing (blockType "script")
+    // ============================================
+    const tests = scripts
+        .command("tests")
+        .description("Run and inspect script test cases")
+        .addHelpText("after", `
+Test cases are authored in TOML at transforms/<name>.tests/<case>.toml and
+applied with \`primitive config push\` (issue #2769); \`config fields transform\`
+lists the fields. Deleting a case is removing its file and running
+\`config push --prune\`.
+
+Test modes:
+  Active version  — omit --config; runs against the script's active config.
+  Pinned version  — pass --config <config-id> to run a specific version.
+
+Examples:
+  $ primitive scripts tests list my-transform
+  $ primitive scripts tests run my-transform <test-case-id>
+  $ primitive scripts tests run my-transform <test-case-id> --config <config-id>
+  $ primitive scripts tests run-all my-transform
+  $ primitive scripts tests runs my-transform
+`);
+    // List test cases
+    tests
+        .command("list")
+        .description("List test cases for a script")
+        .argument("<script>", "Script ID or name")
+        .addOption(pageLimitOption())
+        .addOption(pageCursorOption())
+        .option("--json", "Output as JSON")
+        .action(async (script, options) => {
+        const limit = parsePageLimit(options.limit);
+        const resolvedAppId = getCurrentAppId();
+        const client = new ApiClient();
+        try {
+            const { scriptId, name } = await resolveScript(client, resolvedAppId, script);
+            const page = normalizeCliListEnvelope(await client.listTestCases(resolvedAppId, "script", scriptId, {
+                limit,
+                cursor: options.cursor,
+            }));
+            const items = page.items;
+            // The listing shows the REGISTERED set; the local directory can hold
+            // more (#3061). Reported before the early returns below, so "no test
+            // cases" and a `--json` array both carry the discrepancy on stderr.
+            await reportUnregisteredLocalTestCases({
+                client,
+                appId: resolvedAppId,
+                scriptId,
+                scriptName: name,
+                registered: { items: items ?? [], nextCursor: page.nextCursor },
+            });
+            if (options.json) {
+                json(page);
+                return;
+            }
+            if (items.length === 0) {
+                printEmptyPage(page, "test cases");
+                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 },
+            ]));
+            printPageHint(page);
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Get test case
+    tests
+        .command("get")
+        .description("Get test case details")
+        .argument("<script>", "Script ID or name")
+        .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 (script, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const result = await client.getTestCase(resolvedAppId, "script", scriptId, 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 {
+                console.log(JSON.stringify(JSON.parse(result.inputVariables || "{}"), 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);
+                }
+            }
+        }
+        catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    });
+    // Run a single test case
+    tests
+        .command("run")
+        .description("Run a single test case")
+        .argument("<script>", "Script ID or name")
+        .argument("<test-case-id>", "Test Case ID")
+        .option("--app <app-id>", "App ID (uses current app if not specified)")
+        .option("--config <config-id>", "Pin to a specific version (defaults to the test case's config, else the active version)")
+        .option("--json", "Output as JSON")
+        .action(async (script, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const testCase = await client.getTestCase(resolvedAppId, "script", scriptId, testCaseId);
+            // #3158 — whatever this sends IS the input the case runs against, and
+            // the server hands the case back with its JSON fields already parsed.
+            // `JSON.parse` on that object threw and the run went ahead with `{}`,
+            // so this verb disagreed with `run-all` over the same stored case.
+            const variables = requireTestCaseInputVariables(testCase.inputVariables, testCaseId);
+            const result = await client.executeBlockTest(resolvedAppId, "script", scriptId, {
+                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"));
+                if (v.summary) {
+                    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("✓") : chalk.red("✗");
+                        console.log(`  ${icon} ${check.name}`);
+                        if (!check.passed && check.message) {
+                            console.log(`    ${chalk.dim(check.message)}`);
+                        }
+                    }
+                }
+            }
+            if (result.output) {
+                divider();
+                info("Output:");
+                console.log(result.output);
+            }
+            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 script, or a specific subset")
+        .argument("<script>", "Script ID or name")
+        .option("--config <config-id>", "Override config ID for all tests (pin to a version)")
+        .option("--test-cases <ids>", "Comma-separated list of test case IDs to run (runs only these)")
+        .option("--json", "Output as JSON")
+        .action(async (script, options) => {
+        const resolvedAppId = getCurrentAppId();
+        const client = new ApiClient();
+        try {
+            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);
+                }
+            }
+            const { scriptId, name } = await resolveScript(client, resolvedAppId, script);
+            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, "script", scriptId, {
+                overrideConfigId: options.config,
+                testCaseIds,
+            });
+            // A run that only ever sees the registered set cannot report a clean
+            // pass over a case file nobody pushed (#3061). Reported last in human
+            // output — the end of the run is where the verdict is read.
+            const reportUnrunFiles = () => reportUnregisteredLocalTestCases({
+                client,
+                appId: resolvedAppId,
+                scriptId,
+                scriptName: name,
+            });
+            if (options.json) {
+                const unregisteredLocalTestCaseFiles = await reportUnrunFiles();
+                json({ ...result, unregisteredLocalTestCaseFiles });
+                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("✓") : chalk.red("✗");
+                    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)}`);
+                    }
+                }
+            }
+            await reportUnrunFiles();
+            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 script")
+        .argument("<script>", "Script ID or name")
+        .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 (script, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const client = new ApiClient();
+        try {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const { items } = await client.listTestRuns(resolvedAppId, "script", scriptId, {
+                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);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=scripts.js.map