@griffin-app/griffin-cli 1.0.39 → 1.0.40

package/dist/core/plan-diff.js

@@ -0,0 +1,257 @@
+import objectHash from "object-hash";
+import { NodeType } from "@griffin-app/griffin-ts/schema";
+/**
+ * Compare two test monitors and return granular changes.
+ * Local monitor should be resolved (variables replaced with actual values).
+ */
+export function compareMonitors(local, remote) {
+    const nodeChanges = compareNodes(local.nodes, remote.nodes);
+    const edgeChanges = compareEdges(local.edges, remote.edges);
+    const topLevelChanges = compareTopLevel(local, remote);
+    const hasChanges = nodeChanges.length > 0 ||
+        edgeChanges.length > 0 ||
+        topLevelChanges.length > 0;
+    return {
+        hasChanges,
+        nodes: nodeChanges,
+        edges: edgeChanges,
+        topLevel: topLevelChanges,
+    };
+}
+/**
+ * Compare nodes between local and remote monitors
+ */
+function compareNodes(localNodes, remoteNodes) {
+    const changes = [];
+    // Build map of remote nodes by id
+    const remoteByID = new Map();
+    for (const node of remoteNodes) {
+        remoteByID.set(node.id, node);
+    }
+    const localIDs = new Set();
+    for (const node of localNodes) {
+        localIDs.add(node.id);
+    }
+    // Check local nodes
+    for (const local of localNodes) {
+        const remote = remoteByID.get(local.id);
+        if (!remote) {
+            // Node added
+            changes.push({
+                type: "add",
+                nodeId: local.id,
+                nodeType: local.type,
+                summary: getNodeSummary(local),
+                fieldChanges: [],
+            });
+        }
+        else {
+            // Node exists - check for modifications
+            const fieldChanges = compareNodeFields(local, remote);
+            if (fieldChanges.length > 0) {
+                changes.push({
+                    type: "modify",
+                    nodeId: local.id,
+                    nodeType: local.type,
+                    summary: getNodeSummary(local),
+                    fieldChanges,
+                });
+            }
+        }
+    }
+    // Check for removed nodes
+    for (const remote of remoteNodes) {
+        if (!localIDs.has(remote.id)) {
+            changes.push({
+                type: "remove",
+                nodeId: remote.id,
+                nodeType: remote.type,
+                summary: getNodeSummary(remote),
+                fieldChanges: [],
+            });
+        }
+    }
+    return changes;
+}
+/**
+ * Get a human-readable summary of a node
+ */
+function getNodeSummary(node) {
+    switch (node.type) {
+        case "HTTP_REQUEST":
+            return `${node.method} ${formatValue(node.path)}`;
+        case "WAIT":
+            return `wait ${node.duration_ms}ms`;
+        case "ASSERTION":
+            return `${node.assertions.length} assertion(s)`;
+    }
+}
+/**
+ * Format a value for display (handle VariableRef objects)
+ */
+function formatValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value &&
+        typeof value === "object" &&
+        "$variable" in value &&
+        typeof value.$variable === "object") {
+        return `$\{${value.$variable.key}}`;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * Compare fields within two nodes of the same type
+ */
+function compareNodeFields(local, remote) {
+    const changes = [];
+    // Type should match, but check anyway
+    if (local.type !== remote.type) {
+        changes.push({
+            field: "type",
+            oldValue: remote.type,
+            newValue: local.type,
+        });
+        return changes;
+    }
+    switch (local.type) {
+        case NodeType.HTTP_REQUEST:
+            compareHttpRequestFields(local, remote, changes);
+            break;
+        case NodeType.WAIT:
+            compareWaitFields(local, remote, changes);
+            break;
+        case NodeType.ASSERTION:
+            compareAssertionFields(local, remote, changes);
+            break;
+    }
+    return changes;
+}
+/**
+ * Compare fields specific to HttpRequest nodes
+ */
+function compareHttpRequestFields(local, remote, changes) {
+    const fields = [
+        "method",
+        "path",
+        "base",
+        "headers",
+        "body",
+        "response_format",
+    ];
+    for (const field of fields) {
+        const localVal = local[field];
+        const remoteVal = remote[field];
+        if (!deepEqual(localVal, remoteVal)) {
+            changes.push({
+                field: field,
+                oldValue: remoteVal,
+                newValue: localVal,
+            });
+        }
+    }
+}
+/**
+ * Compare fields specific to Wait nodes
+ */
+function compareWaitFields(local, remote, changes) {
+    if (local.duration_ms !== remote.duration_ms) {
+        changes.push({
+            field: "duration_ms",
+            oldValue: remote.duration_ms,
+            newValue: local.duration_ms,
+        });
+    }
+}
+/**
+ * Compare fields specific to Assertion nodes
+ */
+function compareAssertionFields(local, remote, changes) {
+    if (!deepEqual(local.assertions, remote.assertions)) {
+        changes.push({
+            field: "assertions",
+            oldValue: remote.assertions,
+            newValue: local.assertions,
+        });
+    }
+}
+/**
+ * Compare edges between local and remote monitors
+ */
+function compareEdges(localEdges, remoteEdges) {
+    const changes = [];
+    // Build map of remote edges by "from:to" key
+    const remoteByKey = new Map();
+    for (const edge of remoteEdges) {
+        remoteByKey.set(`${edge.from}:${edge.to}`, edge);
+    }
+    const localKeys = new Set();
+    for (const edge of localEdges) {
+        localKeys.add(`${edge.from}:${edge.to}`);
+    }
+    // Check local edges
+    for (const local of localEdges) {
+        const key = `${local.from}:${local.to}`;
+        if (!remoteByKey.has(key)) {
+            changes.push({
+                type: "add",
+                from: local.from,
+                to: local.to,
+            });
+        }
+    }
+    // Check for removed edges
+    for (const remote of remoteEdges) {
+        const key = `${remote.from}:${remote.to}`;
+        if (!localKeys.has(key)) {
+            changes.push({
+                type: "remove",
+                from: remote.from,
+                to: remote.to,
+            });
+        }
+    }
+    return changes;
+}
+/**
+ * Compare top-level fields: frequency, version, locations
+ */
+function compareTopLevel(local, remote) {
+    const changes = [];
+    // Compare frequency
+    if (!deepEqual(local.frequency, remote.frequency)) {
+        changes.push({
+            field: "frequency",
+            oldValue: remote.frequency,
+            newValue: local.frequency,
+        });
+    }
+    // Compare version
+    if (local.version !== remote.version) {
+        changes.push({
+            field: "version",
+            oldValue: remote.version,
+            newValue: local.version,
+        });
+    }
+    // Compare locations (normalize empty array to undefined)
+    const localLocations = local.locations;
+    const remoteLocations = remote.locations && remote.locations.length > 0
+        ? remote.locations
+        : undefined;
+    if (!deepEqual(localLocations, remoteLocations)) {
+        changes.push({
+            field: "locations",
+            oldValue: remoteLocations,
+            newValue: localLocations,
+        });
+    }
+    return changes;
+}
+/**
+ * Deep equality check using object-hash
+ */
+function deepEqual(a, b) {
+    return objectHash(a ?? null) === objectHash(b ?? null);
+}

package/dist/output/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Output format for CLI commands.
+ * - human: formatted, colored, spinners and progress
+ * - json: single JSON object to stdout, no progress output
+ */
+export type OutputFormat = "human" | "json";
+/**
+ * Set the output format (called from cli.ts when parsing --output).
+ */
+export declare function setOutputFormat(format: OutputFormat): void;
+/**
+ * Get the current output format.
+ */
+export declare function getOutputFormat(): OutputFormat;
+/**
+ * True when output should be JSON-only (no spinners, no progress).
+ */
+export declare function isJsonOutput(): boolean;

package/dist/output/context.js

@@ -0,0 +1,22 @@
+let currentFormat = "human";
+/**
+ * Set the output format (called from cli.ts when parsing --output).
+ */
+export function setOutputFormat(format) {
+    if (format !== "human" && format !== "json") {
+        throw new Error(`Invalid output format: ${format}. Use 'human' or 'json'.`);
+    }
+    currentFormat = format;
+}
+/**
+ * Get the current output format.
+ */
+export function getOutputFormat() {
+    return currentFormat;
+}
+/**
+ * True when output should be JSON-only (no spinners, no progress).
+ */
+export function isJsonOutput() {
+    return currentFormat === "json";
+}

package/dist/output/index.d.ts

@@ -0,0 +1,3 @@
+export { type CommandResult, type InitResultData, type ConnectResultData, type LoginResultData, type LogoutResultData, type GenerateKeyResultData, type ValidateResultData, type ValidateMonitorInfo, type EnvListResultData, type StatusResultData, type RunSummary, type RunsResultData, type MetricsResultData, type MonitorResultData, type ApplyResultData, type LocalRunResultData, type HubRunResultData, type NotificationRuleSummary, type NotificationsListResultData, type NotificationsAddResultData, type NotificationsDeleteResultData, type NotificationsTestResultData, } from "./types.js";
+export { setOutputFormat, getOutputFormat, isJsonOutput, type OutputFormat, } from "./context.js";
+export { render, type CommandName } from "./renderer.js";

package/dist/output/index.js

@@ -0,0 +1,2 @@
+export { setOutputFormat, getOutputFormat, isJsonOutput, } from "./context.js";
+export { render } from "./renderer.js";

package/dist/output/renderer.d.ts

@@ -0,0 +1,6 @@
+import type { CommandResult } from "./types.js";
+export type CommandName = "init" | "validate" | "generate-key" | "env-list" | "local-run" | "hub-connect" | "hub-status" | "hub-metrics" | "hub-runs" | "hub-monitor" | "hub-apply" | "hub-run" | "hub-login" | "hub-logout" | "notifications-list" | "notifications-add" | "notifications-delete" | "notifications-test";
+/**
+ * Render command result to stdout (human or JSON based on --output).
+ */
+export declare function render<T>(result: CommandResult<T>, command: CommandName): void;

package/dist/output/renderer.js

@@ -0,0 +1,348 @@
+import pc from "picocolors";
+import { getOutputFormat } from "./context.js";
+import { terminal } from "../utils/terminal.js";
+import { formatDiff } from "../core/diff.js";
+import { formatApplyResult } from "../core/apply.js";
+function toJsonPayload(result) {
+    if (result.success) {
+        return {
+            success: true,
+            ...result.data,
+            ...(result.warnings?.length ? { warnings: result.warnings } : {}),
+        };
+    }
+    return {
+        success: false,
+        error: result.error,
+        ...(result.hint ? { hint: result.hint } : {}),
+    };
+}
+/**
+ * Render command result to stdout (human or JSON based on --output).
+ */
+export function render(result, command) {
+    if (getOutputFormat() === "json") {
+        console.log(JSON.stringify(toJsonPayload(result), null, 2));
+        return;
+    }
+    renderHuman(result, command);
+}
+function renderHuman(result, command) {
+    if (!result.success) {
+        terminal.error(result.error);
+        if (result.hint) {
+            terminal.dim(result.hint);
+        }
+        return;
+    }
+    const data = result.data;
+    switch (command) {
+        case "init":
+            renderInit(data);
+            break;
+        case "hub-connect":
+            renderConnect(data);
+            break;
+        case "hub-login":
+        case "hub-logout":
+            terminal.success("Success.");
+            terminal.blank();
+            break;
+        case "generate-key":
+            renderGenerateKey(data);
+            break;
+        case "validate":
+            renderValidate(data);
+            break;
+        case "env-list":
+            renderEnvList(data);
+            break;
+        case "hub-status":
+            renderStatus(data);
+            break;
+        case "hub-runs":
+            renderRuns(data);
+            break;
+        case "hub-metrics":
+            renderMetrics(data);
+            break;
+        case "hub-monitor":
+            renderMonitor(data);
+            break;
+        case "hub-apply":
+            renderApply(data);
+            break;
+        case "local-run":
+            renderLocalRun(data);
+            break;
+        case "hub-run":
+            renderHubRun(data);
+            break;
+        case "notifications-list":
+            renderNotificationsList(data);
+            break;
+        case "notifications-add":
+            renderNotificationsAdd(data);
+            break;
+        case "notifications-delete":
+            renderNotificationsDelete(data);
+            break;
+        case "notifications-test":
+            renderNotificationsTest(data);
+            break;
+        default:
+            terminal.success("Done.");
+    }
+}
+function renderInit(d) {
+    terminal.blank();
+    terminal.success("Initialization complete!");
+    terminal.blank();
+    terminal.info("Next steps:");
+    for (const step of d.nextSteps) {
+        terminal.dim(`  ${step}`);
+    }
+    terminal.blank();
+}
+function renderConnect(d) {
+    terminal.success("Hub connection configured");
+    terminal.log(`  URL: ${pc.cyan(d.url)}`);
+    if (d.tokenSet) {
+        terminal.log(`  API Token: ${pc.dim("***")} (saved to user credentials)`);
+    }
+    terminal.blank();
+}
+function renderGenerateKey(d) {
+    terminal.blank();
+    terminal.success("Generated API key:");
+    terminal.blank();
+    terminal.log(`  ${pc.cyan(d.apiKey)}`);
+    terminal.blank();
+    terminal.warn("Store this key securely - it cannot be retrieved later.");
+    terminal.blank();
+    terminal.info("To use this key:");
+    terminal.dim("  1. Add it to your runner's AUTH_API_KEYS environment variable:");
+    terminal.dim(`     AUTH_API_KEYS=${d.apiKey}`);
+    terminal.dim("  2. Or add it to your .griffinrc.json:");
+    terminal.dim(`     { "runner": { "apiToken": "${d.apiKey}" } }`);
+    terminal.dim("  3. Or pass it via environment variable:");
+    terminal.dim(`     GRIFFIN_API_TOKEN=${d.apiKey}`);
+    terminal.blank();
+}
+function renderValidate(d) {
+    terminal.blank();
+    for (const m of d.monitors) {
+        const exportInfo = m.exportName === "default" ? "" : pc.dim(` (${m.exportName})`);
+        terminal.log(`  ${pc.green("●")} ${pc.cyan(m.name)}${exportInfo}`);
+        terminal.dim(`    ${m.filePath}`);
+        terminal.dim(`    Nodes: ${m.nodes}, Edges: ${m.edges}`);
+        if (m.frequency) {
+            terminal.dim(`    Schedule: Every ${m.frequency.every} ${m.frequency.unit}`);
+        }
+        terminal.blank();
+    }
+    terminal.success("All monitors are valid");
+}
+function renderEnvList(d) {
+    terminal.info("Available environments:");
+    terminal.blank();
+    for (const envName of d.environments) {
+        const isDefault = d.default === envName;
+        const marker = isDefault ? pc.green("●") : pc.dim("○");
+        const envDisplay = isDefault
+            ? pc.cyan(envName) + pc.dim(" (default)")
+            : envName;
+        terminal.log(`  ${marker} ${envDisplay}`);
+    }
+    terminal.blank();
+}
+function renderStatus(d) {
+    terminal.info("Hub connection:");
+    terminal.log(`  URL: ${pc.cyan(d.url)}`);
+    if (d.token) {
+        terminal.log(`  API Token: ${pc.dim(d.token.substring(0, 8) + "...")}`);
+        if (d.updatedAt) {
+            terminal.log(`  Updated: ${pc.dim(new Date(d.updatedAt).toLocaleString())}`);
+        }
+    }
+    else {
+        terminal.log(`  API Token: ${pc.dim("(not set)")}`);
+    }
+    terminal.blank();
+}
+function renderRuns(d) {
+    if (d.runs.length === 0) {
+        terminal.info("No runs found.");
+        return;
+    }
+    terminal.blank();
+    const table = terminal.table({
+        head: ["Status", "Monitor", "Duration", "Started"],
+    });
+    for (const run of d.runs) {
+        const statusIcon = getStatusIcon(run.status, run.success);
+        const duration = run.duration_ms
+            ? `${(run.duration_ms / 1000).toFixed(2)}s`
+            : "-";
+        const started = new Date(run.startedAt).toLocaleString();
+        table.push([statusIcon, run.monitorId || "-", duration, started]);
+    }
+    terminal.log(table.toString());
+    const runsWithErrors = d.runs.filter((r) => r.errors && r.errors.length > 0);
+    if (runsWithErrors.length > 0) {
+        terminal.blank();
+        terminal.warn("Runs with errors:");
+        terminal.blank();
+        for (const run of runsWithErrors) {
+            terminal.log(`${pc.red("✗")} ${pc.cyan(run.monitorId || run.id)}`);
+            if (run.errors) {
+                for (const err of run.errors.slice(0, 3)) {
+                    terminal.dim(`  - ${err}`);
+                }
+                if (run.errors.length > 3) {
+                    terminal.dim(`  ... and ${run.errors.length - 3} more`);
+                }
+            }
+            terminal.blank();
+        }
+    }
+}
+function getStatusIcon(status, success) {
+    switch (status) {
+        case "pending":
+            return "⏳";
+        case "running":
+            return "🏃";
+        case "completed":
+            return success ? "✅" : "❌";
+        case "failed":
+            return "❌";
+        default:
+            return "•";
+    }
+}
+function renderMetrics(d) {
+    const period = d.period;
+    terminal.info(`Metrics (${period})`);
+    terminal.dim(`${new Date(d.periodStart).toLocaleString()} – ${new Date(d.periodEnd).toLocaleString()}`);
+    terminal.blank();
+    terminal.log("Monitors:");
+    terminal.log(`  Total: ${d.monitors.total}  Passing: ${pc.green(String(d.monitors.passing))}  Failing: ${d.monitors.failing > 0 ? pc.red(String(d.monitors.failing)) : "0"}  No recent runs: ${d.monitors.noRecentRuns}`);
+    terminal.blank();
+    terminal.log("Runs:");
+    terminal.log(`  Total: ${d.runs.total}  Success rate: ${d.runs.successRate.toFixed(1)}%`);
+    terminal.blank();
+    if (d.latency.p50DurationMs != null ||
+        d.latency.p95DurationMs != null ||
+        d.latency.p99DurationMs != null) {
+        terminal.log("Latency (completed runs):");
+        terminal.log(`  p50: ${d.latency.p50DurationMs ?? "-"} ms  p95: ${d.latency.p95DurationMs ?? "-"} ms  p99: ${d.latency.p99DurationMs ?? "-"} ms`);
+        terminal.blank();
+    }
+    terminal.log(`Uptime: ${d.uptimePercent.toFixed(1)}%`);
+    terminal.blank();
+    if (d.failingMonitors.length > 0) {
+        terminal.warn("Failing monitors:");
+        for (const m of d.failingMonitors) {
+            terminal.log(`  ${pc.red("✗")} ${m.monitorName} (${m.monitorId}) – ${m.consecutiveFailures} consecutive failure(s), last at ${new Date(m.lastFailureAt).toLocaleString()}`);
+        }
+    }
+}
+function renderMonitor(d) {
+    terminal.blank();
+    terminal.log(formatDiff(d.diff));
+}
+function renderApply(d) {
+    terminal.blank();
+    terminal.log(formatApplyResult(d.applied));
+}
+function renderLocalRun(d) {
+    terminal.blank();
+    if (d.failed === 0) {
+        terminal.success(`All tests passed (${pc.bold(String(d.passed))} / ${d.total})`);
+    }
+    else {
+        terminal.error(`${pc.bold(String(d.failed))} test(s) failed, ${pc.bold(String(d.passed))} passed`);
+    }
+}
+function renderHubRun(d) {
+    terminal.blank();
+    terminal.log(`Run ID: ${pc.dim(d.runId)}`);
+    terminal.log(`Status: ${pc.cyan(d.status)}`);
+    terminal.log(`Started: ${pc.dim(new Date(d.startedAt).toLocaleString())}`);
+    if (d.duration_ms != null) {
+        terminal.log(`Duration: ${pc.dim((d.duration_ms / 1000).toFixed(2) + "s")}`);
+    }
+    if (d.success !== undefined) {
+        const successText = d.success ? pc.green("Yes") : pc.red("No");
+        terminal.log(`Success: ${successText}`);
+    }
+    if (d.errors && d.errors.length > 0) {
+        terminal.blank();
+        terminal.error("Errors:");
+        for (const err of d.errors) {
+            terminal.dim(`  - ${err}`);
+        }
+    }
+    if (!d.waited) {
+        terminal.blank();
+        terminal.dim("Run started. Use 'griffin hub runs' to check progress.");
+    }
+}
+function renderNotificationsList(d) {
+    if (d.rules.length === 0) {
+        terminal.info("No notification rules found.");
+        return;
+    }
+    terminal.info("Notification Rules");
+    terminal.blank();
+    const table = terminal.table({
+        head: ["ID", "Name", "Monitor", "Trigger", "Channels", "Enabled"],
+    });
+    for (const rule of d.rules) {
+        const triggerDesc = formatTriggerDesc(rule.trigger);
+        table.push([
+            rule.id.substring(0, 8) + "...",
+            rule.name,
+            rule.monitorId ?? "all monitors",
+            triggerDesc,
+            rule.channels.join(", "),
+            rule.enabled ? "✓" : "✗",
+        ]);
+    }
+    terminal.log(table.toString());
+}
+function formatTriggerDesc(trigger) {
+    if (trigger && typeof trigger === "object" && "type" in trigger) {
+        const t = trigger;
+        switch (t.type) {
+            case "run_failed":
+                return "Run failed";
+            case "run_recovered":
+                return "Run recovered";
+            case "consecutive_failures":
+                return `${t.threshold} consecutive failures`;
+            case "success_rate_below":
+                return `Success rate < ${t.threshold}% (${t.window_minutes}m)`;
+            case "latency_above":
+                return `${t.percentile} latency > ${t.threshold_ms}ms (${t.window_minutes}m)`;
+            default:
+                return String(t.type);
+        }
+    }
+    return String(trigger);
+}
+function renderNotificationsAdd(d) {
+    terminal.success(`Created notification rule: ${d.id}`);
+}
+function renderNotificationsDelete(d) {
+    terminal.success(`Deleted notification rule: ${d.id}`);
+}
+function renderNotificationsTest(d) {
+    if (d.success) {
+        terminal.success(d.message || "Test notification delivered successfully");
+    }
+    else {
+        terminal.error("Test notification failed");
+    }
+}