@griffin-app/griffin-cli 1.0.8 → 1.0.9

package/dist/cli.js

@@ -16,7 +16,8 @@ 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";
 const program = new Command();
 program
     .name("griffin")
@@ -53,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 });
@@ -75,15 +76,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 +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")
@@ -115,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")
@@ -138,7 +138,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")
@@ -152,33 +152,6 @@ notifications
         json: options.json,
     });
 });
-notifications
-    .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")
-    .action(async (options) => {
-    await executeNotificationsAdd({
-        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,
-    });
-});
-notifications
-    .command("delete <id>")
-    .description("Delete a notification rule")
-    .action(async (id) => {
-    await executeNotificationsDelete({ id });
-});
 notifications
     .command("test")
     .description("Test a webhook configuration")
@@ -188,5 +161,56 @@ notifications
         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/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
  */

package/dist/commands/hub/notifications.js

@@ -3,7 +3,8 @@ import { createSdkWithCredentials } from "../../core/sdk.js";
 import { terminal } from "../../utils/terminal.js";
 import { withSDKErrorHandling } from "../../utils/sdk-error.js";
 /**
- * List notification rules
+ * List notification rules (read-only).
+ * Rules are defined in monitor DSL and synced via `griffin hub apply`.
  */
 export async function executeNotificationsList(options) {
     try {
@@ -28,26 +29,22 @@ export async function executeNotificationsList(options) {
         }
         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");
+        terminal.info("Notification Rules (synced from monitor DSL)");
         terminal.blank();
         const table = terminal.table({
-            head: ["ID", "Name", "Monitor", "Trigger", "Channels", "Enabled"],
+            head: ["ID", "Monitor", "Integration", "Trigger", "Enabled"],
         });
         for (const rule of rules) {
             const triggerDesc = formatTrigger(rule.trigger);
-            const channels = rule.channels
-                .map((ch) => (ch.type === "webhook" ? "webhook" : ch.type))
-                .join(", ");
-            const monitorName = rule.monitorId || "all monitors";
             const enabled = rule.enabled ? "✓" : "✗";
             table.push([
                 rule.id.substring(0, 8) + "...",
-                rule.name,
-                monitorName,
+                rule.monitorId ?? "-",
+                rule.integrationName ?? "-",
                 triggerDesc,
-                channels,
                 enabled,
             ]);
         }
@@ -58,76 +55,6 @@ export async function executeNotificationsList(options) {
         terminal.exit(1);
     }
 }
-/**
- * Add a notification rule
- */
-export async function executeNotificationsAdd(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);
-        }
-        // Parse trigger
-        const trigger = parseTrigger(options.trigger);
-        if (!trigger) {
-            terminal.error(`Invalid trigger: ${options.trigger}. Expected format: type[:value]`);
-            terminal.dim("Examples:");
-            terminal.dim("  run_failed");
-            terminal.dim("  consecutive_failures:3");
-            terminal.dim("  success_rate_below:80:60");
-            terminal.exit(1);
-        }
-        const sdk = await createSdkWithCredentials(state.hub.baseUrl);
-        const response = await withSDKErrorHandling(() => sdk.postNotificationsRules({
-            body: {
-                name: options.name,
-                monitorId: options.monitor,
-                environment: options.environment,
-                location: options.location,
-                trigger,
-                channels: [
-                    {
-                        type: "webhook",
-                        url: options.webhook,
-                    },
-                ],
-                cooldownMinutes: options.cooldown,
-            },
-        }), "Failed to create notification rule");
-        const rule = response?.data?.data;
-        if (rule) {
-            terminal.success(`Created notification rule: ${rule.id}`);
-        }
-    }
-    catch (error) {
-        terminal.error(error.message);
-        terminal.exit(1);
-    }
-}
-/**
- * Delete a notification rule
- */
-export async function executeNotificationsDelete(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);
-        await withSDKErrorHandling(() => sdk.deleteNotificationsRulesById({ path: { id: options.id } }), "Failed to delete notification rule");
-        terminal.success(`Deleted notification rule: ${options.id}`);
-    }
-    catch (error) {
-        terminal.error(error.message);
-        terminal.exit(1);
-    }
-}
 /**
  * Test a webhook
  */
@@ -165,45 +92,6 @@ export async function executeNotificationsTest(options) {
         terminal.exit(1);
     }
 }
