@griffin-app/griffin-cli 1.0.26 → 1.0.28

package/dist/commands/hub/metrics.js

@@ -1,50 +1,52 @@
 import { resolveEnvironment } from "../../core/state.js";
-import { terminal } from "../../utils/terminal.js";
 import { createSdkFromState } from "../../core/sdk.js";
-import { withSDKErrorHandling } from "../../utils/sdk-error.js";
-import { withCommandErrorHandler, outputJsonOrContinue, } from "../../utils/command-wrapper.js";
+import { handleSDKErrorWithOutput } from "../../utils/sdk-error.js";
+import { createCommandHandler, } from "../../utils/command-wrapper.js";
 const METRICS_PERIODS = ["1h", "6h", "24h", "7d", "30d"];
 /**
  * Show metrics summary from the hub
  */
-export const executeMetrics = withCommandErrorHandler(async (options) => {
+export const executeMetrics = createCommandHandler("metrics", async (options, output) => {
     const sdk = await createSdkFromState();
     const env = await resolveEnvironment(options.environment);
-    const spinner = terminal.spinner("Fetching metrics...").start();
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.getMetricsSummary({
+    const spinner = output.spinner("Fetching metrics...").start();
+    let response;
+    try {
+        response = await sdk.getMetricsSummary({
             query: {
                 environment: env,
                 period: options.period,
             },
         });
-    }, "Failed to fetch metrics");
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to fetch metrics");
+    }
     spinner.stop();
-    const data = response?.data?.data;
-    if (outputJsonOrContinue(data, options.json))
-        return;
-    terminal.info(`Metrics (${options.period})`);
-    terminal.dim(`${new Date(data.periodStart).toLocaleString()} – ${new Date(data.periodEnd).toLocaleString()}`);
-    terminal.blank();
-    terminal.log("Monitors:");
-    terminal.log(`  Total: ${data.monitors.total}  Passing: ${terminal.colors.green(String(data.monitors.passing))}  Failing: ${data.monitors.failing > 0 ? terminal.colors.red(String(data.monitors.failing)) : "0"}  No recent runs: ${data.monitors.noRecentRuns}`);
-    terminal.blank();
-    terminal.log("Runs:");
-    terminal.log(`  Total: ${data.runs.total}  Success rate: ${data.runs.successRate.toFixed(1)}%`);
-    terminal.blank();
+    const data = response.data?.data;
+    output.setData(data);
+    output.info(`Metrics (${options.period})`);
+    output.dim(`${new Date(data.periodStart).toLocaleString()} – ${new Date(data.periodEnd).toLocaleString()}`);
+    output.blank();
+    output.log("Monitors:");
+    output.log(`  Total: ${data.monitors.total}  Passing: ${output.colors.green(String(data.monitors.passing))}  Failing: ${data.monitors.failing > 0 ? output.colors.red(String(data.monitors.failing)) : "0"}  No recent runs: ${data.monitors.noRecentRuns}`);
+    output.blank();
+    output.log("Runs:");
+    output.log(`  Total: ${data.runs.total}  Success rate: ${data.runs.successRate.toFixed(1)}%`);
+    output.blank();
     if (data.latency.p50DurationMs != null ||
         data.latency.p95DurationMs != null ||
         data.latency.p99DurationMs != null) {
-        terminal.log("Latency (completed runs):");
-        terminal.log(`  p50: ${data.latency.p50DurationMs ?? "-"} ms  p95: ${data.latency.p95DurationMs ?? "-"} ms  p99: ${data.latency.p99DurationMs ?? "-"} ms`);
-        terminal.blank();
+        output.log("Latency (completed runs):");
+        output.log(`  p50: ${data.latency.p50DurationMs ?? "-"} ms  p95: ${data.latency.p95DurationMs ?? "-"} ms  p99: ${data.latency.p99DurationMs ?? "-"} ms`);
+        output.blank();
     }
-    terminal.log(`Uptime: ${data.uptimePercent.toFixed(1)}%`);
-    terminal.blank();
+    output.log(`Uptime: ${data.uptimePercent.toFixed(1)}%`);
+    output.blank();
     if (data.failingMonitors.length > 0) {
-        terminal.warn("Failing monitors:");
+        output.warn("Failing monitors:");
         for (const m of data.failingMonitors) {
-            terminal.log(`  ${terminal.colors.red("✗")} ${m.monitorName} (${m.monitorId}) – ${m.consecutiveFailures} consecutive failure(s), last at ${new Date(m.lastFailureAt).toLocaleString()}`);
+            output.log(`  ${output.colors.red("✗")} ${m.monitorName} (${m.monitorId}) – ${m.consecutiveFailures} consecutive failure(s), last at ${new Date(m.lastFailureAt).toLocaleString()}`);
         }
     }
 });

package/dist/commands/hub/monitor.js

@@ -1,37 +1,37 @@
 import { resolveEnvironment } from "../../core/state.js";
 import { createSdkAndState } from "../../core/sdk.js";
 import { computeDiff, formatDiff, formatDiffJson } from "../../core/diff.js";
-import { terminal } from "../../utils/terminal.js";
-import { withCommandErrorHandler } from "../../utils/command-wrapper.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
 import { discoverLocalMonitors, fetchRemoteMonitors, resolveLocalMonitors, } from "../../core/monitor-helpers.js";
 /**
  * Show what changes would be applied
  */
-export const executePlan = withCommandErrorHandler(async (options) => {
+export const executePlan = createCommandHandler("plan", async (options, output) => {
     const { sdk, state } = await createSdkAndState();
-    // Resolve environment
     const envName = await resolveEnvironment(options.env);
-    // Discover local monitors
     const { monitors } = await discoverLocalMonitors(state);
-    // Fetch remote monitors for this project + environment
     const remoteMonitors = await fetchRemoteMonitors(sdk, state.projectId, envName);
-    // Load variables and resolve local monitors before computing diff
     const resolvedMonitors = await resolveLocalMonitors(monitors, state.projectId, envName);
-    // Compute diff (no deletions shown by default)
     const diff = computeDiff(resolvedMonitors, remoteMonitors, {
         includeDeletions: false,
     });
-    terminal.blank();
-    // Output
+    output.setData({
+        summary: diff.summary,
+        actions: diff.actions.map((a) => ({
+            type: a.type,
+            monitorName: a.monitor?.name ?? a.remoteMonitor?.name,
+            reason: a.reason,
+        })),
+    });
+    output.blank();
     if (options.json) {
-        terminal.log(formatDiffJson(diff));
+        output.log(formatDiffJson(diff));
     }
     else {
-        terminal.log(formatDiff(diff));
+        output.log(formatDiff(diff));
     }
-    // Exit with error code if there are changes
-    if (diff.summary.creates + diff.summary.updates + diff.summary.deletes >
-        0) {
-        terminal.exit(2); // Exit code 2 indicates changes pending
+    const changeCount = diff.summary.creates + diff.summary.updates + diff.summary.deletes;
+    if (changeCount > 0) {
+        output.exit(2);
     }
 });

package/dist/commands/hub/notifications.d.ts

@@ -4,20 +4,17 @@ export interface NotificationsListOptions {
     json?: boolean;
 }
 export interface NotificationsTestOptions {
-    /** Integration id or name. If omitted, wizard runs (select integration + provider options). */
     integration?: string;
-    /** Slack channel (e.g. #alerts). Use with Slack integration. */
     channel?: string;
-    /** Email recipients, comma-separated. Use with email integration. */
     toAddresses?: string;
+    json?: boolean;
 }
 /**
  * List notification rules (read-only).
- * Rules are defined in monitor DSL and synced via `griffin apply`.
  */
 export declare const executeNotificationsList: (options: NotificationsListOptions) => Promise<void>;
 /**
- * Test a notification integration. Without options, runs a wizard (select integration, then provider-specific prompts).
- * With --integration and routing flags, runs non-interactively.
+ * Test a notification integration.
+ * In JSON mode --integration (and routing flags) are required to avoid wizard.
  */
 export declare const executeNotificationsTest: (options: NotificationsTestOptions) => Promise<void>;

package/dist/commands/hub/notifications.js

@@ -1,7 +1,9 @@
 import { createSdkAndState } from "../../core/sdk.js";
 import { terminal } from "../../utils/terminal.js";
+import { handleSDKErrorWithOutput } from "../../utils/sdk-error.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
+import { OutputError } from "../../utils/output.js";
 import { withSDKErrorHandling } from "../../utils/sdk-error.js";
-import { withCommandErrorHandler, outputJsonOrContinue, } from "../../utils/command-wrapper.js";
 function orExit(value, errorMessage) {
     if (value === undefined) {
         terminal.error(errorMessage);
@@ -12,27 +14,31 @@ function orExit(value, errorMessage) {
 }
 /**
  * List notification rules (read-only).
- * Rules are defined in monitor DSL and synced via `griffin apply`.
  */
-export const executeNotificationsList = withCommandErrorHandler(async (options) => {
+export const executeNotificationsList = createCommandHandler("notifications list", async (options, output) => {
     const { sdk } = await createSdkAndState();
-    const response = await withSDKErrorHandling(() => sdk.getNotificationsRules({
-        query: {
-            monitorId: options.monitor,
-            enabled: options.enabled,
-        },
-    }), "Failed to fetch notification rules");
-    const rules = response?.data?.data || [];
-    if (outputJsonOrContinue(rules, options.json))
-        return;
+    let response;
+    try {
+        response = await sdk.getNotificationsRules({
+            query: {
+                monitorId: options.monitor,
+                enabled: options.enabled,
+            },
+        });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to fetch notification rules");
+    }
+    const rules = response.data?.data || [];
+    output.setData({ rules });
     if (rules.length === 0) {
-        terminal.info("No notification rules found.");
-        terminal.dim("Define notifications in your monitor DSL and run griffin apply.");
+        output.info("No notification rules found.");
+        output.dim("Define notifications in your monitor DSL and run griffin apply.");
         return;
     }
-    terminal.info("Notification Rules (synced from monitor DSL)");
-    terminal.blank();
-    const table = terminal.table({
+    output.info("Notification Rules (synced from monitor DSL)");
+    output.blank();
+    const table = output.table({
         head: ["ID", "Monitor", "Integration", "Trigger", "Enabled"],
     });
     for (const rule of rules) {
@@ -46,7 +52,7 @@ export const executeNotificationsList = withCommandErrorHandler(async (options)
             enabled,
         ]);
     }
-    terminal.log(table.toString());
+    output.log(table.toString());
 });
 async function fetchNotificationIntegrations(sdk) {
     const result = await withSDKErrorHandling(() => sdk.getIntegrations({
@@ -85,9 +91,6 @@ async function promptRoutingForProvider(provider) {
             throw new Error(`Unsupported provider: ${provider}`);
     }
 }
-/**
- * Build routing object from CLI options. Exactly one of channel, toAddresses, or webhook (none) must be used.
- */
 function buildRoutingFromOptions(options) {
     if (options.channel !== undefined && options.channel !== "") {
         return { channelType: "slack", channel: options.channel };
@@ -103,9 +106,6 @@ function buildRoutingFromOptions(options) {
     }
     return { channelType: "webhook" };
 }
-/**
- * Run interactive wizard: select integration, then prompt for provider-specific options (channel, to-addresses, or none).
- */
 async function executeNotificationsTestWizard(sdk, options) {
     const integrations = await fetchNotificationIntegrations(sdk);
     if (integrations.length === 0) {
@@ -139,12 +139,15 @@ function canBuildRoutingFromOptions(options) {
     return false;
 }
 /**
- * Test a notification integration. Without options, runs a wizard (select integration, then provider-specific prompts).
- * With --integration and routing flags, runs non-interactively.
+ * Test a notification integration.
+ * In JSON mode --integration (and routing flags) are required to avoid wizard.
  */
-export const executeNotificationsTest = withCommandErrorHandler(async (options) => {
+export const executeNotificationsTest = createCommandHandler("notifications test", async (options, output) => {
     const { sdk } = await createSdkAndState();
     const useWizard = !options.integration || !canBuildRoutingFromOptions(options);
+    if (options.json && useWizard) {
+        throw new OutputError("INTERACTIVE_REQUIRED", "In JSON mode provide --integration and routing (e.g. --channel or --to-addresses) to run non-interactively.", undefined, "Select integration and provide channel/recipients");
+    }
     let integration;
     let routing;
     if (useWizard) {
@@ -156,23 +159,34 @@ export const executeNotificationsTest = withCommandErrorHandler(async (options)
         integration = options.integration;
         routing = buildRoutingFromOptions(options);
     }
-    const spinner = terminal.spinner("Sending test notification...").start();
-    const response = await withSDKErrorHandling(() => sdk.postNotificationsTest({
-        body: { integration, routing },
-    }), "Failed to send test notification");
+    const spinner = output.spinner("Sending test notification...").start();
+    let response;
+    try {
+        response = await sdk.postNotificationsTest({
+            body: { integration, routing },
+        });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to send test notification");
+    }
     spinner.stop();
-    const result = response?.data?.data;
+    const result = response.data?.data;
     if (result?.success) {
-        terminal.success(result.message || "Test notification delivered successfully");
+        output.setData({
+            success: true,
+            message: result.message ?? "Test notification delivered successfully",
+        });
+        output.success(result.message || "Test notification delivered successfully");
     }
     else {
-        terminal.error("Test notification failed");
-        terminal.exit(1);
+        output.setData({
+            success: false,
+            message: "Test notification failed",
+        });
+        output.error("Test notification failed");
+        output.exit(1);
     }
 });
-/**
- * Format trigger for display
- */
 function formatTrigger(trigger) {
     switch (trigger.type) {
         case "run_failed":

package/dist/commands/hub/run.d.ts

@@ -3,6 +3,7 @@ export interface RunOptions {
     env: string;
     wait?: boolean;
     force?: boolean;
+    json?: boolean;
 }
 /**
  * Trigger a monitor run on the hub

package/dist/commands/hub/run.js

@@ -1,136 +1,163 @@
 import { resolveEnvironment } from "../../core/state.js";
 import { createSdkAndState } from "../../core/sdk.js";
 import { computeDiff } from "../../core/diff.js";
-import { terminal } from "../../utils/terminal.js";
-import { withSDKErrorHandling } from "../../utils/sdk-error.js";
-import { withCommandErrorHandler } from "../../utils/command-wrapper.js";
+import { handleSDKErrorWithOutput } from "../../utils/sdk-error.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
 import { discoverLocalMonitors, } from "../../core/monitor-helpers.js";
 import { loadVariables } from "../../core/variables.js";
 import { resolveMonitor } from "../../resolve.js";
+function runToData(run) {
+    return {
+        id: run.id,
+        status: run.status,
+        success: run.success,
+        startedAt: run.startedAt,
+        durationMs: run.duration_ms ?? null,
+        errors: run.errors ?? [],
+    };
+}
 /**
  * Trigger a monitor run on the hub
  */
-export const executeRun = withCommandErrorHandler(async (options) => {
+export const executeRun = createCommandHandler("run", async (options, output) => {
     const { sdk, state } = await createSdkAndState();
-    // Resolve environment
     const envName = await resolveEnvironment(options.env);
-    // Discover local monitors
     const { monitors: discoveredMonitors } = await discoverLocalMonitors(state);
-    // Find local monitor by name
     const localMonitor = discoveredMonitors.find((p) => p.monitor.name === options.monitor);
     if (!localMonitor) {
-        terminal.error(`Monitor "${options.monitor}" not found locally`);
-        terminal.blank();
-        terminal.info("Available monitors:");
+        output.setData({
+            error: "NOT_FOUND",
+            message: `Monitor "${options.monitor}" not found locally`,
+        });
+        output.error(`Monitor "${options.monitor}" not found locally`);
+        output.blank();
+        output.info("Available monitors:");
         for (const p of discoveredMonitors) {
-            terminal.dim(`  - ${p.monitor.name}`);
+            output.dim(`  - ${p.monitor.name}`);
         }
-        terminal.exit(1);
+        output.exit(1);
     }
-    // Fetch remote monitors for this project + environment
-    const fetchSpinner = terminal.spinner("Checking hub...").start();
-    const response = await withSDKErrorHandling(() => sdk.getMonitor({
-        query: {
-            projectId: state.projectId,
-            environment: envName,
-        },
-    }), "Failed to fetch monitors from hub");
-    const remoteMonitors = response?.data?.data;
-    // Find remote monitor by name
+    const fetchSpinner = output.spinner("Checking hub...").start();
+    let response;
+    try {
+        response = await sdk.getMonitor({
+            query: {
+                projectId: state.projectId,
+                environment: envName,
+            },
+        });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to fetch monitors from hub");
+    }
+    const remoteMonitors = response.data?.data;
     const remoteMonitor = remoteMonitors.find((p) => p.name === options.monitor);
     if (!remoteMonitor) {
         fetchSpinner.fail(`Monitor "${options.monitor}" not found on hub`);
-        terminal.dim("Run 'griffin apply' to sync your monitors first");
-        terminal.exit(1);
+        output.setData({
+            error: "NOT_FOUND",
+            message: `Monitor "${options.monitor}" not found on hub`,
+        });
+        output.dim("Run 'griffin apply' to sync your monitors first");
+        output.exit(1);
     }
     fetchSpinner.succeed("Monitor found on hub");
-    // Load variables and resolve local monitor before computing diff
     const variables = await loadVariables(envName);
     const resolvedLocalMonitor = resolveMonitor(localMonitor.monitor, state.projectId, envName, variables);
-    // Compute diff to check if local monitor differs from remote
-    const diff = computeDiff([resolvedLocalMonitor], [remoteMonitor], {
-        includeDeletions: false,
-    });
+    const diff = computeDiff([resolvedLocalMonitor], [remoteMonitor], { includeDeletions: false });
     const hasDiff = diff.actions.length > 0 &&
         diff.actions.some((a) => a.type === "update" || a.type === "create");
     if (hasDiff && !options.force) {
-        terminal.error(`Local monitor "${options.monitor}" differs from hub`);
-        terminal.blank();
-        terminal.warn("The monitor on the hub is different from your local version.");
-        terminal.dim("Run 'griffin apply' to sync, or use --force to run anyway.");
-        terminal.exit(1);
+        output.setData({
+            error: "LOCAL_DIFFERS",
+            message: `Local monitor "${options.monitor}" differs from hub`,
+        });
+        output.error(`Local monitor "${options.monitor}" differs from hub`);
+        output.blank();
+        output.warn("The monitor on the hub is different from your local version.");
+        output.dim("Run 'griffin apply' to sync, or use --force to run anyway.");
+        output.exit(1);
     }
-    // Trigger the run
-    terminal.blank();
-    terminal.info(`Triggering run for monitor: ${terminal.colors.cyan(options.monitor)}`);
-    terminal.log(`Target environment: ${terminal.colors.cyan(envName)}`);
+    output.blank();
+    output.info(`Triggering run for monitor: ${output.colors.cyan(options.monitor)}`);
+    output.log(`Target environment: ${output.colors.cyan(envName)}`);
     if (hasDiff && options.force) {
-        terminal.warn("Running with --force (local changes not applied)");
+        output.warn("Running with --force (local changes not applied)");
+    }
+    const triggerSpinner = output.spinner("Triggering run...").start();
+    let runResponse;
+    try {
+        runResponse = await sdk.postRunsTriggerByMonitorId({
+            path: { monitorId: remoteMonitor.id },
+            body: { environment: envName },
+        });
     }
-    const triggerSpinner = terminal.spinner("Triggering run...").start();
-    const runResponse = await withSDKErrorHandling(() => sdk.postRunsTriggerByMonitorId({
-        path: {
-            monitorId: remoteMonitor.id,
-        },
-        body: {
-            environment: envName,
-        },
-    }), "Failed to trigger run");
-    const run = runResponse?.data?.data;
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to trigger run");
+    }
+    const run = runResponse.data?.data;
     triggerSpinner.succeed("Run triggered");
-    terminal.blank();
-    terminal.log(`Run ID: ${terminal.colors.dim(run.id)}`);
-    terminal.log(`Status: ${terminal.colors.cyan(run.status)}`);
-    terminal.log(`Started: ${terminal.colors.dim(new Date(run.startedAt).toLocaleString())}`);
-    // Wait for completion if requested
+    output.blank();
+    output.log(`Run ID: ${output.colors.dim(run.id)}`);
+    output.log(`Status: ${output.colors.cyan(run.status)}`);
+    output.log(`Started: ${output.colors.dim(new Date(run.startedAt).toLocaleString())}`);
     if (options.wait) {
-        terminal.blank();
-        const waitSpinner = terminal
+        output.blank();
+        const waitSpinner = output
             .spinner("Waiting for run to complete...")
             .start();
         const runId = run.id;
-        let completed = false;
-        while (!completed) {
-            await new Promise((resolve) => setTimeout(resolve, 2000)); // Poll every 2 seconds
-            const runStatusResponse = await withSDKErrorHandling(() => sdk.getRunsById({
-                path: {
-                    id: runId,
-                },
-            }), "Failed to fetch run status");
-            const run = runStatusResponse?.data?.data;
-            if (run.status === "completed" || run.status === "failed") {
-                completed = true;
-                if (run.success) {
-                    waitSpinner.succeed(`Run ${run.status}`);
+        while (true) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            let runStatusResponse;
+            try {
+                runStatusResponse = await sdk.getRunsById({
+                    path: { id: runId },
+                });
+            }
+            catch (err) {
+                handleSDKErrorWithOutput(err, output, "Failed to fetch run status");
+            }
+            const currentRun = runStatusResponse.data?.data;
+            if (currentRun.status === "completed" || currentRun.status === "failed") {
+                if (currentRun.success) {
+                    waitSpinner.succeed(`Run ${currentRun.status}`);
                 }
                 else {
-                    waitSpinner.fail(`Run ${run.status}`);
+                    waitSpinner.fail(`Run ${currentRun.status}`);
                 }
-                terminal.blank();
-                if (run.duration_ms) {
-                    terminal.log(`Duration: ${terminal.colors.dim((run.duration_ms / 1000).toFixed(2) + "s")}`);
+                output.blank();
+                if (currentRun.duration_ms) {
+                    output.log(`Duration: ${output.colors.dim((currentRun.duration_ms / 1000).toFixed(2) + "s")}`);
                 }
-                if (run.success !== undefined) {
-                    const successText = run.success
-                        ? terminal.colors.green("Yes")
-                        : terminal.colors.red("No");
-                    terminal.log(`Success: ${successText}`);
+                if (currentRun.success !== undefined) {
+                    const successText = currentRun.success
+                        ? output.colors.green("Yes")
+                        : output.colors.red("No");
+                    output.log(`Success: ${successText}`);
                 }
-                if (run.errors && run.errors.length > 0) {
-                    terminal.blank();
-                    terminal.error("Errors:");
-                    for (const error of run.errors) {
-                        terminal.dim(`  - ${error}`);
+                if (currentRun.errors && currentRun.errors.length > 0) {
+                    output.blank();
+                    output.error("Errors:");
+                    for (const error of currentRun.errors) {
+                        output.dim(`  - ${error}`);
                     }
                 }
-                if (!run.success) {
-                    terminal.exit(1);
+                output.setData({
+                    run: runToData(currentRun),
+                });
+                if (!currentRun.success) {
+                    output.exit(1);
                 }
+                break;
             }
         }
     }
     else {
-        terminal.blank();
-        terminal.dim("Run started. Use 'griffin runs' to check progress.");
+        output.setData({
+            run: runToData(run),
+        });
+        output.blank();
+        output.dim("Run started. Use 'griffin runs' to check progress.");
     }
 });

package/dist/commands/hub/runs.d.ts

@@ -1,6 +1,8 @@
 export interface RunsOptions {
     monitor?: string;
     limit?: number;
+    env?: string;
+    json?: boolean;
 }
 /**
  * Show recent runs from the hub