@griffin-app/griffin-cli 1.0.18 → 1.0.19

package/dist/commands/hub/apply.js

@@ -1,107 +1,66 @@
-import { loadState, resolveEnvironment } from "../../core/state.js";
-import { discoverMonitors, formatDiscoveryErrors, } from "../../core/discovery.js";
+import { resolveEnvironment } from "../../core/state.js";
 import { computeDiff, formatDiff } from "../../core/diff.js";
 import { applyDiff, formatApplyResult } from "../../core/apply.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 { loadVariables } from "../../core/variables.js";
-import { resolveMonitor } from "../../resolve.js";
+import { withCommandErrorHandler } from "../../utils/command-wrapper.js";
+import { discoverLocalMonitors, fetchRemoteMonitors, resolveLocalMonitors, } from "../../core/monitor-helpers.js";
 /**
  * Apply changes to the hub
  */
-export async function executeApply(options) {
-    try {
-        // Load state
-        const state = await loadState();
-        // Resolve environment
-        const envName = await resolveEnvironment(options.env);
-        // Check if runner is configured
-        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);
-        }
-        terminal.info(`Applying to ${terminal.colors.cyan(envName)} environment`);
-        terminal.blank();
-        // 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, errors } = await discoverMonitors(discoveryPattern, discoveryIgnore);
-        if (errors.length > 0) {
-            spinner.fail("Discovery failed");
-            terminal.error(formatDiscoveryErrors(errors));
-            terminal.exit(1);
-        }
-        spinner.succeed(`Found ${monitors.length} local monitor(s)`);
-        // Fetch remote monitors for this project + environment
-        const fetchSpinner = terminal
-            .spinner("Fetching remote monitors...")
-            .start();
-        const response = await withSDKErrorHandling(() => sdk.getMonitor({
-            query: {
-                projectId: state.projectId,
-                environment: envName,
-            },
-        }), "Failed to fetch remote monitors");
-        const remoteMonitors = response?.data?.data;
-        fetchSpinner.succeed(`Found ${remoteMonitors.length} remote monitor(s)`);
-        // Load variables and resolve local monitors before computing diff
-        const variables = await loadVariables(envName);
-        const resolvedMonitors = monitors.map((p) => resolveMonitor(p.monitor, state.projectId, envName, variables));
-        // Compute diff (include deletions if --prune)
-        const diff = computeDiff(resolvedMonitors, remoteMonitors, {
-            includeDeletions: options.prune || false,
-        });
-        // Show monitor
-        terminal.blank();
-        terminal.log(formatDiff(diff));
+export const executeApply = withCommandErrorHandler(async (options) => {
+    const { sdk, state } = await createSdkAndState();
+    // Resolve environment
+    const envName = await resolveEnvironment(options.env);
+    terminal.info(`Applying to ${terminal.colors.cyan(envName)} environment`);
+    terminal.blank();
+    // Discover local monitors
+    const { monitors } = await discoverLocalMonitors(state);
+    // Fetch remote monitors for this project + environment
+    const remoteMonitors = await fetchRemoteMonitors(sdk, state.projectId, envName);
+    // Load variables and resolve local monitors before computing diff
+    const resolvedMonitors = await resolveLocalMonitors(monitors, state.projectId, envName);
+    // Compute diff (include deletions if --prune)
+    const diff = computeDiff(resolvedMonitors, remoteMonitors, {
+        includeDeletions: options.prune || false,
+    });
+    // Show monitor
+    terminal.blank();
+    terminal.log(formatDiff(diff));
+    terminal.blank();
+    // Check if there are changes
+    if (diff.summary.creates + diff.summary.updates + diff.summary.deletes ===
+        0) {
+        terminal.success("No changes to apply.");
+        return;
+    }
+    // Show deletions warning if --prune
+    if (options.prune && diff.summary.deletes > 0) {
+        terminal.warn(`--prune will DELETE ${diff.summary.deletes} monitor(s) from the hub`);
         terminal.blank();
-        // Check if there are changes
-        if (diff.summary.creates + diff.summary.updates + diff.summary.deletes ===
-            0) {
-            terminal.success("No changes to apply.");
+    }
+    // Ask for confirmation unless auto-approved
+    if (!options.autoApprove && !options.dryRun) {
+        const confirmed = await terminal.confirm("Do you want to perform these actions?");
+        if (!confirmed) {
+            terminal.warn("Apply cancelled.");
             return;
         }
-        // Show deletions warning if --prune
-        if (options.prune && diff.summary.deletes > 0) {
-            terminal.warn(`--prune will DELETE ${diff.summary.deletes} monitor(s) from the hub`);
-            terminal.blank();
-        }
-        // Ask for confirmation unless auto-approved
-        if (!options.autoApprove && !options.dryRun) {
-            const confirmed = await terminal.confirm("Do you want to perform these actions?");
-            if (!confirmed) {
-                terminal.warn("Apply cancelled.");
-                return;
-            }
-        }
-        // Apply changes with environment injection
-        const applySpinner = terminal.spinner("Applying changes...").start();
-        const result = await applyDiff(diff, sdk, {
-            dryRun: options.dryRun,
-        });
-        if (result.success) {
-            applySpinner.succeed("Changes applied successfully");
-        }
-        else {
-            applySpinner.fail("Apply failed");
-        }
-        terminal.blank();
-        terminal.log(formatApplyResult(result));
-        if (!result.success) {
-            terminal.exit(1);
-        }
     }
-    catch (error) {
-        terminal.error(error.message);
+    // Apply changes with environment injection
+    const applySpinner = terminal.spinner("Applying changes...").start();
+    const result = await applyDiff(diff, sdk, {
+        dryRun: options.dryRun,
+    });
+    if (result.success) {
+        applySpinner.succeed("Changes applied successfully");
+    }
+    else {
+        applySpinner.fail("Apply failed");
+    }
+    terminal.blank();
+    terminal.log(formatApplyResult(result));
+    if (!result.success) {
         terminal.exit(1);
     }
-}
+});

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

@@ -1,6 +1,6 @@
 export interface ConnectOptions {
     url: string;
-    token?: string;
+    token: string;
 }
 /**
  * Configure hub connection settings

package/dist/commands/hub/connect.js

@@ -9,9 +9,7 @@ export async function executeConnect(options) {
     try {
         const state = await loadState();
         // Save token to user-level credentials file if provided
-        if (options.token) {
-            await saveHubCredentials(options.token);
-        }
+        await saveHubCredentials(options.token);
         // Update hub config in project state (without token)
         state.hub = {
             baseUrl: options.url,
@@ -20,9 +18,7 @@ export async function executeConnect(options) {
         await saveState(state);
         terminal.success("Hub connection configured");
         terminal.log(`  URL: ${terminal.colors.cyan(options.url)}`);
-        if (options.token) {
-            terminal.log(`  API Token: ${terminal.colors.dim("***")} (saved to user credentials)`);
-        }
+        terminal.log(`  API Token: ${terminal.colors.dim("***")} (saved to user credentials)`);
         terminal.blank();
     }
     catch (error) {

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

@@ -0,0 +1,10 @@
+export interface DestroyOptions {
+    autoApprove?: boolean;
+    dryRun?: boolean;
+    env: string;
+    monitor?: string;
+}
+/**
+ * Destroy monitors on the hub
+ */
+export declare function executeDestroy(options: DestroyOptions): Promise<void>;

package/dist/commands/hub/destroy.js

@@ -0,0 +1,141 @@
+import { loadState, resolveEnvironment } from "../../core/state.js";
+import { createSdkWithCredentials } from "../../core/sdk.js";
+import { terminal } from "../../utils/terminal.js";
+import { withSDKErrorHandling } from "../../utils/sdk-error.js";
+/**
+ * Destroy monitors on the hub
+ */
+export async function executeDestroy(options) {
+    try {
+        // Load state
+        const state = await loadState();
+        // Resolve environment
+        const envName = await resolveEnvironment(options.env);
+        // Check if hub is configured
+        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);
+        }
+        terminal.info(`Destroying monitors in ${terminal.colors.cyan(envName)} environment`);
+        terminal.blank();
+        // Create SDK client 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 response = await withSDKErrorHandling(() => sdk.getMonitor({
+            query: {
+                projectId: state.projectId,
+                environment: envName,
+            },
+        }), "Failed to fetch remote monitors");
+        const remoteMonitors = response?.data?.data;
+        fetchSpinner.succeed(`Found ${remoteMonitors.length} remote monitor(s)`);
+        if (remoteMonitors.length === 0) {
+            terminal.success("No monitors to destroy.");
+            return;
+        }
+        // Filter monitors if --monitor option is provided
+        let monitorsToDestroy = remoteMonitors;
+        if (options.monitor) {
+            const targetMonitor = remoteMonitors.find((m) => m.name === options.monitor || m.id === options.monitor);
+            if (!targetMonitor) {
+                terminal.error(`Monitor "${options.monitor}" not found in ${envName} environment`);
+                terminal.blank();
+                terminal.dim("Available monitors:");
+                remoteMonitors.forEach((m) => {
+                    terminal.dim(`  - ${m.name} (${m.id})`);
+                });
+                terminal.exit(1);
+                return; // TypeScript doesn't know exit(1) terminates
+            }
+            monitorsToDestroy = [targetMonitor];
+        }
+        // Show what will be destroyed
+        terminal.blank();
+        terminal.warn(`The following ${monitorsToDestroy.length} monitor(s) will be DESTROYED:`);
+        terminal.blank();
+        monitorsToDestroy.forEach((monitor) => {
+            terminal.log(`  ${terminal.colors.red("-")} ${monitor.name} (${monitor.id})`);
+        });
+        terminal.blank();
+        // Show dry run message if applicable
+        if (options.dryRun) {
+            terminal.info("[DRY RUN] No changes will be made");
+            terminal.blank();
+            terminal.log("Summary:");
+            terminal.log(`  Would destroy: ${monitorsToDestroy.length} monitor(s)`);
+            return;
+        }
+        // Ask for confirmation unless auto-approved
+        if (!options.autoApprove) {
+            terminal.blank();
+            terminal.warn(terminal.colors.bold("This action is DESTRUCTIVE and cannot be undone!"));
+            terminal.blank();
+            const confirmed = await terminal.confirm("Do you really want to destroy these monitors?");
+            if (!confirmed) {
+                terminal.warn("Destroy cancelled.");
+                return;
+            }
+            // Double confirmation for destroying all monitors
+            if (!options.monitor && monitorsToDestroy.length > 1) {
+                terminal.blank();
+                const doubleConfirmed = await terminal.confirm(`Type 'yes' to confirm destroying ALL ${monitorsToDestroy.length} monitors`);
+                if (!doubleConfirmed) {
+                    terminal.warn("Destroy cancelled.");
+                    return;
+                }
+            }
+        }
+        // Destroy monitors
+        terminal.blank();
+        const destroySpinner = terminal.spinner("Destroying monitors...").start();
+        let successCount = 0;
+        let failureCount = 0;
+        const errors = [];
+        for (const monitor of monitorsToDestroy) {
+            try {
+                await withSDKErrorHandling(() => sdk.deleteMonitorById({
+                    path: {
+                        id: monitor.id,
+                    },
+                }), `Failed to delete monitor "${monitor.name}"`);
+                successCount++;
+                terminal.success(`Destroyed: ${terminal.colors.cyan(monitor.name)}`);
+            }
+            catch (error) {
+                failureCount++;
+                const errorMessage = error.message;
+                errors.push({ monitor, error: errorMessage });
+                terminal.error(`Failed to destroy: ${monitor.name} - ${errorMessage}`);
+            }
+        }
+        if (failureCount === 0) {
+            destroySpinner.succeed("All monitors destroyed successfully");
+        }
+        else {
+            destroySpinner.fail("Some monitors failed to destroy");
+        }
+        // Show summary
+        terminal.blank();
+        terminal.log("Destroy complete:");
+        terminal.blank();
+        terminal.log(`  ${terminal.colors.green("✓")} Destroyed: ${successCount}`);
+        if (failureCount > 0) {
+            terminal.log(`  ${terminal.colors.red("✗")} Failed: ${failureCount}`);
+            terminal.blank();
+            terminal.error("Errors:");
+            errors.forEach(({ monitor, error }) => {
+                terminal.error(`  - ${monitor.name}: ${error}`);
+            });
+            terminal.exit(1);
+        }
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}

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

