@griffin-app/griffin-cli 1.0.26 → 1.0.28

package/dist/commands/hub/runs.js

@@ -1,73 +1,75 @@
 import { createSdkFromState } from "../../core/sdk.js";
-import { terminal } from "../../utils/terminal.js";
-import { withSDKErrorHandling } from "../../utils/sdk-error.js";
-import { withCommandErrorHandler } from "../../utils/command-wrapper.js";
+import { handleSDKErrorWithOutput } from "../../utils/sdk-error.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
 /**
  * Show recent runs from the hub
  */
-export const executeRuns = withCommandErrorHandler(async (options) => {
-    // Load state
+export const executeRuns = createCommandHandler("runs", async (options, output) => {
     const sdk = await createSdkFromState();
-    // Get recent runs
     const limit = options.limit || 10;
-    const spinner = terminal.spinner("Fetching runs...").start();
-    const response = await withSDKErrorHandling(() => sdk.getRuns({
-        query: {
-            monitorId: options.monitor,
-            limit: limit,
-            offset: 0,
-        },
-    }), "Failed to fetch runs");
-    const runsData = response?.data;
+    const spinner = output.spinner("Fetching runs...").start();
+    let response;
+    try {
+        response = await sdk.getRuns({
+            query: {
+                monitorId: options.monitor,
+                limit,
+                offset: 0,
+            },
+        });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to fetch runs");
+    }
+    const runsData = response.data;
     if (!runsData || runsData.total === 0) {
         spinner.info("No runs found.");
+        output.setData({ runs: [], total: 0 });
         return;
     }
     spinner.succeed(`Found ${runsData.total} run(s)`);
-    terminal.blank();
-    // Create table
-    const table = terminal.table({
+    output.setData({
+        runs: runsData.data.map((run) => ({
+            id: run.id,
+            status: run.status,
+            success: run.success,
+            monitorName: run.monitor?.name ?? "-",
+            durationMs: run.duration_ms ?? null,
+            startedAt: run.startedAt,
+            errors: run.errors ?? [],
+        })),
+        total: runsData.total,
+    });
+    output.blank();
+    const table = output.table({
         head: ["Status", "Monitor", "Duration", "Started"],
     });
     for (const run of runsData.data) {
-        try {
-            const statusIcon = getStatusIcon(run.status, run.success);
-            const duration = run.duration_ms
-                ? `${(run.duration_ms / 1000).toFixed(2)}s`
-                : "-";
-            const started = new Date(run.startedAt).toLocaleString();
-            table.push([statusIcon, run.monitor.name || "-", duration, started]);
-        }
-        catch (error) {
-            terminal.error(`Error processing run ${run.id}: ${error.message}`);
-        }
-    }
-    try {
-        terminal.log(table.toString());
-    }
-    catch (error) {
-        terminal.error(`Error rendering table: ${error.message}`);
-        terminal.error(error.stack || "");
-        terminal.exit(1);
+        const statusIcon = getStatusIcon(run.status, run.success);
+        const duration = run.duration_ms
+            ? `${(run.duration_ms / 1000).toFixed(2)}s`
+            : "-";
+        const started = new Date(run.startedAt).toLocaleString();
+        table.push([statusIcon, run.monitor?.name ?? "-", duration, started]);
     }
-    // Show detailed errors if any
+    output.log(table.toString());
     const runsWithErrors = runsData.data.filter((run) => Array.isArray(run.errors) && run.errors.length > 0);
     if (runsWithErrors.length > 0) {
-        terminal.blank();
-        terminal.warn("Runs with errors:");
-        terminal.blank();
+        output.blank();
+        output.warn("Runs with errors:");
+        output.blank();
         for (const run of runsWithErrors) {
-            terminal.log(`${terminal.colors.red("✗")} ${terminal.colors.cyan(run.monitor.name)}`);
+            output.log(`${output.colors.red("✗")} ${output.colors.cyan(run.monitor?.name ?? "")}`);
             if (Array.isArray(run.errors) && run.errors.length > 0) {
                 const errorsToShow = run.errors.slice(0, 3);
                 for (const error of errorsToShow) {
-                    terminal.dim(`  - ${String(error)}`);
+                    output.dim(`  - ${String(error)}`);
                 }
                 if (run.errors.length > 3) {
-                    terminal.dim(`  ... and ${run.errors.length - 3} more`);
+                    output.dim(`  ... and ${run.errors.length - 3} more`);
                 }
             }
-            terminal.blank();
+            output.blank();
         }
     }
 });

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

@@ -6,6 +6,7 @@ export interface SecretsSetOptions {
     name: string;
     environment: string;
     value?: string;
+    json?: boolean;
 }
 export interface SecretsGetOptions {
     name: string;
@@ -16,22 +17,21 @@ export interface SecretsDeleteOptions {
     name: string;
     environment: string;
     force?: boolean;
+    json?: boolean;
 }
 /**
  * List secrets (metadata only).
- * Uses the resolved secrets integration for the organization and environment
- * (from hub integrations API or platform default / legacy config).
  */
 export declare const executeSecretsList: (options: SecretsListOptions) => Promise<void>;
 /**
- * Set a secret (prompts for value if not provided)
+ * Set a secret (prompts for value if not provided; in JSON mode --value is required).
  */
 export declare const executeSecretsSet: (options: SecretsSetOptions) => Promise<void>;
 /**
- * Get secret metadata only
+ * Get secret metadata only.
  */
 export declare const executeSecretsGet: (options: SecretsGetOptions) => Promise<void>;
 /**
- * Delete a secret (with confirmation unless --force)
+ * Delete a secret (with confirmation unless --force; in JSON mode --force is required to avoid prompt).
  */
 export declare const executeSecretsDelete: (options: SecretsDeleteOptions) => Promise<void>;

package/dist/commands/hub/secrets.js

@@ -1,127 +1,135 @@
 import { createInterface } from "node:readline";
 import { resolveEnvironment } from "../../core/state.js";
-import { terminal } from "../../utils/terminal.js";
-import { withSDKErrorHandling } from "../../utils/sdk-error.js";
 import { createSdkFromState } from "../../core/sdk.js";
-import { withCommandErrorHandler, outputJsonOrContinue, } from "../../utils/command-wrapper.js";
+import { handleSDKErrorWithOutput } from "../../utils/sdk-error.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
+import { OutputError } from "../../utils/output.js";
 const SECRET_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
  * List secrets (metadata only).
- * Uses the resolved secrets integration for the organization and environment
- * (from hub integrations API or platform default / legacy config).
  */
-export const executeSecretsList = withCommandErrorHandler(async (options) => {
+export const executeSecretsList = createCommandHandler("secrets list", async (options, output) => {
     const sdk = await createSdkFromState();
     const env = await resolveEnvironment(options.environment);
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.getSecrets({
-            query: {
-                environment: env,
-            },
+    let response;
+    try {
+        response = await sdk.getSecrets({
+            query: { environment: env },
         });
-    }, "Failed to list secrets");
-    const secrets = response?.data?.data ?? [];
-    if (outputJsonOrContinue(secrets, options.json))
-        return;
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to list secrets");
+    }
+    const secrets = response.data?.data ?? [];
+    output.setData({ secrets });
     if (secrets.length === 0) {
-        terminal.info(`No secrets found for environment "${env}".`);
+        output.info(`No secrets found for environment "${env}".`);
         return;
     }
-    terminal.info(`Secrets (environment: ${env})`);
-    terminal.blank();
-    const table = terminal.table({
+    output.info(`Secrets (environment: ${env})`);
+    output.blank();
+    const table = output.table({
         head: ["Name", "Created", "Updated"],
     });
     for (const s of secrets) {
         table.push([s.name, s.createdAt ?? "-", s.updatedAt ?? "-"]);
     }
-    terminal.log(table.toString());
+    output.log(table.toString());
 });
+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());
+        });
+    });
+}
 /**
- * Set a secret (prompts for value if not provided)
+ * Set a secret (prompts for value if not provided; in JSON mode --value is required).
  */
-export const executeSecretsSet = withCommandErrorHandler(async (options) => {
+export const executeSecretsSet = createCommandHandler("secrets set", async (options, output) => {
     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);
+        output.flushError("VALIDATION_ERROR", "Secret name must start with a letter or underscore and contain only letters, numbers, and underscores.");
     }
     let value = options.value;
     if (value === undefined) {
+        if (options.json) {
+            throw new OutputError("INTERACTIVE_REQUIRED", "Secret value required; use --value in non-interactive (JSON) mode", undefined, "Enter secret value");
+        }
         value = await promptSecret("Enter secret value:");
         if (!value) {
-            terminal.error("Secret value cannot be empty.");
-            terminal.exit(1);
+            output.flushError("VALIDATION_ERROR", "Secret value cannot be empty.");
         }
     }
     const sdk = await createSdkFromState();
     const env = await resolveEnvironment(options.environment);
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.putSecretsByName({
+    let response;
+    try {
+        response = await 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.`);
-});
-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());
-        });
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to set secret");
+    }
+    const result = response.data;
+    output.setData({
+        name: result.data?.name ?? options.name,
+        createdAt: result.data?.createdAt,
+        updatedAt: result.data?.updatedAt,
     });
-}
+    output.success(`Secret "${result.data?.name ?? options.name}" saved.`);
+});
 /**
- * Get secret metadata only
+ * Get secret metadata only.
  */
-export const executeSecretsGet = withCommandErrorHandler(async (options) => {
+export const executeSecretsGet = createCommandHandler("secrets get", async (options, output) => {
     const sdk = await createSdkFromState();
     const env = await resolveEnvironment(options.environment);
-    const response = await withSDKErrorHandling(async () => {
-        return sdk.getSecretsByName({
+    let response;
+    try {
+        response = await sdk.getSecretsByName({
             path: { name: options.name },
             query: { environment: env },
         });
-    }, "Failed to get secret");
-    const secret = response?.data?.data;
-    if (outputJsonOrContinue(secret, options.json))
-        return;
-    terminal.info(`Secret: ${secret.name}`);
-    terminal.dim(`Created: ${secret.createdAt ?? "-"}`);
-    terminal.dim(`Updated: ${secret.updatedAt ?? "-"}`);
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to get secret");
+    }
+    const secret = response.data?.data;
+    output.setData(secret);
+    output.info(`Secret: ${secret.name}`);
+    output.dim(`Created: ${secret.createdAt ?? "-"}`);
+    output.dim(`Updated: ${secret.updatedAt ?? "-"}`);
 });
 /**
- * Delete a secret (with confirmation unless --force)
+ * Delete a secret (with confirmation unless --force; in JSON mode --force is required to avoid prompt).
  */
-export const executeSecretsDelete = withCommandErrorHandler(async (options) => {
+export const executeSecretsDelete = createCommandHandler("secrets delete", async (options, output) => {
     const sdk = await createSdkFromState();
     const env = await resolveEnvironment(options.environment);
     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.");
+        const confirmed = await output.confirm(`Delete secret "${options.name}" (environment: ${env})?`, false);
+        if (!confirmed) {
+            output.setData({ deleted: false, name: options.name });
+            output.info("Aborted.");
             return;
         }
     }
-    await withSDKErrorHandling(async () => {
-        return sdk.deleteSecretsByName({
+    try {
+        await sdk.deleteSecretsByName({
             path: { name: options.name },
             query: { environment: env },
         });
-    }, "Failed to delete secret");
-    terminal.success(`Secret deleted.`);
+    }
+    catch (err) {
+        handleSDKErrorWithOutput(err, output, "Failed to delete secret");
+    }
+    output.setData({ deleted: true, name: options.name });
+    output.success(`Secret deleted.`);
 });

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

@@ -1,4 +1,7 @@
+export interface StatusOptions {
+    json?: boolean;
+}
 /**
  * Show hub connection status
  */
-export declare const executeStatus: () => Promise<void>;
+export declare const executeStatus: (options: StatusOptions) => Promise<void>;

package/dist/commands/hub/status.js

@@ -1,21 +1,27 @@
 import { loadState } from "../../core/state.js";
 import { getHubCredentials } from "../../core/credentials.js";
-import { terminal } from "../../utils/terminal.js";
-import { withCommandErrorHandler } from "../../utils/command-wrapper.js";
+import { createCommandHandler } from "../../utils/command-wrapper.js";
 /**
  * Show hub connection status
  */
-export const executeStatus = withCommandErrorHandler(async () => {
+export const executeStatus = createCommandHandler("status", async (options, output) => {
     const state = await loadState();
     const credentials = await getHubCredentials();
-    terminal.info("Hub connection:");
-    terminal.log(`  URL: ${terminal.colors.cyan(state.hub.baseUrl)}`);
+    output.setData({
+        hubUrl: state.hub.baseUrl,
+        token: credentials?.token
+            ? credentials.token.substring(0, 8) + "..."
+            : null,
+        updatedAt: credentials?.updatedAt ?? null,
+    });
+    output.info("Hub connection:");
+    output.log(`  URL: ${output.colors.cyan(state.hub.baseUrl)}`);
     if (credentials?.token) {
-        terminal.log(`  API Token: ${terminal.colors.dim(credentials.token.substring(0, 8) + "...")}`);
-        terminal.log(`  Updated: ${terminal.colors.dim(new Date(credentials.updatedAt).toLocaleString())}`);
+        output.log(`  API Token: ${output.colors.dim(credentials.token.substring(0, 8) + "...")}`);
+        output.log(`  Updated: ${output.colors.dim(new Date(credentials.updatedAt).toLocaleString())}`);
     }
     else {
-        terminal.log(`  API Token: ${terminal.colors.dim("(not set)")}`);
+        output.log(`  API Token: ${output.colors.dim("(not set)")}`);
     }
-    terminal.blank();
+    output.blank();
 });

package/dist/commands/init.d.ts

@@ -1,7 +1,8 @@
 export interface InitOptions {
     project?: string;
+    json?: boolean;
 }
 /**
  * Initialize griffin in the current directory
  */
-export declare function executeInit(options: InitOptions): Promise<void>;
+export declare const executeInit: (options: InitOptions) => Promise<void>;

package/dist/commands/init.js

@@ -1,38 +1,44 @@
 import { initState, stateExists, getStateFilePath } from "../core/state.js";
 import { detectProjectId } from "../core/project.js";
-import { terminal } from "../utils/terminal.js";
+import { createCommandHandler } from "../utils/command-wrapper.js";
 /**
  * Initialize griffin in the current directory
  */
-export async function executeInit(options) {
-    const spinner = terminal.spinner("Initializing griffin...").start();
-    // Check if already initialized
+export const executeInit = createCommandHandler("init", async (options, output) => {
+    const spinner = output.spinner("Initializing griffin...").start();
     if (await stateExists()) {
         spinner.fail("Already initialized");
-        terminal.dim(`State file exists: ${getStateFilePath()}`);
-        terminal.exit(1);
+        output.setData({
+            error: "ALREADY_INITIALIZED",
+            message: "State file already exists",
+            stateFilePath: getStateFilePath(),
+        });
+        output.dim(`State file exists: ${getStateFilePath()}`);
+        output.exit(1);
     }
-    // Determine project ID
     let projectId = options.project;
     if (!projectId) {
         projectId = await detectProjectId();
     }
-    spinner.succeed(`Project: ${terminal.colors.cyan(projectId)}`);
-    // Initialize state file (includes default environment)
+    spinner.succeed(`Project: ${output.colors.cyan(projectId)}`);
     await initState(projectId);
-    terminal.success(`Created state file: ${terminal.colors.dim(getStateFilePath())}`);
-    terminal.blank();
-    terminal.success("Initialization complete!");
-    terminal.blank();
-    terminal.info("Next steps:");
-    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:");
-    terminal.dim("     griffin test");
-    terminal.dim("  4. Connect to hub (optional):");
-    terminal.dim("     griffin auth connect --url <url> --token <token>");
-    terminal.dim("  5. Deploy to hub:");
-    terminal.dim("     griffin apply");
-    terminal.blank();
-}
+    output.setData({
+        projectId,
+        stateFilePath: getStateFilePath(),
+    });
+    output.success(`Created state file: ${output.colors.dim(getStateFilePath())}`);
+    output.blank();
+    output.success("Initialization complete!");
+    output.blank();
+    output.info("Next steps:");
+    output.dim("  1. Add variables for your environment (optional):");
+    output.dim("     griffin variables add API_KEY=your-key --env default");
+    output.dim("  2. Create test monitors (*.ts files in __griffin__/ directories)");
+    output.dim("  3. Run tests locally:");
+    output.dim("     griffin test");
+    output.dim("  4. Connect to hub (optional):");
+    output.dim("     griffin auth connect --url <url> --token <token>");
+    output.dim("  5. Deploy to hub:");
+    output.dim("     griffin apply");
+    output.blank();
+});

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

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

package/dist/commands/local/run.js

@@ -1,49 +1,57 @@
 import { findTestFiles } from "../../monitor-discovery.js";
 import { runTestFile } from "../../monitor-runner.js";
 import { resolveEnvironment } from "../../core/state.js";
-import { terminal } from "../../utils/terminal.js";
 import { basename } from "path";
-import { withCommandErrorHandler } from "../../utils/command-wrapper.js";
-export const executeRunLocal = withCommandErrorHandler(async (options) => {
-    // Resolve environment
+import { createCommandHandler } from "../../utils/command-wrapper.js";
+export const executeRunLocal = createCommandHandler("test", async (options, output) => {
     const envName = await resolveEnvironment(options.env);
-    terminal.info(`Running tests locally against ${terminal.colors.cyan(envName)} environment`);
-    terminal.dim(`Variables will be loaded from variables.yaml for environment: ${envName}`);
-    terminal.blank();
-    const spinner = terminal.spinner("Discovering test files...").start();
+    output.info(`Running tests locally against ${output.colors.cyan(envName)} environment`);
+    output.dim(`Variables will be loaded from variables.yaml for environment: ${envName}`);
+    output.blank();
+    const spinner = output.spinner("Discovering test files...").start();
     const testFiles = findTestFiles();
     if (testFiles.length === 0) {
         spinner.fail("No test files found");
-        terminal.dim("Looking for .ts files in __griffin__ directories.");
-        terminal.exit(1);
+        output.setData({
+            results: [],
+            passed: 0,
+            failed: 0,
+            error: "NO_TEST_FILES",
+        });
+        output.dim("Looking for .ts files in __griffin__ directories.");
+        output.exit(1);
     }
-    spinner.succeed(`Found ${terminal.colors.bold(testFiles.length.toString())} test file(s)`);
-    testFiles.forEach((file) => terminal.dim(`  - ${file}`));
-    terminal.blank();
+    spinner.succeed(`Found ${output.colors.bold(testFiles.length.toString())} test file(s)`);
+    testFiles.forEach((file) => output.dim(`  - ${file}`));
+    output.blank();
     const results = await Promise.all(testFiles.map(async (file) => {
         const fileName = basename(file);
-        const testSpinner = terminal
-            .spinner(`Running ${terminal.colors.cyan(fileName)}`)
+        const testSpinner = output
+            .spinner(`Running ${output.colors.cyan(fileName)}`)
             .start();
         const result = await runTest(file, envName);
         if (result.success) {
-            testSpinner.succeed(`${terminal.colors.cyan(fileName)} passed`);
+            testSpinner.succeed(`${output.colors.cyan(fileName)} passed`);
         }
         else {
-            testSpinner.fail(`${terminal.colors.cyan(fileName)} failed`);
+            testSpinner.fail(`${output.colors.cyan(fileName)} failed`);
         }
-        return result;
+        return { file: fileName, success: result.success };
     }));
-    // Print summary
-    const successful = results.filter((r) => r.success).length;
-    const failed = results.length - successful;
-    terminal.blank();
+    const passed = results.filter((r) => r.success).length;
+    const failed = results.length - passed;
+    output.setData({
+        results,
+        passed,
+        failed,
+    });
+    output.blank();
     if (failed === 0) {
-        terminal.success(`All tests passed (${terminal.colors.bold(successful.toString())} / ${results.length})`);
+        output.success(`All tests passed (${output.colors.bold(passed.toString())} / ${results.length})`);
     }
     else {
-        terminal.error(`${terminal.colors.bold(failed.toString())} test(s) failed, ${terminal.colors.bold(successful.toString())} passed`);
-        terminal.exit(1);
+        output.error(`${output.colors.bold(failed.toString())} test(s) failed, ${output.colors.bold(passed.toString())} passed`);
+        output.exit(1);
     }
 });
 async function runTest(file, envName) {
@@ -52,7 +60,7 @@ async function runTest(file, envName) {
         return { success: result.success };
     }
     catch (error) {
-        terminal.error(error.message || String(error));
+        console.error(error.message || String(error));
         return { success: false };
     }
 }

package/dist/commands/validate.d.ts

@@ -1,4 +1,7 @@
+export interface ValidateOptions {
+    json?: boolean;
+}
 /**
  * Validate test monitor files without syncing
  */
-export declare const executeValidate: () => Promise<void>;
+export declare const executeValidate: (options: ValidateOptions) => Promise<void>;