@griffin-app/griffin-cli 1.0.11 → 1.0.13

package/dist/commands/hub/notifications.js

@@ -2,6 +2,14 @@ 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";
+function orExit(value, errorMessage) {
+    if (value === undefined) {
+        terminal.error(errorMessage);
+        terminal.exit(1);
+        throw new Error(errorMessage);
+    }
+    return value;
+}
 /**
  * List notification rules (read-only).
  * Rules are defined in monitor DSL and synced via `griffin hub apply`.
@@ -55,8 +63,102 @@ export async function executeNotificationsList(options) {
         terminal.exit(1);
     }
 }
+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,
+    }));
+}
+function promptRoutingForProvider(provider) {
+    switch (provider) {
+        case "slack": {
+            return terminal
+                .input("Slack channel (e.g. #alerts)", "#alerts")
+                .then((value) => ({
+                provider: "slack",
+                channel: (value ?? "").trim() || "#alerts",
+            }));
+        }
+        case "email": {
+            return terminal.input("To addresses (comma-separated)").then((value) => {
+                const toAddresses = (value ?? "")
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                if (toAddresses.length === 0) {
+                    terminal.error("At least one email address is required.");
+                    terminal.exit(1);
+                }
+                return { provider: "email", toAddresses };
+            });
+        }
+        default:
+            return Promise.resolve({ provider: "webhook" });
+    }
+}
 /**
- * Test a webhook
+ * 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 { provider: "slack", channel: options.channel };
+    }
+    if (options.toAddresses !== undefined && options.toAddresses !== "") {
+        const toAddresses = options.toAddresses
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (toAddresses.length > 0) {
+            return { provider: "email", toAddresses };
+        }
+    }
+    return { provider: "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) {
+        terminal.error("No notification integrations found.");
+        terminal.dim("Connect one with: griffin hub integrations connect notifications <provider>");
+        terminal.exit(1);
+    }
+    if (options.integration) {
+        const match = orExit(integrations.find((i) => i.id === options.integration ||
+            i.name.toLowerCase() === (options.integration ?? "").toLowerCase()), `Integration not found: ${options.integration}`);
+        const routing = await promptRoutingForProvider(match.provider);
+        return { integration: match.id, routing };
+    }
+    const choiceLabels = integrations.map((i) => `${i.name} (${i.provider})`);
+    const choice = await terminal.select("Select integration to test", choiceLabels);
+    const found = orExit(integrations.find((i) => `${i.name} (${i.provider})` === choice), "No integration selected.");
+    const routing = await promptRoutingForProvider(found.provider);
+    return { integration: found.id, routing };
+}
+function canBuildRoutingFromOptions(options) {
+    if (options.channel !== undefined && options.channel !== "")
+        return true;
+    if (options.toAddresses !== undefined && options.toAddresses !== "") {
+        const toAddresses = options.toAddresses
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (toAddresses.length > 0)
+            return true;
+    }
+    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.
  */
 export async function executeNotificationsTest(options) {
     try {
@@ -68,14 +170,21 @@ export async function executeNotificationsTest(options) {
             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: {
-                channel: {
-                    type: "webhook",
-                    url: options.webhook,
-                },
-            },
+            body: { integration, routing },
         }), "Failed to send test notification");
         spinner.stop();
         const result = response?.data?.data;

package/dist/commands/init.js

@@ -1,19 +1,6 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { initState, stateExists, getStateFilePath, } from "../core/state.js";
+import { initState, stateExists, getStateFilePath } from "../core/state.js";
 import { detectProjectId } from "../core/project.js";
 import { terminal } from "../utils/terminal.js";
-const VARIABLES_FILE = "variables.yaml";
-const VARIABLES_TEMPLATE = `# Per-environment variables for test monitors. Reference in monitors with variable("key").
-# Edit values below for each environment.
-environments:
-  dev:
-    # api_key: "your-api-key"
-  staging:
-    # api_key: "your-staging-key"
-  production:
-    # api_key: "your-production-key"
-`;
 /**
  * Initialize griffin in the current directory
  */
@@ -31,30 +18,21 @@ export async function executeInit(options) {
         projectId = await detectProjectId();
     }
     spinner.succeed(`Project: ${terminal.colors.cyan(projectId)}`);
