@griffin-app/griffin-cli 1.0.18 → 1.0.20

package/dist/commands/hub/notifications.js

@@ -1,7 +1,7 @@
-import { loadState } from "../../core/state.js";
-import { createSdkWithCredentials } from "../../core/sdk.js";
+import { createSdkAndState } from "../../core/sdk.js";
 import { terminal } from "../../utils/terminal.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,81 +12,61 @@ function orExit(value, errorMessage) {
 }
 /**
  * List notification rules (read-only).
- * Rules are defined in monitor DSL and synced via `griffin hub apply`.
+ * Rules are defined in monitor DSL and synced via `griffin apply`.
  */
-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.");
-            terminal.dim("Define notifications in your monitor DSL and run griffin hub apply.");
-            return;
-        }
-        terminal.info("Notification Rules (synced from monitor DSL)");
-        terminal.blank();
-        const table = terminal.table({
-            head: ["ID", "Monitor", "Integration", "Trigger", "Enabled"],
-        });
-        for (const rule of rules) {
-            const triggerDesc = formatTrigger(rule.trigger);
-            const enabled = rule.enabled ? "✓" : "✗";
-            table.push([
-                rule.id.substring(0, 8) + "...",
-                rule.monitorId ?? "-",
-                rule.integrationName ?? "-",
-                triggerDesc,
-                enabled,
-            ]);
-        }
-        terminal.log(table.toString());
+export const executeNotificationsList = withCommandErrorHandler(async (options) => {
+    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;
+    if (rules.length === 0) {
+        terminal.info("No notification rules found.");
+        terminal.dim("Define notifications in your monitor DSL and run griffin apply.");
+        return;
     }
-    catch (error) {
-        terminal.error(error.message);
-        terminal.exit(1);
+    terminal.info("Notification Rules (synced from monitor DSL)");
+    terminal.blank();
+    const table = terminal.table({
+        head: ["ID", "Monitor", "Integration", "Trigger", "Enabled"],
+    });
+    for (const rule of rules) {
+        const triggerDesc = formatTrigger(rule.trigger);
+        const enabled = rule.enabled ? "✓" : "✗";
+        table.push([
+            rule.id.substring(0, 8) + "...",
+            rule.monitorId ?? "-",
+            rule.integrationName ?? "-",
+            triggerDesc,
+            enabled,
+        ]);
     }
-}
+    terminal.log(table.toString());
+});
 async function fetchNotificationIntegrations(sdk) {
     const result = await withSDKErrorHandling(() => sdk.getIntegrations({
         query: { category: "notifications", enabled: true },
     }), "Failed to fetch integrations");
     const list = result?.data?.data ?? [];
-    return list
-        .filter((i) => i.category === "notifications")
-        .map((i) => ({
-        id: i.id,
-        name: i.name,
-        provider: i.provider,
-    }));
+    return list.filter((i) => i.category === "notifications");
 }
