@griffin-app/griffin-cli 1.0.8 → 1.0.10

package/dist/cli.js

@@ -16,7 +16,9 @@ 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";
+import { executeNotificationsList, executeNotificationsTest, } from "./commands/hub/notifications.js";
+import { executeSecretsList, executeSecretsSet, executeSecretsGet, executeSecretsDelete, } from "./commands/hub/secrets.js";
+import { executeIntegrationsList, executeIntegrationsShow, executeIntegrationsAdd, executeIntegrationsUpdate, executeIntegrationsRemove, } from "./commands/hub/integrations.js";
 const program = new Command();
 program
     .name("griffin")
@@ -53,7 +55,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 });
@@ -75,15 +77,14 @@ hub
     await executeStatus();
 });
 hub
-    .command("metrics")
+    .command("metrics [env]")
     .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) => {
+    .action(async (env, options) => {
     await executeMetrics({
         period: options.period,
-        environment: options.environment,
+        environment: env,
         json: options.json,
     });
 });
@@ -99,14 +100,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")
@@ -115,7 +116,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")
@@ -138,7 +139,7 @@ hub
 // Notifications command group
 const notifications = hub
     .command("notifications")
-    .description("Manage notification rules");
+    .description("View notification rules (rules are defined in monitor DSL and synced via griffin hub apply)");
 notifications
     .command("list")
     .description("List notification rules")
@@ -153,39 +154,133 @@ notifications
     });
 });
 notifications
+    .command("test")
+    .description("Test a webhook configuration")
+    .requiredOption("--webhook <url>", "Webhook URL to test")
+    .action(async (options) => {
+    await executeNotificationsTest({
+        webhook: options.webhook,
+    });
+});
+// Integrations command group
+const integrations = hub
+    .command("integrations")
+    .description("Manage integrations (notifications, secrets, metrics)");
+integrations
+    .command("list")
+    .description("List integrations")
+    .option("--category <cat>", "Filter by category: secrets, notifications, metrics")
+    .option("--provider-type <type>", "Filter by provider type")
+    .option("--environment <env>", "Filter by environment")
+    .option("--enabled", "Filter by enabled status")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    await executeIntegrationsList({
+        category: options.category,
+        providerType: options.providerType,
+        environment: options.environment,
+        enabled: options.enabled ? true : undefined,
+        json: options.json,
+    });
+});
+integrations
+    .command("show <id>")
+    .description("Show integration details")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    await executeIntegrationsShow({ id, json: options.json });
+});
+integrations
     .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")
+    .description("Add an integration (no credentials in Phase 1; use API for credentials)")
+    .requiredOption("--category <cat>", "Category: secrets, notifications, metrics")
+    .requiredOption("--provider-type <type>", "Provider type (e.g. slack_webhook, datadog)")
+    .requiredOption("--name <name>", "Display name")
+    .option("--environment <env>", "Environment scope (omit for org-wide)")
+    .option("--enabled/--no-enabled", "Enabled", true)
+    .option("--json", "Output as JSON")
     .action(async (options) => {
-    await executeNotificationsAdd({
+    await executeIntegrationsAdd({
+        category: options.category,
+        providerType: options.providerType,
         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,
+        enabled: options.enabled,
+        json: options.json,
     });
 });
-notifications
-    .command("delete <id>")
-    .description("Delete a notification rule")
+integrations
+    .command("update <id>")
+    .description("Update an integration")
+    .option("--name <name>", "Display name")
+    .option("--environment <env>", "Environment scope")
+    .option("--enabled/--no-enabled", "Enabled")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+    await executeIntegrationsUpdate({
+        id,
+        name: options.name,
+        environment: options.environment,
+        enabled: options.enabled,
+        json: options.json,
+    });
+});
+integrations
+    .command("remove <id>")
+    .description("Remove an integration")
+    .option("--force", "Skip confirmation")
     .action(async (id) => {
-    await executeNotificationsDelete({ id });
+    await executeIntegrationsRemove({ id });
 });
-notifications
-    .command("test")
-    .description("Test a webhook configuration")
-    .requiredOption("--webhook <url>", "Webhook URL to test")
+// 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 executeNotificationsTest({
-        webhook: options.webhook,
+    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

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/integrations.d.ts

@@ -0,0 +1,37 @@
+export interface IntegrationsListOptions {
+    category?: string;
+    providerType?: string;
+    environment?: string;
+    enabled?: boolean;
+    json?: boolean;
+}
+export declare function executeIntegrationsList(options: IntegrationsListOptions): Promise<void>;
+export interface IntegrationsShowOptions {
+    id: string;
+    json?: boolean;
+}
+export declare function executeIntegrationsShow(options: IntegrationsShowOptions): Promise<void>;
+export interface IntegrationsAddOptions {
+    category: string;
+    providerType: string;
+    name: string;
+    config?: Record<string, string>;
+    environment?: string;
+    enabled?: boolean;
+    json?: boolean;
+}
+export declare function executeIntegrationsAdd(options: IntegrationsAddOptions): Promise<void>;
+export interface IntegrationsUpdateOptions {
+    id: string;
+    name?: string;
+    config?: Record<string, string>;
+    environment?: string;
+    enabled?: boolean;
+    json?: boolean;
+}
+export declare function executeIntegrationsUpdate(options: IntegrationsUpdateOptions): Promise<void>;
+export interface IntegrationsRemoveOptions {
+    id: string;
+    force?: boolean;
+}
+export declare function executeIntegrationsRemove(options: IntegrationsRemoveOptions): Promise<void>;

package/dist/commands/hub/integrations.js