-    // Initialize state file
+    // Initialize state file (includes default environment)
     await initState(projectId);
     terminal.success(`Created state file: ${terminal.colors.dim(getStateFilePath())}`);
-    // Create variables.yaml if it doesn't exist
-    const variablesPath = path.join(process.cwd(), VARIABLES_FILE);
-    try {
-        await fs.access(variablesPath);
-        terminal.dim(`variables.yaml already exists, skipping`);
-    }
-    catch {
-        await fs.writeFile(variablesPath, VARIABLES_TEMPLATE, "utf-8");
-        terminal.success(`Created ${terminal.colors.dim(VARIABLES_FILE)}`);
-    }
     terminal.blank();
     terminal.success("Initialization complete!");
     terminal.blank();
     terminal.info("Next steps:");
-    terminal.dim("  1. Edit variables.yaml to set api_host and other variables per environment");
+    terminal.dim("  1. Add variables for your environment (optional):");
+    terminal.dim("     griffin variables add API_KEY=your-key --env default");
     terminal.dim("  2. Create test monitors (*.ts files in __griffin__/ directories)");
-    terminal.dim("  3. Run tests locally (pass environment name):");
-    terminal.dim("     griffin local run dev");
+    terminal.dim("  3. Run tests locally:");
+    terminal.dim("     griffin local run");
     terminal.dim("  4. Connect to hub (optional):");
     terminal.dim("     griffin hub connect --url <url> --token <token>");
     terminal.dim("  5. Deploy to hub:");
-    terminal.dim("     griffin hub apply dev");
+    terminal.dim("     griffin hub apply");
     terminal.blank();
 }

package/dist/commands/variables.d.ts

@@ -0,0 +1,12 @@
+/**
+ * List all variables for an environment
+ */
+export declare function executeVariablesList(env: string): Promise<void>;
+/**
+ * Add or update a variable for an environment
+ */
+export declare function executeVariablesAdd(keyValue: string, env: string): Promise<void>;
+/**
+ * Remove a variable from an environment
+ */
+export declare function executeVariablesRemove(key: string, env: string): Promise<void>;

package/dist/commands/variables.js

