@griffin-app/griffin-cli 1.0.7 → 1.0.9

package/dist/cli.js

@@ -9,12 +9,15 @@ 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, executeNotificationsTest, } from "./commands/hub/notifications.js";
+import { executeSecretsList, executeSecretsSet, executeSecretsGet, executeSecretsDelete, } from "./commands/hub/secrets.js";
 const program = new Command();
 program
     .name("griffin")
@@ -51,7 +54,7 @@ env
 // Local command group
 const local = program.command("local").description("Local test execution");
 local
-    .command("run <env>")
+    .command("run [env]")
     .description("Run tests locally against an environment")
     .action(async (env, options) => {
     await executeRunLocal({ env });
@@ -72,6 +75,18 @@ hub
     .action(async () => {
     await executeStatus();
 });
+hub
+    .command("metrics [env]")
+    .description("Show metrics summary from the hub")
+    .option("--period <period>", "Time window: 1h, 6h, 24h, 7d, 30d", "24h")
+    .option("--json", "Output as JSON")
+    .action(async (env, options) => {
+    await executeMetrics({
+        period: options.period,
+        environment: env,
+        json: options.json,
+    });
+});
 hub
     .command("runs")
     .description("Show recent runs from the hub")
@@ -84,14 +99,14 @@ hub
     });
 });
 hub
-    .command("monitor <env>")
+    .command("plan [env]")
     .description("Show what changes would be applied")
     .option("--json", "Output in JSON format")
     .action(async (env, options) => {
     await executeMonitor({ ...options, env });
 });
 hub
-    .command("apply <env>")
+    .command("apply [env]")
     .description("Apply changes to the hub")
     .option("--auto-approve", "Skip confirmation prompt")
     .option("--dry-run", "Show what would be done without making changes")
@@ -100,7 +115,7 @@ hub
     await executeApply({ ...options, env });
 });
 hub
-    .command("run <env>")
+    .command("run [env]")
     .description("Trigger a monitor run on the hub")
     .requiredOption("--monitor <name>", "Monitor name to run")
     .option("--wait", "Wait for run to complete")
@@ -120,5 +135,82 @@ hub
     .action(async (options) => {
     await executeLogout(options);
 });
+// Notifications command group
+const notifications = hub
+    .command("notifications")
+    .description("View notification rules (rules are defined in monitor DSL and synced via griffin hub apply)");
+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("test")
+    .description("Test a webhook configuration")
+    .requiredOption("--webhook <url>", "Webhook URL to test")
+    .action(async (options) => {
+    await executeNotificationsTest({
+        webhook: options.webhook,
+    });
+});
+// Secrets command group
+const secrets = hub
+    .command("secrets")
+    .description("Manage secrets (platform storage)");
+secrets
+    .command("list")
+    .description("List secrets for an environment")
+    .option("--environment <env>", "Environment name", "default")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    await executeSecretsList({
+        environment: options.environment,
+        json: options.json,
+    });
+});
+secrets
+    .command("set <name>")
+    .description("Create or update a secret (prompts for value)")
+    .option("--environment <env>", "Environment name", "default")
+    .option("--value <value>", "Secret value (avoid for sensitive data)")
+    .action(async (name, options) => {
+    await executeSecretsSet({
+        name,
+        environment: options.environment,
+        value: options.value,
+    });
+});
+secrets
+    .command("get <name>")
+    .description("Show secret metadata (not the value)")
+    .option("--environment <env>", "Environment name", "default")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+    await executeSecretsGet({
+        name,
+        environment: options.environment,
+        json: options.json,
+    });
+});
+secrets
+    .command("delete <name>")
+    .description("Delete a secret")
+    .option("--environment <env>", "Environment name", "default")
+    .option("--force", "Skip confirmation prompt")
+    .action(async (name, options) => {
+    await executeSecretsDelete({
+        name,
+        environment: options.environment,
+        force: options.force,
+    });
+});
 // Parse arguments
 program.parse();