-function promptRoutingForProvider(provider) {
+async function promptRoutingForProvider(provider) {
     switch (provider) {
         case "slack": {
             return terminal
                 .input("Slack channel (e.g. #alerts)", "#alerts")
                 .then((value) => ({
-                provider: "slack",
+                channelType: "slack",
                 channel: (value ?? "").trim() || "#alerts",
             }));
         }
-        case "email": {
+        case "email":
+        case "resend":
             return terminal.input("To addresses (comma-separated)").then((value) => {
                 const toAddresses = (value ?? "")
                     .split(",")
@@ -96,11 +76,13 @@ function promptRoutingForProvider(provider) {
                     terminal.error("At least one email address is required.");
                     terminal.exit(1);
                 }
-                return { provider: "email", toAddresses };
+                return { channelType: "email", toAddresses };
             });
-        }
+        case "webhook":
+            return { channelType: "webhook" };
         default:
-            return Promise.resolve({ provider: "webhook" });
+            terminal.error(`Unsupported provider: ${provider}`);
+            throw new Error(`Unsupported provider: ${provider}`);
     }
 }
 /**
@@ -108,7 +90,7 @@ function promptRoutingForProvider(provider) {
  */
 function buildRoutingFromOptions(options) {
     if (options.channel !== undefined && options.channel !== "") {
-        return { provider: "slack", channel: options.channel };
+        return { channelType: "slack", channel: options.channel };
     }
     if (options.toAddresses !== undefined && options.toAddresses !== "") {
         const toAddresses = options.toAddresses
@@ -116,10 +98,10 @@ function buildRoutingFromOptions(options) {
             .map((s) => s.trim())
             .filter(Boolean);
         if (toAddresses.length > 0) {
-            return { provider: "email", toAddresses };
+            return { channelType: "email", toAddresses };
         }
     }
-    return { provider: "webhook" };
+    return { channelType: "webhook" };
 }
 /**
  * Run interactive wizard: select integration, then prompt for provider-specific options (channel, to-addresses, or none).
@@ -128,7 +110,7 @@ async function executeNotificationsTestWizard(sdk, options) {
     const integrations = await fetchNotificationIntegrations(sdk);
     if (integrations.length === 0) {
         terminal.error("No notification integrations found.");
-        terminal.dim("Connect one with: griffin hub integrations connect notifications <provider>");
+        terminal.dim("Connect one with: griffin integrations connect notifications <provider>");
         terminal.exit(1);
     }
     if (options.integration) {
@@ -160,47 +142,34 @@ function canBuildRoutingFromOptions(options) {
  * Test a notification integration. Without options, runs a wizard (select integration, then provider-specific prompts).
  * With --integration and routing flags, runs non-interactively.
  */
-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 useWizard = !options.integration || !canBuildRoutingFromOptions(options);
-        let integration;
-        let routing;
-        if (useWizard) {
-            const wizardResult = await executeNotificationsTestWizard(sdk, options);
-            integration = wizardResult.integration;
-            routing = wizardResult.routing;
-        }
-        else {
-            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");
-        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);
-        }
+export const executeNotificationsTest = withCommandErrorHandler(async (options) => {
+    const { sdk } = await createSdkAndState();
+    const useWizard = !options.integration || !canBuildRoutingFromOptions(options);
+    let integration;
+    let routing;
+    if (useWizard) {
+        const wizardResult = await executeNotificationsTestWizard(sdk, options);
+        integration = wizardResult.integration;
+        routing = wizardResult.routing;
     }
-    catch (error) {
-        terminal.error(error.message);
+    else {
+        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");
+    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);
     }
-}
+});
 /**
  * Format trigger for display
  */

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