@@ -0,0 +1,87 @@
+import { loadState, saveState, getEnvironment } from "../core/state.js";
+import { terminal } from "../utils/terminal.js";
+/**
+ * List all variables for an environment
+ */
+export async function executeVariablesList(env) {
+    try {
+        const state = await loadState();
+        const envConfig = await getEnvironment(env);
+        if (!envConfig.variables || Object.keys(envConfig.variables).length === 0) {
+            terminal.warn(`No variables defined for environment '${env}'.`);
+            terminal.blank();
+            terminal.dim(`Add variables with: griffin variables add KEY=VALUE --env ${env}`);
+            terminal.blank();
+            return;
+        }
+        terminal.info(`Variables for environment '${env}':`);
+        terminal.blank();
+        for (const [key, value] of Object.entries(envConfig.variables)) {
+            const keyDisplay = terminal.colors.cyan(key);
+            const valueDisplay = terminal.colors.dim(value);
+            terminal.log(`  ${keyDisplay} = ${valueDisplay}`);
+        }
+        terminal.blank();
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Add or update a variable for an environment
+ */
+export async function executeVariablesAdd(keyValue, env) {
+    try {
+        // Parse KEY=VALUE format
+        const match = keyValue.match(/^([^=]+)=(.*)$/);
+        if (!match) {
+            throw new Error("Invalid format. Use: griffin variables add KEY=VALUE --env <env>");
+        }
+        const [, key, value] = match;
+        const trimmedKey = key.trim();
+        const trimmedValue = value.trim();
+        if (!trimmedKey) {
+            throw new Error("Variable key cannot be empty");
+        }
+        const state = await loadState();
+        const envConfig = await getEnvironment(env);
+        // Initialize variables object if it doesn't exist
+        if (!envConfig.variables) {
+            envConfig.variables = {};
+        }
+        // Add or update the variable
+        envConfig.variables[trimmedKey] = trimmedValue;
+        // Update the environment in state
+        state.environments[env] = envConfig;
+        await saveState(state);
+        terminal.success(`Variable '${trimmedKey}' set for environment '${env}'.`);
+        terminal.blank();
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Remove a variable from an environment
+ */
+export async function executeVariablesRemove(key, env) {
+    try {
+        const state = await loadState();
+        const envConfig = await getEnvironment(env);
+        if (!envConfig.variables || !(key in envConfig.variables)) {
+            throw new Error(`Variable '${key}' not found in environment '${env}'`);
+        }
+        delete envConfig.variables[key];
+        // Update the environment in state
+        state.environments[env] = envConfig;
+        await saveState(state);
+        terminal.success(`Variable '${key}' removed from environment '${env}'.`);
+        terminal.blank();
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}

package/dist/core/apply.test.js

@@ -9,6 +9,7 @@ function createMonitor(name) {
         environment: "test",
         version: "1.0",
         frequency: { every: 5, unit: "MINUTE" },
+        notifications: [],
         nodes: [],
         edges: [],
     };

package/dist/core/diff.test.js

@@ -11,6 +11,7 @@ function createMonitor(name, overrides) {
         frequency: { every: 5, unit: "MINUTE" },
         nodes: [],
         edges: [],
+        notifications: [],
         ...overrides,
     };
 }
@@ -24,6 +25,7 @@ function createResolvedMonitor(name, overrides) {
         frequency: { every: 5, unit: "MINUTE" },
         nodes: [],
         edges: [],
+        notifications: [],
         ...overrides,
     };
 }

package/dist/core/discovery.d.ts

@@ -1,3 +1,4 @@
+import "tsx";
 import type { MonitorDSL } from "@griffin-app/griffin-ts/types";
 export interface DiscoveredMonitor {
     monitor: MonitorDSL;

package/dist/core/discovery.js

@@ -1,3 +1,4 @@
+import "tsx";
 import { glob } from "glob";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -45,16 +46,25 @@ async function loadMonitorsFromFile(filePath) {
         const module = await import(fileUrl);
         // Check default export
         if (module.default) {
-            if (isMonitor(module.default)) {
+            // Handle potential double-wrapping from tsx/esModuleInterop
+            // When tsx transpiles TS files with esModuleInterop, it may wrap the default export
+            let defaultExport = module.default;
+            if (typeof defaultExport === "object" &&
+                defaultExport !== null &&
+                "default" in defaultExport &&
+                typeof defaultExport.default === "object") {
+                defaultExport = defaultExport.default;
+            }
+            if (isMonitor(defaultExport)) {
                 monitors.push({
-                    monitor: module.default,
+                    monitor: defaultExport,
                     filePath,
                     exportName: "default",
                 });
             }
             else {
-                const errors = Value.Errors(MonitorDSLSchema, module.default);
-                throw new Error(`Default export is not a valid TestMonitor. Got: ${JSON.stringify(errors, null, 2)}`);
+                const errors = Value.Errors(MonitorDSLSchema, defaultExport);
+                throw new Error(`Default export is not a valid TestMonitor. Got: ${JSON.stringify([...errors], null, 2)}`);
             }
         }
         if (monitors.length === 0) {

package/dist/core/monitor-diff.js

@@ -247,6 +247,21 @@ function compareTopLevel(local, remote) {
             newValue: localLocations,
         });
     }
+    // Compare notifications (normalize empty array to undefined)
+    const localNotifications = local.notifications && local.notifications.length > 0
+        ? local.notifications
+        : undefined;
+    const remoteNotifications = remote.notifications && remote.notifications.length > 0
+        ? remote.notifications
+        : undefined;
+    console.log("REMOTE NOTIFICATIONS", remoteNotifications);
+    if (!deepEqual(localNotifications, remoteNotifications)) {
+        changes.push({
+            field: "notifications",
+            oldValue: remoteNotifications,
+            newValue: localNotifications,
+        });
+    }
     return changes;
 }
 /**

package/dist/core/variables.d.ts

@@ -1,9 +1,9 @@
 /**
- * Load variables from variables.yaml for a specific environment.
+ * Load variables from state file for a specific environment.
  *
  * @param envName - The environment name to load variables for
  * @returns Record of variable key-value pairs
- * @throws Error if variables.yaml doesn't exist or environment not found
+ * @throws Error if environment not found or has no variables
  */
 export declare function loadVariables(envName: string): Promise<Record<string, string>>;
 /**

package/dist/core/variables.js

@@ -1,33 +1,15 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { parse } from "yaml";
+import { getEnvironment } from "./state.js";
 /**
- * Load variables from variables.yaml for a specific environment.
+ * Load variables from state file for a specific environment.
  *
  * @param envName - The environment name to load variables for
  * @returns Record of variable key-value pairs
- * @throws Error if variables.yaml doesn't exist or environment not found
+ * @throws Error if environment not found or has no variables
  */
 export async function loadVariables(envName) {
-    const yamlPath = path.join(process.cwd(), "variables.yaml");
-    try {
-        const content = await fs.readFile(yamlPath, "utf-8");
-        const config = parse(content);
-        if (!config.environments) {
-            throw new Error(`Invalid variables.yaml: missing "environments" key.\nExpected format:\nenvironments:\n  ${envName}:\n    key: value`);
-        }
-        if (!config.environments[envName]) {
-            const availableEnvs = Object.keys(config.environments);
-            throw new Error(`Environment "${envName}" not found in variables.yaml.\nAvailable environments: ${availableEnvs.join(", ")}`);
-        }
-        return config.environments[envName];
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new Error(`variables.yaml not found in ${process.cwd()}.\nCreate one with:\nenvironments:\n  ${envName}:\n    my-variable: my-value`);
-        }
-        throw error;
-    }
+    const envConfig = await getEnvironment(envName);
+    // Return empty object if no variables defined (allows monitors with no variable refs to work)
+    return envConfig.variables || {};
 }
 /**
  * Check if a value is a variable reference.

package/dist/providers/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hardcoded provider registry for integration connect.
+ * Defines categories, providers, auth methods, and required fields.
+ */
+export type AuthMethod = "oauth" | "credentials";
+export interface ProviderField {
+    key: string;
+    label: string;
+    secret?: boolean;
+    required?: boolean;
+    default?: string;
+}
+export interface ProviderDefinition {
+    category: string;
+    provider: string;
+    displayName: string;
+    authMethod: AuthMethod;
+    configFields?: ProviderField[];
+    credentialFields?: ProviderField[];
+}
+export declare function getCategories(): string[];
+export declare function getProviders(category: string): ProviderDefinition[];
+export declare function getProvider(category: string, provider: string): ProviderDefinition | null;
+export declare function getAllProvidersByCategory(): Map<string, ProviderDefinition[]>;

package/dist/providers/registry.js

@@ -0,0 +1,123 @@
+/**
+ * Hardcoded provider registry for integration connect.
+ * Defines categories, providers, auth methods, and required fields.
+ */
+const providers = [
+    // Notifications - OAuth
+    {
+        category: "notifications",
+        provider: "slack",
+        displayName: "Slack",
+        authMethod: "oauth",
+    },
+    {
+        category: "notifications",
+        provider: "pagerduty",
+        displayName: "PagerDuty",
+        authMethod: "oauth",
+    },
+    // Notifications - Credentials
+    {
+        category: "notifications",
+        provider: "webhook",
+        displayName: "Webhook",
+        authMethod: "credentials",
+        configFields: [{ key: "url", label: "Webhook URL", required: true }],
+    },
+    {
+        category: "notifications",
+        provider: "slack_webhook",
+        displayName: "Slack Webhook",
+        authMethod: "credentials",
+        credentialFields: [
+            {
+                key: "webhook_url",
+                label: "Webhook URL",
+                secret: true,
+                required: true,
+            },
+        ],
+    },
+    {
+        category: "notifications",
+        provider: "email",
+        displayName: "Email (SES)",
+        authMethod: "credentials",
+        configFields: [
+            { key: "fromAddress", label: "From Address", required: true },
+            { key: "sesRegion", label: "SES Region", required: true },
+            {
+                key: "toAddresses",
+                label: "To Addresses (comma-separated)",
+                required: true,
+            },
+        ],
+    },
+    // Secrets - Credentials
+    {
+        category: "secrets",
+        provider: "env",
+        displayName: "Environment Variables",
+        authMethod: "credentials",
+        configFields: [{ key: "prefix", label: "Env Prefix", required: false }],
+    },
+    {
+        category: "secrets",
+        provider: "aws",
+        displayName: "AWS Secrets Manager",
+        authMethod: "credentials",
+        configFields: [{ key: "region", label: "AWS Region", required: true }],
+        credentialFields: [
+            { key: "accessKeyId", label: "Access Key ID", secret: true },
+            { key: "secretAccessKey", label: "Secret Access Key", secret: true },
+        ],
+    },
+    {
+        category: "secrets",
+        provider: "vault",
+        displayName: "HashiCorp Vault",
+        authMethod: "credentials",
+        configFields: [{ key: "address", label: "Vault Address", required: true }],
+        credentialFields: [{ key: "token", label: "Vault Token", secret: true }],
+    },
+    // Metrics - Credentials
+    {
+        category: "metrics",
+        provider: "datadog",
+        displayName: "Datadog",
+        authMethod: "credentials",
+        configFields: [
+            {
+                key: "site",
+                label: "Datadog Site",
+                default: "datadoghq.com",
+            },
+        ],
+        credentialFields: [
+            {
+                key: "api_key",
+                label: "API Key",
+                secret: true,
+                required: true,
+            },
+        ],
+    },
+];
+const categories = ["notifications", "secrets", "metrics"];
+export function getCategories() {
+    return [...categories];
+}
+export function getProviders(category) {
+    return providers.filter((p) => p.category === category);
+}
+export function getProvider(category, provider) {
+    return (providers.find((p) => p.category === category && p.provider === provider) ??
+        null);
+}
+export function getAllProvidersByCategory() {
+    const map = new Map();
+    for (const cat of categories) {
+        map.set(cat, getProviders(cat));
+    }
+    return map;
+}

package/dist/schemas/state.d.ts

@@ -1,5 +1,7 @@
 import { Type, type Static } from "typebox";
-export declare const EnvironmentConfigSchema: Type.TObject<{}>;
+export declare const EnvironmentConfigSchema: Type.TObject<{
+    variables: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+}>;
 export type EnvironmentConfig = Static<typeof EnvironmentConfigSchema>;
 export declare const CloudConfigSchema: Type.TObject<{
     authUrl: Type.TString;
@@ -15,14 +17,22 @@ export declare const DiscoveryConfigSchema: Type.TObject<{
 }>;
 export type DiscoveryConfig = Static<typeof DiscoveryConfigSchema>;
 export declare const EnvironmentsConfigSchema: Type.TIntersect<[Type.TObject<{
-    default: Type.TObject<{}>;
-}>, Type.TRecord<"^.*$", Type.TObject<{}>>]>;
+    default: Type.TObject<{
+        variables: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    }>;
+}>, Type.TRecord<"^.*$", Type.TObject<{
+    variables: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+}>>]>;
 export declare const StateFileSchema: Type.TObject<{
     stateVersion: Type.TLiteral<1>;
     projectId: Type.TString;
     environments: Type.TIntersect<[Type.TObject<{
-        default: Type.TObject<{}>;
-    }>, Type.TRecord<"^.*$", Type.TObject<{}>>]>;
+        default: Type.TObject<{
+            variables: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+        }>;
+    }>, Type.TRecord<"^.*$", Type.TObject<{
+        variables: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    }>>]>;
     hub: Type.TObject<{
         baseUrl: Type.TString;
         clientId: Type.TOptional<Type.TString>;

package/dist/schemas/state.js

@@ -8,7 +8,9 @@ import { Type } from "typebox";
  */
 const authUrl = "https://www.getgriffinapp.com/api/auth";
 const hubBaseUrl = "https://griffin-hub.fly.dev";
-export const EnvironmentConfigSchema = Type.Object({});
+export const EnvironmentConfigSchema = Type.Object({
+    variables: Type.Optional(Type.Record(Type.String(), Type.String())),
+});
 export const CloudConfigSchema = Type.Object({
     authUrl: Type.String(),
 });

package/dist/utils/terminal.d.ts

@@ -63,6 +63,10 @@ export declare class Terminal {
      * Prompt user for text input
      */
     input(message: string, initial?: string): Promise<string>;
+    /**
+     * Prompt user for hidden input (password/secret)
+     */
+    password(message: string): Promise<string>;
     /**
      * Create a formatted table
      */

package/dist/utils/terminal.js

@@ -105,6 +105,17 @@ export class Terminal {
         });
         return response.value;
     }
+    /**
+     * Prompt user for hidden input (password/secret)
+     */
+    async password(message) {
+        const response = await enquirer.prompt({
+            type: "password",
+            name: "value",
+            message,
+        });
+        return response.value;
+    }
     /**
      * Create a formatted table
      */