@@ -2,45 +2,45 @@ import type { IntegrationCategory, Provider } from "@griffin-app/griffin-ts/type
 export interface IntegrationsListOptions {
     category?: IntegrationCategory;
     provider?: Provider;
-    environment?: string;
+    environment: string;
     enabled?: boolean;
     json?: boolean;
 }
-export declare function executeIntegrationsList(options: IntegrationsListOptions): Promise<void>;
+export declare const executeIntegrationsList: (options: IntegrationsListOptions) => Promise<void>;
 export interface IntegrationsShowOptions {
     id: string;
     json?: boolean;
 }
-export declare function executeIntegrationsShow(options: IntegrationsShowOptions): Promise<void>;
+export declare const executeIntegrationsShow: (options: IntegrationsShowOptions) => Promise<void>;
 export interface IntegrationsAddOptions {
     category: IntegrationCategory;
     provider: Provider;
     name: string;
     config?: Record<string, string>;
-    environment?: string;
+    environment: string;
     enabled?: boolean;
     json?: boolean;
 }
-export declare function executeIntegrationsAdd(options: IntegrationsAddOptions): Promise<void>;
+export declare const executeIntegrationsAdd: (options: IntegrationsAddOptions) => Promise<void>;
 export interface IntegrationsUpdateOptions {
     id: string;
     name?: string;
     config?: Record<string, string>;
-    environment?: string;
+    environment: string;
     enabled?: boolean;
     json?: boolean;
 }
-export declare function executeIntegrationsUpdate(options: IntegrationsUpdateOptions): Promise<void>;
+export declare const executeIntegrationsUpdate: (options: IntegrationsUpdateOptions) => Promise<void>;
 export interface IntegrationsRemoveOptions {
     id: string;
     force?: boolean;
 }
-export declare function executeIntegrationsRemove(options: IntegrationsRemoveOptions): Promise<void>;
+export declare const executeIntegrationsRemove: (options: IntegrationsRemoveOptions) => Promise<void>;
 export interface IntegrationsConnectOptions {
     category: IntegrationCategory;
     provider: Provider;
     name?: string;
-    environment?: string;
+    environment: string;
     json?: boolean;
 }
 export declare function printConnectHelp(): void;