@griffin-app/griffin-cli 1.0.7 → 1.0.8

package/dist/cli.js

@@ -9,12 +9,14 @@ import { executeRunLocal } from "./commands/local/run.js";
 // Hub commands
 import { executeConnect } from "./commands/hub/connect.js";
 import { executeStatus } from "./commands/hub/status.js";
+import { executeMetrics } from "./commands/hub/metrics.js";
 import { executeRuns } from "./commands/hub/runs.js";
 import { executeMonitor } from "./commands/hub/monitor.js";
 import { executeApply } from "./commands/hub/apply.js";
 import { executeRun } from "./commands/hub/run.js";
 import { executeLogin } from "./commands/hub/login.js";
 import { executeLogout } from "./commands/hub/logout.js";
+import { executeNotificationsList, executeNotificationsAdd, executeNotificationsDelete, executeNotificationsTest, } from "./commands/hub/notifications.js";
 const program = new Command();
 program
     .name("griffin")
@@ -72,6 +74,19 @@ hub
     .action(async () => {
     await executeStatus();
 });
+hub
+    .command("metrics")
+    .description("Show metrics summary from the hub")
+    .option("--period <period>", "Time window: 1h, 6h, 24h, 7d, 30d", "24h")
+    .option("--environment <env>", "Filter by environment")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    await executeMetrics({
+        period: options.period,
+        environment: options.environment,
+        json: options.json,
+    });
+});
 hub
     .command("runs")
     .description("Show recent runs from the hub")
@@ -120,5 +135,58 @@ hub
     .action(async (options) => {
     await executeLogout(options);
 });
+// Notifications command group
+const notifications = hub
+    .command("notifications")
+    .description("Manage notification rules");
+notifications
+    .command("list")
+    .description("List notification rules")
+    .option("--monitor <id>", "Filter by monitor ID")
+    .option("--enabled", "Filter by enabled status")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    await executeNotificationsList({
+        monitor: options.monitor,
+        enabled: options.enabled ? true : undefined,
+        json: options.json,
+    });
+});
+notifications
+    .command("add")
+    .description("Create a notification rule")
+    .requiredOption("--name <name>", "Rule name")
+    .option("--monitor <id>", "Monitor ID (optional, applies to all if not specified)")
+    .option("--environment <env>", "Environment filter")
+    .option("--location <loc>", "Location filter")
+    .requiredOption("--trigger <trigger>", "Trigger: run_failed, run_recovered, consecutive_failures:N, success_rate_below:threshold:window_min, latency_above:threshold_ms:percentile:window_min")
+    .requiredOption("--webhook <url>", "Webhook URL")
+    .option("--cooldown <minutes>", "Cooldown period in minutes", "15")
+    .action(async (options) => {
+    await executeNotificationsAdd({
+        name: options.name,
+        monitor: options.monitor,
+        environment: options.environment,
+        location: options.location,
+        trigger: options.trigger,
+        webhook: options.webhook,
+        cooldown: options.cooldown ? parseInt(options.cooldown, 10) : undefined,
+    });
+});
+notifications
+    .command("delete <id>")
+    .description("Delete a notification rule")
+    .action(async (id) => {
+    await executeNotificationsDelete({ id });
+});
+notifications
+    .command("test")
+    .description("Test a webhook configuration")
+    .requiredOption("--webhook <url>", "Webhook URL to test")
+    .action(async (options) => {
+    await executeNotificationsTest({
+        webhook: options.webhook,
+    });
+});
 // Parse arguments
 program.parse();

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

@@ -0,0 +1,12 @@
+declare const METRICS_PERIODS: readonly ["1h", "6h", "24h", "7d", "30d"];
+type MetricsPeriod = (typeof METRICS_PERIODS)[number];
+export interface MetricsOptions {
+    period?: MetricsPeriod;
+    environment?: string;
+    json?: boolean;
+}
+/**
+ * Show metrics summary from the hub
+ */
+export declare function executeMetrics(options: MetricsOptions): Promise<void>;
+export {};

package/dist/commands/hub/metrics.js