package/dist/commands/env.js

@@ -16,13 +16,8 @@ export async function executeEnvList() {
         terminal.info("Available environments:");
         terminal.blank();
         for (const envName of environments) {
-            const isDefault = state.defaultEnvironment === envName;
-            const marker = isDefault
-                ? terminal.colors.green("●")
-                : terminal.colors.dim("○");
-            const envDisplay = isDefault
-                ? terminal.colors.cyan(envName) + terminal.colors.dim(" (default)")
-                : envName;
+            const marker = terminal.colors.green("●");
+            const envDisplay = terminal.colors.cyan(envName);
             terminal.log(`  ${marker} ${envDisplay}`);
         }
         terminal.blank();

package/dist/commands/hub/apply.js

@@ -1,5 +1,5 @@
 import { loadState, resolveEnvironment } from "../../core/state.js";
-import { discoverMonitors, formatDiscoveryErrors } from "../../core/discovery.js";
+import { discoverMonitors, formatDiscoveryErrors, } from "../../core/discovery.js";
 import { computeDiff, formatDiff } from "../../core/diff.js";
 import { applyDiff, formatApplyResult } from "../../core/apply.js";
 import { createSdkWithCredentials } from "../../core/sdk.js";
@@ -42,7 +42,9 @@ export async function executeApply(options) {
         }
         spinner.succeed(`Found ${monitors.length} local monitor(s)`);
         // Fetch remote monitors for this project + environment
-        const fetchSpinner = terminal.spinner("Fetching remote monitors...").start();
+        const fetchSpinner = terminal
+            .spinner("Fetching remote monitors...")
+            .start();
         const response = await withSDKErrorHandling(() => sdk.getMonitor({
             query: {
                 projectId: state.projectId,

package/dist/commands/hub/login.js

@@ -1,20 +1,20 @@
 // CLI implementation
 import { createAuthClient } from "better-auth/client";
 import { deviceAuthorizationClient, jwtClient, } from "better-auth/client/plugins";
-import { getProjectId, loadState, saveState } from "../../core/state.js";
+import { loadState, saveState } from "../../core/state.js";
 import { saveHubCredentials } from "../../core/credentials.js";
 import { terminal } from "../../utils/terminal.js";
 import { randomBytes } from "crypto";
-import { createEmptyState } from "../../schemas/state.js";
-const baseURL = "http://localhost:4000/api/auth";
-const hubBaseUrl = "http://localhost:3000";
-//const baseURL = "https://cloud.griffin.app"
 const oauthGrant = "urn:ietf:params:oauth:grant-type:device_code";
-const authClient = createAuthClient({
-    baseURL: baseURL,
-    plugins: [deviceAuthorizationClient(), jwtClient()],
-});
+function createAuthClientFromState(state) {
+    return createAuthClient({
+        baseURL: state.cloud.authUrl,
+        plugins: [deviceAuthorizationClient(), jwtClient()],
+    });
+}
 async function pollForToken(clientId, deviceCode, interval) {
+    const state = await loadState();
+    const authClient = createAuthClientFromState(state);
     const { data, error } = await authClient.device.token({
         grant_type: oauthGrant,
         device_code: deviceCode,
@@ -39,16 +39,9 @@ async function pollForToken(clientId, deviceCode, interval) {
     }
 }
 export async function executeLogin() {
-    let state;
-    let clientId;
-    try {
-        state = await loadState();
-        clientId = state.hub?.clientId;
-    }
-    catch (error) { }
-    if (!clientId) {
-        clientId = randomBytes(16).toString("hex");
-    }
+    const state = await loadState();
+    const clientId = state.hub?.clientId ?? randomBytes(16).toString("hex");
+    const authClient = createAuthClientFromState(state);
     const { data } = await authClient.device.code({
         client_id: clientId,
     });
@@ -69,17 +62,11 @@ export async function executeLogin() {
         terminal.success("Login successful");
         terminal.log(`  Token saved to user credentials`);
     }
-    if (!state) {
-        const projectId = await getProjectId();
-        state = createEmptyState(projectId);
-    }
-    // Save hub config to project state (without token)
     await saveState({
         ...state,
         hub: {
             ...state.hub,
             clientId: clientId,
-            baseUrl: hubBaseUrl,
         },
     });
 }

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/monitor.js

@@ -1,5 +1,5 @@
 import { loadState, resolveEnvironment } from "../../core/state.js";
-import { discoverMonitors, formatDiscoveryErrors } from "../../core/discovery.js";
+import { discoverMonitors, formatDiscoveryErrors, } from "../../core/discovery.js";
 import { createSdkWithCredentials } from "../../core/sdk.js";
 import { computeDiff, formatDiff, formatDiffJson } from "../../core/diff.js";
 import { terminal } from "../../utils/terminal.js";
@@ -38,7 +38,9 @@ export async function executeMonitor(options) {
         // Create SDK clients with credentials
         const sdk = await createSdkWithCredentials(state.hub.baseUrl);
         // Fetch remote monitors for this project + environment
-        const fetchSpinner = terminal.spinner("Fetching remote monitors...").start();
+        const fetchSpinner = terminal
+            .spinner("Fetching remote monitors...")
+            .start();
         const response = await withSDKErrorHandling(() => sdk.getMonitor({
             query: {
                 projectId: state.projectId,

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

@@ -0,0 +1,17 @@
+export interface NotificationsListOptions {
+    monitor?: string;
+    enabled?: boolean;
+    json?: boolean;
+}
+export interface NotificationsTestOptions {
+    webhook: string;
+}
+/**
+ * List notification rules (read-only).
+ * Rules are defined in monitor DSL and synced via `griffin hub apply`.
+ */
+export declare function executeNotificationsList(options: NotificationsListOptions): Promise<void>;
+/**
+ * Test a webhook
+ */
+export declare function executeNotificationsTest(options: NotificationsTestOptions): Promise<void>;

package/dist/commands/hub/notifications.js

@@ -0,0 +1,113 @@
+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 (read-only).
+ * Rules are defined in monitor DSL and synced via `griffin hub 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());
+    }
+    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);
+    }
+}
+/**
+ * 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/commands/hub/run.js

@@ -1,6 +1,6 @@
 import { loadState, resolveEnvironment } from "../../core/state.js";
 import { createSdkWithCredentials } from "../../core/sdk.js";
-import { discoverMonitors, formatDiscoveryErrors } from "../../core/discovery.js";
+import { discoverMonitors, formatDiscoveryErrors, } from "../../core/discovery.js";
 import { computeDiff } from "../../core/diff.js";
 import { terminal } from "../../utils/terminal.js";
 import { withSDKErrorHandling } from "../../utils/sdk-error.js";

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

@@ -0,0 +1,35 @@
+export interface SecretsListOptions {
+    environment?: string;
+    json?: boolean;
+}
+export interface SecretsSetOptions {
+    name: string;
+    environment?: string;
+    value?: string;
+}
+export interface SecretsGetOptions {
+    name: string;
+    environment?: string;
+    json?: boolean;
+}
+export interface SecretsDeleteOptions {
+    name: string;
+    environment?: string;
+    force?: boolean;
+}
+/**
+ * List secrets (metadata only)
+ */
+export declare function executeSecretsList(options: SecretsListOptions): Promise<void>;
+/**
+ * Set a secret (prompts for value if not provided)
+ */
+export declare function executeSecretsSet(options: SecretsSetOptions): Promise<void>;
+/**
+ * Get secret metadata only
+ */
+export declare function executeSecretsGet(options: SecretsGetOptions): Promise<void>;
+/**
+ * Delete a secret (with confirmation unless --force)
+ */
+export declare function executeSecretsDelete(options: SecretsDeleteOptions): Promise<void>;