@@ -7,4 +7,4 @@ export interface RunOptions {
 /**
  * Trigger a monitor run on the hub
  */
-export declare function executeRun(options: RunOptions): Promise<void>;
+export declare const executeRun: (options: RunOptions) => Promise<void>;

package/dist/commands/hub/run.js

@@ -1,162 +1,136 @@
-import { loadState, resolveEnvironment } from "../../core/state.js";
-import { createSdkWithCredentials } from "../../core/sdk.js";
-import { discoverMonitors, formatDiscoveryErrors, } from "../../core/discovery.js";
+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 { discoverLocalMonitors, } from "../../core/monitor-helpers.js";
 import { loadVariables } from "../../core/variables.js";
 import { resolveMonitor } from "../../resolve.js";
 /**
  * Trigger a monitor run on the hub
  */
-export async function executeRun(options) {
-    try {
-        // Load state
-        const state = await loadState();
-        // Resolve environment
-        const envName = await resolveEnvironment(options.env);
-        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);
-        }
-        // Create SDK clients with credentials
-        const sdk = await createSdkWithCredentials(state.hub.baseUrl);
-        // Discover local monitors
-        const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
-        const discoveryIgnore = state.discovery?.ignore || [
-            "node_modules/**",
-            "dist/**",
-        ];
-        const spinner = terminal.spinner("Discovering local monitors...").start();
-        const { monitors: discoveredMonitors, errors } = await discoverMonitors(discoveryPattern, discoveryIgnore);
-        if (errors.length > 0) {
-            spinner.fail("Discovery failed");
-            terminal.error(formatDiscoveryErrors(errors));
-            terminal.exit(1);
-        }
-        // Find local monitor by name
-        const localMonitor = discoveredMonitors.find((p) => p.monitor.name === options.monitor);
-        if (!localMonitor) {
-            spinner.fail(`Monitor "${options.monitor}" not found locally`);
-            terminal.blank();
-            terminal.info("Available monitors:");
-            for (const p of discoveredMonitors) {
-                terminal.dim(`  - ${p.monitor.name}`);
-            }
-            terminal.exit(1);
-        }
-        spinner.succeed(`Found local monitor: ${terminal.colors.cyan(options.monitor)}`);
-        // 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 remoteMonitor = remoteMonitors.find((p) => p.name === options.monitor);
-        if (!remoteMonitor) {
-            fetchSpinner.fail(`Monitor "${options.monitor}" not found on hub`);
-            terminal.dim("Run 'griffin hub apply' to sync your monitors first");
-            terminal.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 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 hub apply' to sync, or use --force to run anyway.");
-            terminal.exit(1);
-        }
-        // Trigger the run
+export const executeRun = withCommandErrorHandler(async (options) => {
+    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(`Triggering run for monitor: ${terminal.colors.cyan(options.monitor)}`);
-        terminal.log(`Target environment: ${terminal.colors.cyan(envName)}`);
-        if (hasDiff && options.force) {
-            terminal.warn("Running with --force (local changes not applied)");
+        terminal.info("Available monitors:");
+        for (const p of discoveredMonitors) {
+            terminal.dim(`  - ${p.monitor.name}`);
         }
-        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;
-        triggerSpinner.succeed("Run triggered");
+        terminal.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 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);
+    }
+    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 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.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
-        if (options.wait) {
-            terminal.blank();
-            const waitSpinner = terminal
-                .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}`);
-                    }
-                    else {
-                        waitSpinner.fail(`Run ${run.status}`);
-                    }
+        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);
+    }
+    // Trigger the run
+    terminal.blank();
+    terminal.info(`Triggering run for monitor: ${terminal.colors.cyan(options.monitor)}`);
+    terminal.log(`Target environment: ${terminal.colors.cyan(envName)}`);
+    if (hasDiff && options.force) {
+        terminal.warn("Running with --force (local changes not applied)");
+    }
+    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;
+    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
+    if (options.wait) {
+        terminal.blank();
+        const waitSpinner = terminal
+            .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}`);
+                }
+                else {
+                    waitSpinner.fail(`Run ${run.status}`);
+                }
+                terminal.blank();
+                if (run.duration_ms) {
+                    terminal.log(`Duration: ${terminal.colors.dim((run.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 (run.errors && run.errors.length > 0) {
                     terminal.blank();
-                    if (run.duration_ms) {
-                        terminal.log(`Duration: ${terminal.colors.dim((run.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 (run.errors && run.errors.length > 0) {
-                        terminal.blank();
-                        terminal.error("Errors:");
-                        for (const error of run.errors) {
-                            terminal.dim(`  - ${error}`);
-                        }
-                    }
-                    if (!run.success) {
-                        terminal.exit(1);
+                    terminal.error("Errors:");
+                    for (const error of run.errors) {
+                        terminal.dim(`  - ${error}`);
                     }
                 }
+                if (!run.success) {
+                    terminal.exit(1);
+                }
             }
         }
-        else {
-            terminal.blank();
-            terminal.dim("Run started. Use 'griffin hub runs' to check progress.");
-        }
     }
-    catch (error) {
-        terminal.error(error.message);
-        terminal.exit(1);
+    else {
+        terminal.blank();
+        terminal.dim("Run started. Use 'griffin runs' to check progress.");
     }
-}
+});

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

@@ -5,4 +5,4 @@ export interface RunsOptions {
 /**
  * Show recent runs from the hub
  */
-export declare function executeRuns(options: RunsOptions): Promise<void>;
+export declare const executeRuns: (options: RunsOptions) => Promise<void>;