@@ -0,0 +1,78 @@
+import { loadState } from "../../core/state.js";
+import { getHubCredentials } from "../../core/credentials.js";
+import { terminal } from "../../utils/terminal.js";
+const METRICS_PERIODS = ["1h", "6h", "24h", "7d", "30d"];
+/**
+ * Show metrics summary from the hub
+ */
+export async function executeMetrics(options) {
+    try {
+        const state = await loadState();
+        if (!state.hub?.baseUrl) {
+            terminal.error("No hub connection configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
+        }
+        const credentials = await getHubCredentials();
+        const token = credentials?.token;
+        if (!token) {
+            terminal.error("No API token. Run 'griffin hub login' or connect with --token.");
+            terminal.exit(1);
+        }
+        const baseUrl = state.hub.baseUrl;
+        const period = options.period ?? "24h";
+        const url = new URL(baseUrl);
+        url.pathname = "/metrics/summary";
+        url.searchParams.set("period", period);
+        if (options.environment) {
+            url.searchParams.set("environment", options.environment);
+        }
+        const spinner = terminal.spinner("Fetching metrics...").start();
+        const response = await fetch(url.toString(), {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        spinner.stop();
+        if (!response.ok) {
+            const text = await response.text();
+            terminal.error(`Failed to fetch metrics: ${response.status} ${response.statusText}`);
+            if (text)
+                terminal.dim(text);
+            terminal.exit(1);
+        }
+        const body = (await response.json());
+        const data = body.data;
+        if (options.json) {
+            terminal.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        terminal.info(`Metrics (${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();
+        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();
+        }
+        terminal.log(`Uptime: ${data.uptimePercent.toFixed(1)}%`);
+        terminal.blank();
+        if (data.failingMonitors.length > 0) {
+            terminal.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()}`);
+            }
+        }
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}

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

@@ -0,0 +1,36 @@
+export interface NotificationsListOptions {
+    monitor?: string;
+    enabled?: boolean;
+    json?: boolean;
+}
+export interface NotificationsAddOptions {
+    name: string;
+    monitor?: string;
+    environment?: string;
+    location?: string;
+    trigger: string;
+    webhook: string;
+    cooldown?: number;
+}
+export interface NotificationsDeleteOptions {
+    id: string;
+}
+export interface NotificationsTestOptions {
+    webhook: string;
+}
+/**
+ * List notification rules
+ */
+export declare function executeNotificationsList(options: NotificationsListOptions): Promise<void>;
+/**
+ * Add a notification rule
+ */
+export declare function executeNotificationsAdd(options: NotificationsAddOptions): Promise<void>;
+/**
+ * Delete a notification rule
+ */
+export declare function executeNotificationsDelete(options: NotificationsDeleteOptions): Promise<void>;
+/**
+ * Test a webhook
+ */
+export declare function executeNotificationsTest(options: NotificationsTestOptions): Promise<void>;

package/dist/commands/hub/notifications.js

@@ -0,0 +1,225 @@
+import { loadState } from "../../core/state.js";
+import { createSdkWithCredentials } from "../../core/sdk.js";
+import { terminal } from "../../utils/terminal.js";
+import { withSDKErrorHandling } from "../../utils/sdk-error.js";
+/**
+ * List notification rules
+ */
+export async function executeNotificationsList(options) {
+    try {
+        const state = await loadState();
+        if (!state.hub?.baseUrl) {
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
+        }
+        const sdk = await createSdkWithCredentials(state.hub.baseUrl);
+        const response = await withSDKErrorHandling(() => sdk.getNotificationsRules({
+            query: {
+                monitorId: options.monitor,
+                enabled: options.enabled,
+            },
+        }), "Failed to fetch notification rules");
+        const rules = response?.data?.data || [];
+        if (options.json) {
+            terminal.log(JSON.stringify(rules, null, 2));
+            return;
+        }
+        if (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 rules) {
+            const triggerDesc = formatTrigger(rule.trigger);
+            const channels = rule.channels
+                .map((ch) => (ch.type === "webhook" ? "webhook" : ch.type))
+                .join(", ");
+            const monitorName = rule.monitorId || "all monitors";
+            const enabled = rule.enabled ? "✓" : "✗";
+            table.push([
+                rule.id.substring(0, 8) + "...",
+                rule.name,
+                monitorName,
+                triggerDesc,
+                channels,
+                enabled,
+            ]);
+        }
+        terminal.log(table.toString());
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Add a notification rule
+ */
+export async function executeNotificationsAdd(options) {
+    try {
+        const state = await loadState();
+        if (!state.hub?.baseUrl) {
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
+        }
+        // Parse trigger
+        const trigger = parseTrigger(options.trigger);
+        if (!trigger) {
+            terminal.error(`Invalid trigger: ${options.trigger}. Expected format: type[:value]`);
+            terminal.dim("Examples:");
+            terminal.dim("  run_failed");
+            terminal.dim("  consecutive_failures:3");
+            terminal.dim("  success_rate_below:80:60");
+            terminal.exit(1);
+        }
+        const sdk = await createSdkWithCredentials(state.hub.baseUrl);
+        const response = await withSDKErrorHandling(() => sdk.postNotificationsRules({
+            body: {
+                name: options.name,
+                monitorId: options.monitor,
+                environment: options.environment,
+                location: options.location,
+                trigger,
+                channels: [
+                    {
+                        type: "webhook",
+                        url: options.webhook,
+                    },
+                ],
+                cooldownMinutes: options.cooldown,
+            },
+        }), "Failed to create notification rule");
+        const rule = response?.data?.data;
+        if (rule) {
+            terminal.success(`Created notification rule: ${rule.id}`);
+        }
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Delete a notification rule
+ */
+export async function executeNotificationsDelete(options) {
+    try {
+        const state = await loadState();
+        if (!state.hub?.baseUrl) {
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
+        }
+        const sdk = await createSdkWithCredentials(state.hub.baseUrl);
+        await withSDKErrorHandling(() => sdk.deleteNotificationsRulesById({ path: { id: options.id } }), "Failed to delete notification rule");
+        terminal.success(`Deleted notification rule: ${options.id}`);
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Test a webhook
+ */
+export async function executeNotificationsTest(options) {
+    try {
+        const state = await loadState();
+        if (!state.hub?.baseUrl) {
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
+        }
+        const sdk = await createSdkWithCredentials(state.hub.baseUrl);
+        const spinner = terminal.spinner("Sending test notification...").start();
+        const response = await withSDKErrorHandling(() => sdk.postNotificationsTest({
+            body: {
+                channel: {
+                    type: "webhook",
+                    url: options.webhook,
+                },
+            },
+        }), "Failed to send test notification");
+        spinner.stop();
+        const result = response?.data?.data;
+        if (result?.success) {
+            terminal.success(result.message || "Test notification delivered successfully");
+        }
+        else {
+            terminal.error("Test notification failed");
+            terminal.exit(1);
+        }
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Parse trigger string into trigger object
+ */
+function parseTrigger(triggerStr) {
+    const parts = triggerStr.split(":");
+    const type = parts[0];
+    switch (type) {
+        case "run_failed":
+            return { type: "run_failed" };
+        case "run_recovered":
+            return { type: "run_recovered" };
+        case "consecutive_failures":
+            if (parts.length < 2)
+                return null;
+            return {
+                type: "consecutive_failures",
+                threshold: parseInt(parts[1], 10),
+            };
+        case "success_rate_below":
+            if (parts.length < 3)
+                return null;
+            return {
+                type: "success_rate_below",
+                threshold: parseFloat(parts[1]),
+                window_minutes: parseInt(parts[2], 10),
+            };
+        case "latency_above":
+            if (parts.length < 4)
+                return null;
+            return {
+                type: "latency_above",
+                threshold_ms: parseInt(parts[1], 10),
+                percentile: parts[2],
+                window_minutes: parseInt(parts[3], 10),
+            };
+        default:
+            return null;
+    }
+}
+/**
+ * Format trigger for display
+ */
+function formatTrigger(trigger) {
+    switch (trigger.type) {
+        case "run_failed":
+            return "Run failed";
+        case "run_recovered":
+            return "Run recovered";
+        case "consecutive_failures":
+            return `${trigger.threshold} consecutive failures`;
+        case "success_rate_below":
+            return `Success rate < ${trigger.threshold}% (${trigger.window_minutes}m)`;
+        case "latency_above":
+            return `${trigger.percentile} latency > ${trigger.threshold_ms}ms (${trigger.window_minutes}m)`;
+        default:
+            return String(trigger.type);
+    }
+}

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");
+    }
+}

package/dist/output/types.d.ts

@@ -0,0 +1,153 @@
+import type { ApplyResult } from "../core/apply.js";
+import type { DiffResult } from "../core/diff.js";
+/**
+ * Base result type for all CLI commands.
+ * Discriminated union: success yields data; failure yields error and optional hint.
+ * exitCode: if set, used when exiting (default 0 for success, 1 for failure).
+ */
+export type CommandResult<T> = {
+    success: true;
+    data: T;
+    warnings?: string[];
+    exitCode?: number;
+} | {
+    success: false;
+    error: string;
+    hint?: string;
+    exitCode?: number;
+};
+export interface InitResultData {
+    projectId: string;
+    stateFile: string;
+    environments: string[];
+    variablesCreated: boolean;
+    nextSteps: string[];
+}
+export interface ConnectResultData {
+    url: string;
+    tokenSet: boolean;
+}
+export interface LoginResultData {
+    success: true;
+}
+export interface LogoutResultData {
+    success: true;
+}
+export interface GenerateKeyResultData {
+    apiKey: string;
+}
+export interface ValidateMonitorInfo {
+    name: string;
+    filePath: string;
+    exportName: string;
+    nodes: number;
+    edges: number;
+    frequency?: {
+        every: number;
+        unit: string;
+    };
+}
+export interface ValidateResultData {
+    monitors: ValidateMonitorInfo[];
+    valid: boolean;
+}
+export interface EnvListResultData {
+    environments: string[];
+    default: string | null;
+}
+export interface StatusResultData {
+    url: string;
+    token: string | null;
+    updatedAt: string | null;
+}
+export interface RunSummary {
+    id: string;
+    monitorId: string | null;
+    status: string;
+    success?: boolean;
+    duration_ms?: number;
+    startedAt: string;
+    errors?: string[];
+}
+export interface RunsResultData {
+    runs: RunSummary[];
+    total: number;
+}
+export interface MetricsResultData {
+    period: string;
+    periodStart: string;
+    periodEnd: string;
+    monitors: {
+        total: number;
+        passing: number;
+        failing: number;
+        noRecentRuns: number;
+    };
+    runs: {
+        total: number;
+        successful: number;
+        failed: number;
+        successRate: number;
+    };
+    latency: {
+        p50DurationMs: number | null;
+        p95DurationMs: number | null;
+        p99DurationMs: number | null;
+    };
+    uptimePercent: number;
+    failingMonitors: Array<{
+        monitorId: string;
+        monitorName: string;
+        lastFailureAt: string;
+        consecutiveFailures: number;
+    }>;
+}
+export interface MonitorResultData {
+    diff: DiffResult;
+    hasChanges: boolean;
+}
+export interface ApplyResultData {
+    diff: DiffResult;
+    applied: ApplyResult;
+    dryRun: boolean;
+}
+export interface LocalRunResultData {
+    results: Array<{
+        file: string;
+        success: boolean;
+    }>;
+    passed: number;
+    failed: number;
+    total: number;
+}
+export interface HubRunResultData {
+    runId: string;
+    status: string;
+    success?: boolean;
+    duration_ms?: number;
+    startedAt: string;
+    errors?: string[];
+    waited?: boolean;
+}
+export interface NotificationRuleSummary {
+    id: string;
+    name: string;
+    monitorId: string | null;
+    trigger: unknown;
+    channels: string[];
+    enabled: boolean;
+}
+export interface NotificationsListResultData {
+    rules: NotificationRuleSummary[];
+}
+export interface NotificationsAddResultData {
+    id: string;
+    name: string;
+}
+export interface NotificationsDeleteResultData {
+    id: string;
+}
+export interface NotificationsTestResultData {
+    success: boolean;
+    message: string;
+}

package/dist/output/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/sdk-error.js

@@ -109,6 +109,8 @@ export async function withSDKErrorHandling(fn, context) {
         return await fn();
     }
     catch (error) {
+        console.error("error");
+        console.error(error);
         handleSDKError(error, context);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@griffin-app/griffin-cli",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "CLI tool for running and managing griffin API tests",
   "type": "module",
   "main": "dist/index.js",
@@ -23,7 +23,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@griffin-app/griffin-hub-sdk": "1.0.7",
+    "@griffin-app/griffin-hub-sdk": "1.0.8",
     "@griffin-app/griffin-plan-executor": "0.1.14",
     "@griffin-app/griffin-ts": "0.1.14",
     "better-auth": "^1.4.17",