-/**
- * Parse trigger string into trigger object
- */
-function parseTrigger(triggerStr) {
-    const parts = triggerStr.split(":");
-    const type = parts[0];
-    switch (type) {
-        case "run_failed":
-            return { type: "run_failed" };
-        case "run_recovered":
-            return { type: "run_recovered" };
-        case "consecutive_failures":
-            if (parts.length < 2)
-                return null;
-            return {
-                type: "consecutive_failures",
-                threshold: parseInt(parts[1], 10),
-            };
-        case "success_rate_below":
-            if (parts.length < 3)
-                return null;
-            return {
-                type: "success_rate_below",
-                threshold: parseFloat(parts[1]),
-                window_minutes: parseInt(parts[2], 10),
-            };
-        case "latency_above":
-            if (parts.length < 4)
-                return null;
-            return {
-                type: "latency_above",
-                threshold_ms: parseInt(parts[1], 10),
-                percentile: parts[2],
-                window_minutes: parseInt(parts[3], 10),
-            };
-        default:
-            return null;
-    }
-}
 /**
  * Format trigger for display
  */

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

package/dist/commands/hub/secrets.js

@@ -0,0 +1,185 @@
+import { createInterface } from "node:readline";
+import { loadState } from "../../core/state.js";
+import { terminal } from "../../utils/terminal.js";
+import { withSDKErrorHandling } from "../../utils/sdk-error.js";
+import { createSdkWithCredentials } from "../../core/sdk.js";
+const SECRET_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * List secrets (metadata only)
+ */
+export async function executeSecretsList(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 baseUrl = state.hub.baseUrl;
+        const sdk = await createSdkWithCredentials(baseUrl);
+        const env = options.environment ?? "default";
+        const response = await withSDKErrorHandling(async () => {
+            return sdk.getSecrets({
+                query: {
+                    environment: env,
+                },
+            });
+        }, "Failed to list secrets");
+        const secrets = response?.data?.data ?? [];
+        if (options.json) {
+            terminal.log(JSON.stringify(secrets, null, 2));
+            return;
+        }
+        if (secrets.length === 0) {
+            terminal.info(`No secrets found for environment "${env}".`);
+            return;
+        }
+        terminal.info(`Secrets (environment: ${env})`);
+        terminal.blank();
+        const table = terminal.table({
+            head: ["Name", "Created", "Updated"],
+        });
+        for (const s of secrets) {
+            table.push([s.name, s.createdAt ?? "-", s.updatedAt ?? "-"]);
+        }
+        terminal.log(table.toString());
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Set a secret (prompts for value if not provided)
+ */
+export async function executeSecretsSet(options) {
+    try {
+        if (!SECRET_NAME_REGEX.test(options.name)) {
+            terminal.error("Secret name must start with a letter or underscore and contain only letters, numbers, and underscores.");
+            terminal.exit(1);
+        }
+        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);
+        }
+        let value = options.value;
+        if (value === undefined) {
+            value = await promptSecret("Enter secret value:");
+            if (!value) {
+                terminal.error("Secret value cannot be empty.");
+                terminal.exit(1);
+            }
+        }
+        const baseUrl = state.hub.baseUrl;
+        const env = options.environment ?? "default";
+        const sdk = await createSdkWithCredentials(baseUrl);
+        const response = await withSDKErrorHandling(async () => {
+            return sdk.putSecretsByName({
+                path: { name: options.name },
+                body: { value, environment: env },
+            });
+        }, "Failed to set secret");
+        const result = response?.data;
+        terminal.success(`Secret "${result.data.name}" saved.`);
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+function promptSecret(promptText) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(promptText, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Get secret metadata only
+ */
+export async function executeSecretsGet(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 baseUrl = state.hub.baseUrl;
+        const env = options.environment ?? "default";
+        const sdk = await createSdkWithCredentials(baseUrl);
+        const response = await withSDKErrorHandling(async () => {
+            return sdk.getSecretsByName({
+                path: { name: options.name },
+                query: { environment: env },
+            });
+        }, "Failed to get secret");
+        const secret = response?.data?.data;
+        if (options.json) {
+            terminal.log(JSON.stringify(secret, null, 2));
+            return;
+        }
+        terminal.info(`Secret: ${secret.name}`);
+        terminal.dim(`Created: ${secret.createdAt ?? "-"}`);
+        terminal.dim(`Updated: ${secret.updatedAt ?? "-"}`);
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}
+/**
+ * Delete a secret (with confirmation unless --force)
+ */
+export async function executeSecretsDelete(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 baseUrl = state.hub.baseUrl;
+        const env = options.environment ?? "default";
+        const sdk = await createSdkWithCredentials(baseUrl);
+        if (!options.force) {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question(`Delete secret "${options.name}" (environment: ${env})? [y/N] `, (a) => {
+                    rl.close();
+                    resolve(a.trim().toLowerCase());
+                });
+            });
+            if (answer !== "y" && answer !== "yes") {
+                terminal.info("Aborted.");
+                return;
+            }
+        }
+        const response = await withSDKErrorHandling(async () => {
+            return sdk.deleteSecretsByName({
+                path: { name: options.name },
+                query: { environment: env },
+            });
+        }, "Failed to delete secret");
+        const result = response?.data;
+        terminal.success(`Secret deleted.`);
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}