@@ -0,0 +1,167 @@
+import { loadState } from "../../core/state.js";
+import { getHubCredentials } from "../../core/credentials.js";
+import { terminal } from "../../utils/terminal.js";
+async function hubFetch(path, options = {}) {
+    const state = await loadState();
+    if (!state.hub?.baseUrl) {
+        terminal.error("Hub connection not configured.");
+        terminal.dim("Connect with: griffin hub connect --url <url> --token <token>");
+        process.exit(1);
+    }
+    const credentials = await getHubCredentials();
+    const url = `${state.hub.baseUrl.replace(/\/$/, "")}${path}`;
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (credentials?.token) {
+        headers["Authorization"] = `Bearer ${credentials.token}`;
+    }
+    const res = await fetch(url, {
+        method: options.method ?? "GET",
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    const text = await res.text();
+    let json;
+    try {
+        json = text ? JSON.parse(text) : {};
+    }
+    catch {
+        return { error: res.ok ? "Invalid response" : text || res.statusText };
+    }
+    if (!res.ok) {
+        return { error: json.error ?? res.statusText };
+    }
+    return json;
+}
+export async function executeIntegrationsList(options) {
+    const params = new URLSearchParams();
+    if (options.category)
+        params.set("category", options.category);
+    if (options.providerType)
+        params.set("providerType", options.providerType);
+    if (options.environment != null)
+        params.set("environment", options.environment);
+    if (options.enabled != null)
+        params.set("enabled", String(options.enabled));
+    const qs = params.toString();
+    const path = `/integrations${qs ? `?${qs}` : ""}`;
+    const result = await hubFetch(path);
+    if (result.error) {
+        terminal.error(result.error);
+        process.exit(1);
+    }
+    const list = result.data ?? [];
+    if (options.json) {
+        terminal.log(JSON.stringify(list, null, 2));
+        return;
+    }
+    if (list.length === 0) {
+        terminal.info("No integrations found.");
+        return;
+    }
+    terminal.info("Integrations");
+    terminal.blank();
+    const table = terminal.table({
+        head: ["ID", "Category", "Provider", "Name", "Environment", "Enabled"],
+    });
+    for (const i of list) {
+        table.push([
+            i.id.substring(0, 12) + (i.id.length > 12 ? "…" : ""),
+            i.category,
+            i.providerType,
+            i.name,
+            i.environment ?? "(all)",
+            i.enabled ? "✓" : "✗",
+        ]);
+    }
+    terminal.log(table.toString());
+}
+export async function executeIntegrationsShow(options) {
+    const result = await hubFetch(`/integrations/${encodeURIComponent(options.id)}`);
+    if (result.error) {
+        terminal.error(result.error);
+        process.exit(1);
+    }
+    const integration = result.data;
+    if (!integration) {
+        terminal.error("Integration not found.");
+        process.exit(1);
+    }
+    if (options.json) {
+        terminal.log(JSON.stringify(integration, null, 2));
+        return;
+    }
+    terminal.info(integration.name);
+    terminal.dim(`ID: ${integration.id}`);
+    terminal.log(`Category: ${integration.category}`);
+    terminal.log(`Provider: ${integration.providerType}`);
+    terminal.log(`Environment: ${integration.environment ?? "(all)"}`);
+    terminal.log(`Enabled: ${integration.enabled ? "Yes" : "No"}`);
+    terminal.log(`Has credentials: ${integration.hasCredentials ? "Yes" : "No"}`);
+    if (Object.keys(integration.config).length > 0) {
+        terminal.log("Config: " + JSON.stringify(integration.config));
+    }
+}
+export async function executeIntegrationsAdd(options) {
+    const body = {
+        category: options.category,
+        providerType: options.providerType,
+        name: options.name,
+        config: options.config ?? {},
+        environment: options.environment ?? null,
+        enabled: options.enabled ?? true,
+    };
+    const result = await hubFetch("/integrations", {
+        method: "POST",
+        body,
+    });
+    if (result.error) {
+        terminal.error(result.error);
+        process.exit(1);
+    }
+    const integration = result.data;
+    if (!integration) {
+        terminal.error("Create failed.");
+        process.exit(1);
+    }
+    if (options.json) {
+        terminal.log(JSON.stringify(integration, null, 2));
+        return;
+    }
+    terminal.info(`Created integration ${integration.name} (${integration.id})`);
+}
+export async function executeIntegrationsUpdate(options) {
+    const body = {};
+    if (options.name !== undefined)
+        body.name = options.name;
+    if (options.config !== undefined)
+        body.config = options.config;
+    if (options.environment !== undefined)
+        body.environment = options.environment;
+    if (options.enabled !== undefined)
+        body.enabled = options.enabled;
+    const result = await hubFetch(`/integrations/${encodeURIComponent(options.id)}`, { method: "PATCH", body });
+    if (result.error) {
+        terminal.error(result.error);
+        process.exit(1);
+    }
+    const integration = result.data;
+    if (!integration) {
+        terminal.error("Update failed.");
+        process.exit(1);
+    }
+    if (options.json) {
+        terminal.log(JSON.stringify(integration, null, 2));
+        return;
+    }
+    terminal.info(`Updated integration ${integration.name}`);
+}
+export async function executeIntegrationsRemove(options) {
+    const result = await hubFetch(`/integrations/${encodeURIComponent(options.id)}`, { method: "DELETE" });
+    if (result.error) {
+        terminal.error(result.error);
+        process.exit(1);
+    }
+    terminal.info("Integration removed.");
+}

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/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

@@ -3,33 +3,14 @@ export interface NotificationsListOptions {
     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
+ * 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>;
-/**
- * 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
  */