primitive-admin 1.0.53 → 1.0.55

package/dist/src/commands/scripts.js

@@ -0,0 +1,667 @@
+import { ApiClient } from "../lib/api-client.js";
+import { resolveAppId } from "../lib/config.js";
+import chalk from "chalk";
+import { success, error, info, keyValue, result as printResult, formatTable, formatId, formatDate, formatDuration, json, divider, } from "../lib/output.js";
+import { confirmPrompt } from "../lib/confirm-prompt.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).
+ */
+async function resolveScriptId(client, appId, ref) {
+    const { items } = await client.listScripts(appId);
+    const byId = items.find((s) => s.scriptId === ref);
+    if (byId)
+        return byId.scriptId;
+    const byName = items.find((s) => s.name === ref);
+    if (byName)
+        return byName.scriptId;
+    const byNameCi = items.find((s) => String(s.name).toLowerCase() === ref.toLowerCase());
+    if (byNameCi)
+        return byNameCi.scriptId;
+    throw new Error(`Script not found: ${ref}`);
+}
+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
+  $ primitive scripts configs list my-transform
+  $ primitive scripts tests list my-transform
+  $ primitive scripts tests create my-transform --name "Basic" --vars '{"x":1}'
+  $ primitive scripts tests run my-transform <test-case-id>
+  $ primitive scripts tests run-all my-transform
+
+Scripts (transforms) are authored via 'sync' from transforms/<name>.rhai
+files. Test cases live under transforms/<name>.tests/*.toml and round-trip
+through 'sync pull' / 'sync push'. Both the script reference and the test
+commands accept either a script id or a script name.
+`);
+    // 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(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(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);
+        }
+    });
+    // ============================================
+    // TESTS SUBCOMMAND — script block testing (blockType "script")
+    // ============================================
+    const tests = scripts
+        .command("tests")
+        .description("Manage and run script test cases")
+        .addHelpText("after", `
+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 create my-transform --name "Basic" --vars '{"x":1}'
+  $ 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")
+        .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 { items } = await client.listTestCases(resolvedAppId, "script", scriptId);
+            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 a script")
+        .argument("<script>", "Script ID or name")
+        .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("--config <config-id>", "Config ID to pin this test to a version")
+        .option("--json", "Output as JSON")
+        .action(async (script, 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 scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const result = await client.createTestCase(resolvedAppId, "script", scriptId, {
+                name: options.name,
+                inputVariables,
+                expectedOutputPattern: options.pattern,
+                expectedOutputContains,
+                expectedJsonSubset,
+                configId: options.config,
+            });
+            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("<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);
+        }
+    });
+    // Update test case
+    tests
+        .command("update")
+        .description("Update a 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("--name <name>", "Test case name")
+        .option("--vars <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 pin this test to a version")
+        .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 (script, testCaseId, options) => {
+        const resolvedAppId = resolveAppId(undefined, options);
+        const payload = {};
+        if (options.name)
+            payload.name = options.name;
+        if (options.vars) {
+            try {
+                payload.inputVariables = JSON.parse(options.vars);
+            }
+            catch {
+                error("Invalid JSON in --vars");
+                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 scriptId = await resolveScriptId(client, resolvedAppId, script);
+            const result = await client.updateTestCase(resolvedAppId, "script", scriptId, 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("<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("-y, --yes", "Skip confirmation prompt")
+        .action(async (script, 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 {
+            const scriptId = await resolveScriptId(client, resolvedAppId, script);
+            await client.deleteTestCase(resolvedAppId, "script", scriptId, 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("<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);
+            let variables = {};
+            try {
+                variables = JSON.parse(testCase.inputVariables || "{}");
+            }
+            catch {
+                // Use empty object if parsing fails
+            }
+            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("--app <app-id>", "App ID (uses current app if not specified)")
+        .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 = resolveAppId(undefined, options);
+        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 = await resolveScriptId(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,
+            });
+            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("✓") : 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)}`);
+                    }
+                }
+            }
+            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