package/dist/commands/init.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { initState, stateExists, getStateFilePath, addEnvironment, } 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";
@@ -34,11 +34,6 @@ export async function executeInit(options) {
     // Initialize state file
     await initState(projectId);
     terminal.success(`Created state file: ${terminal.colors.dim(getStateFilePath())}`);
-    // Create default environments
-    await addEnvironment("dev", {});
-    await addEnvironment("staging", {});
-    await addEnvironment("production", {});
-    terminal.success("Created default environments (dev, staging, production)");
     // Create variables.yaml if it doesn't exist
     const variablesPath = path.join(process.cwd(), VARIABLES_FILE);
     try {

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

@@ -1,4 +1,4 @@
 export interface RunLocalOptions {
-    env: string;
+    env?: string;
 }
 export declare function executeRunLocal(options: RunLocalOptions): Promise<void>;

package/dist/core/apply.test.js

@@ -116,7 +116,9 @@ describe("applyDiff", () => {
     it("should apply delete action", async () => {
         const remoteMonitor = createMonitor("old-monitor");
         const diff = {
-            actions: [{ type: "delete", monitor: null, remoteMonitor, reason: "removed" }],
+            actions: [
+                { type: "delete", monitor: null, remoteMonitor, reason: "removed" },
+            ],
             summary: { creates: 0, updates: 0, deletes: 1, noops: 0 },
         };
         const mockMonitorApi = {

package/dist/core/state.d.ts

@@ -34,10 +34,6 @@ export declare function addEnvironment(name: string, config: EnvironmentConfig):
  * Remove an environment
  */
 export declare function removeEnvironment(name: string): Promise<void>;
-/**
- * Set the default environment
- */
-export declare function setDefaultEnvironment(name: string): Promise<void>;
 /**
  * Get the current environment name (from flag, env var, or default)
  */

package/dist/core/state.js

@@ -84,10 +84,6 @@ export async function initState(projectId) {
 export async function addEnvironment(name, config) {
     const state = await loadState();
     state.environments[name] = config;
-    // Set as default if it's the first environment
-    if (Object.keys(state.environments).length === 1) {
-        state.defaultEnvironment = name;
-    }
     await saveState(state);
 }
 /**
@@ -95,26 +91,13 @@ export async function addEnvironment(name, config) {
  */
 export async function removeEnvironment(name) {
     const state = await loadState();
-    if (!(name in state.environments)) {
-        throw new Error(`Environment '${name}' does not exist`);
+    if (name === "default") {
+        throw new Error("Cannot remove default environment");
     }
-    delete state.environments[name];
-    // Update default if we removed it
-    if (state.defaultEnvironment === name) {
-        const remaining = Object.keys(state.environments);
-        state.defaultEnvironment = remaining.length > 0 ? remaining[0] : undefined;
-    }
-    await saveState(state);
-}
-/**
- * Set the default environment
- */
-export async function setDefaultEnvironment(name) {
-    const state = await loadState();
     if (!(name in state.environments)) {
         throw new Error(`Environment '${name}' does not exist`);
     }
-    state.defaultEnvironment = name;
+    delete state.environments[name];
     await saveState(state);
 }
 /**
@@ -123,14 +106,13 @@ export async function setDefaultEnvironment(name) {
 export async function resolveEnvironment(envFlag) {
     const state = await loadState();
     // Priority: CLI flag > ENV var > default > error
-    const envName = envFlag || process.env.GRIFFIN_ENV || state.defaultEnvironment;
-    if (!envName) {
-        throw new Error("No environment specified. Pass the environment name as the first argument (e.g. griffin hub apply production). You can also set GRIFFIN_ENV or a default with 'griffin env default <name>'.");
+    if (!envFlag) {
+        return "default";
     }
-    if (!(envName in state.environments)) {
-        throw new Error(`Environment '${envName}' not found. Available: ${Object.keys(state.environments).join(", ")}`);
+    if (!(envFlag in state.environments)) {
+        throw new Error(`Environment '${envFlag}' not found. Available: ${Object.keys(state.environments).join(", ")}`);
     }
-    return envName;
+    return envFlag;
 }
 /**
  * Get environment configuration

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export type { DiffAction, DiffResult } from "./core/diff.js";
 export type { ApplyResult, ApplyAction, ApplyError } from "./core/apply.js";
 export { createEmptyState, StateFileSchema, HubConfigSchema, } from "./schemas/state.js";
 export { createEmptyCredentials, CredentialsFileSchema, HubCredentialsSchema, } from "./schemas/credentials.js";
-export { getStateDirPath, getStateFilePath, stateExists, loadState, saveState, initState, addEnvironment, removeEnvironment, setDefaultEnvironment, resolveEnvironment, getEnvironment, } from "./core/state.js";
+export { getStateDirPath, getStateFilePath, stateExists, loadState, saveState, initState, addEnvironment, removeEnvironment, resolveEnvironment, getEnvironment, } from "./core/state.js";
 export { getCredentialsDirPath, getCredentialsFilePath, credentialsExist, loadCredentials, saveCredentials, saveHubCredentials, getHubCredentials, removeHubCredentials, } from "./core/credentials.js";
 export { discoverMonitors, formatDiscoveryErrors } from "./core/discovery.js";
 export { computeDiff, formatDiff, formatDiffJson } from "./core/diff.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 // Export core functions
 export { createEmptyState, StateFileSchema, HubConfigSchema, } from "./schemas/state.js";
 export { createEmptyCredentials, CredentialsFileSchema, HubCredentialsSchema, } from "./schemas/credentials.js";
-export { getStateDirPath, getStateFilePath, stateExists, loadState, saveState, initState, addEnvironment, removeEnvironment, setDefaultEnvironment, resolveEnvironment, getEnvironment, } from "./core/state.js";
+export { getStateDirPath, getStateFilePath, stateExists, loadState, saveState, initState, addEnvironment, removeEnvironment, resolveEnvironment, getEnvironment, } from "./core/state.js";
 export { getCredentialsDirPath, getCredentialsFilePath, credentialsExist, loadCredentials, saveCredentials, saveHubCredentials, getHubCredentials, removeHubCredentials, } from "./core/credentials.js";
 export { discoverMonitors, formatDiscoveryErrors } from "./core/discovery.js";
 export { computeDiff, formatDiff, formatDiffJson } from "./core/diff.js";

package/dist/schemas/state.d.ts

@@ -1,16 +1,12 @@
 import { Type, type Static } from "typebox";
-/**
- * State file schema for tracking project configuration
- * Stored in .griffin/state.json
- *
- * Note: The hub is now the source of truth for monitors.
- * This file only stores configuration (project, environments, runner connection).
- */
 export declare const EnvironmentConfigSchema: Type.TObject<{}>;
 export type EnvironmentConfig = Static<typeof EnvironmentConfigSchema>;
+export declare const CloudConfigSchema: Type.TObject<{
+    authUrl: Type.TString;
+}>;
 export declare const HubConfigSchema: Type.TObject<{
     baseUrl: Type.TString;
-    clientId: Type.TString;
+    clientId: Type.TOptional<Type.TString>;
 }>;
 export type HubConfig = Static<typeof HubConfigSchema>;
 export declare const DiscoveryConfigSchema: Type.TObject<{
@@ -18,15 +14,22 @@ export declare const DiscoveryConfigSchema: Type.TObject<{
     ignore: Type.TOptional<Type.TArray<Type.TString>>;
 }>;
 export type DiscoveryConfig = Static<typeof DiscoveryConfigSchema>;
+export declare const EnvironmentsConfigSchema: Type.TIntersect<[Type.TObject<{
+    default: Type.TObject<{}>;
+}>, Type.TRecord<"^.*$", Type.TObject<{}>>]>;
 export declare const StateFileSchema: Type.TObject<{
     stateVersion: Type.TLiteral<1>;
     projectId: Type.TString;
-    environments: Type.TRecord<"^.*$", Type.TObject<{}>>;
-    defaultEnvironment: Type.TOptional<Type.TString>;
-    hub: Type.TOptional<Type.TObject<{
+    environments: Type.TIntersect<[Type.TObject<{
+        default: Type.TObject<{}>;
+    }>, Type.TRecord<"^.*$", Type.TObject<{}>>]>;
+    hub: Type.TObject<{
         baseUrl: Type.TString;
-        clientId: Type.TString;
-    }>>;
+        clientId: Type.TOptional<Type.TString>;
+    }>;
+    cloud: Type.TObject<{
+        authUrl: Type.TString;
+    }>;
     discovery: Type.TOptional<Type.TObject<{
         pattern: Type.TOptional<Type.TString>;
         ignore: Type.TOptional<Type.TArray<Type.TString>>;
@@ -37,7 +40,3 @@ export type StateFile = Static<typeof StateFileSchema>;
  * Create an empty state file
  */
 export declare function createEmptyState(projectId: string): StateFile;
-/**
- * Create state file with a default local environment
- */
-export declare function createStateWithDefaultEnv(projectId: string): StateFile;

package/dist/schemas/state.js

@@ -6,24 +6,35 @@ import { Type } from "typebox";
  * Note: The hub is now the source of truth for monitors.
  * This file only stores configuration (project, environments, runner connection).
  */
+const authUrl = "https://www.getgriffinapp.com/api/auth";
+const hubBaseUrl = "https://griffin-hub.fly.dev";
 export const EnvironmentConfigSchema = Type.Object({});
+export const CloudConfigSchema = Type.Object({
+    authUrl: Type.String(),
+});
 export const HubConfigSchema = Type.Object({
     baseUrl: Type.String(),
-    clientId: Type.String(),
+    clientId: Type.Optional(Type.String()),
 });
 export const DiscoveryConfigSchema = Type.Object({
     pattern: Type.Optional(Type.String()),
     ignore: Type.Optional(Type.Array(Type.String())),
 });
+export const EnvironmentsConfigSchema = Type.Intersect([
+    Type.Object({
+        default: EnvironmentConfigSchema,
+    }),
+    Type.Record(Type.String(), EnvironmentConfigSchema),
+]);
 // State schema (hub is source of truth for monitors)
 export const StateFileSchema = Type.Object({
     stateVersion: Type.Literal(1),
     projectId: Type.String(),
     // Environment configuration
-    environments: Type.Record(Type.String(), EnvironmentConfigSchema),
-    defaultEnvironment: Type.Optional(Type.String()),
+    environments: EnvironmentsConfigSchema,
     // Hub connection (for remote execution)
-    hub: Type.Optional(HubConfigSchema),
+    hub: HubConfigSchema,
+    cloud: CloudConfigSchema,
     // Discovery settings
     discovery: Type.Optional(DiscoveryConfigSchema),
 });
@@ -31,22 +42,17 @@ export const StateFileSchema = Type.Object({
  * Create an empty state file
  */
 export function createEmptyState(projectId) {
-    return {
-        stateVersion: 1,
-        projectId,
-        environments: {},
-    };
-}
-/**
- * Create state file with a default local environment
- */
-export function createStateWithDefaultEnv(projectId) {
     return {
         stateVersion: 1,
         projectId,
         environments: {
-            local: {},
+            default: {},
+        },
+        hub: {
+            baseUrl: hubBaseUrl,
+        },
+        cloud: {
+            authUrl: authUrl,
         },
-        defaultEnvironment: "local",
     };
 }

package/dist/test-runner.js

@@ -25,7 +25,7 @@ export async function runTestFile(filePath, envName) {
     terminal.dim(`Project ID: ${projectId}`);
     const resolvedMonitor = resolveMonitor(rawMonitor, projectId, envName, variables);
     const secretRegistry = new SecretProviderRegistry();
-    secretRegistry.register(new EnvSecretProvider());
+    secretRegistry.setProvider(new EnvSecretProvider());
     try {
         const result = await executeMonitorV1({
             ...resolvedMonitor,

package/dist/utils/sdk-error.js

@@ -109,8 +109,6 @@ export async function withSDKErrorHandling(fn, context) {
         return await fn();
     }
     catch (error) {
-        console.error("error");
-        console.error(error);
         handleSDKError(error, context);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@griffin-app/griffin-cli",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "CLI tool for running and managing griffin API tests",
   "type": "module",
   "main": "dist/index.js",
@@ -23,9 +23,9 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@griffin-app/griffin-hub-sdk": "1.0.8",
-    "@griffin-app/griffin-plan-executor": "0.1.14",
-    "@griffin-app/griffin-ts": "0.1.14",
+    "@griffin-app/griffin-hub-sdk": "1.0.10",
+    "@griffin-app/griffin-plan-executor": "0.1.16",
+    "@griffin-app/griffin-ts": "0.1.15",
     "better-auth": "^1.4.17",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",