@griffin-app/griffin-cli 1.0.32 → 1.0.34

package/dist/cli.js

@@ -38,8 +38,12 @@ program
 program
     .command("validate")
     .description("Check monitor files for errors")
-    .action(async () => {
-    await executeValidate({ json: program.opts().json });
+    .option("--monitor <name>", "Validate only this monitor by name")
+    .action(async (options) => {
+    await executeValidate({
+        monitor: options.monitor,
+        json: program.opts().json,
+    });
 });
 program
     .command("status")
@@ -51,18 +55,25 @@ program
     .command("test")
     .description("Run monitors locally")
     .option("--env <name>", "Environment name", "default")
+    .option("--monitor <name>", "Run only this monitor by name")
     .action(async (options) => {
-    await executeRunLocal({ env: options.env, json: program.opts().json });
+    await executeRunLocal({
+        env: options.env,
+        monitor: options.monitor,
+        json: program.opts().json,
+    });
 });
 program
     .command("plan")
     .description("Preview pending monitor changes")
     .option("--env <name>", "Environment name", "default")
+    .option("--monitor <name>", "Plan only this monitor by name")
     .option("--json", "Output in JSON format")
     .action(async (options) => {
     await executePlan({
         ...options,
         env: options.env,
+        monitor: options.monitor,
         json: program.opts().json ?? options.json,
     });
 });
@@ -70,6 +81,7 @@ program
     .command("apply")
     .description("Push monitor changes to the platform")
     .option("--env <name>", "Environment name", "default")
+    .option("--monitor <name>", "Apply only this monitor by name")
     .option("--auto-approve", "Skip confirmation prompt")
     .option("--dry-run", "Show what would be done without making changes")
     .option("--prune", "Delete monitors on hub that don't exist locally")
@@ -77,6 +89,7 @@ program
     await executeApply({
         ...options,
         env: options.env,
+        monitor: options.monitor,
         json: program.opts().json,
     });
 });

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

@@ -2,6 +2,7 @@ export interface ApplyOptions {
     autoApprove?: boolean;
     dryRun?: boolean;
     env: string;
+    monitor?: string;
     prune?: boolean;
     json?: boolean;
 }

package/dist/commands/hub/apply.js

@@ -3,7 +3,8 @@ import { computeDiff, formatDiff } from "../../core/diff.js";
 import { applyDiff, formatApplyResult } from "../../core/apply.js";
 import { createSdkAndState } from "../../core/sdk.js";
 import { createCommandHandler } from "../../utils/command-wrapper.js";
-import { discoverLocalMonitors, fetchRemoteMonitors, resolveLocalMonitors, } from "../../core/monitor-helpers.js";
+import { discoverLocalMonitors, fetchRemoteMonitors, resolveLocalMonitors, monitorNotFoundData, } from "../../core/monitor-helpers.js";
+import { OutputError } from "../../utils/output.js";
 /**
  * Apply changes to the hub
  */
@@ -15,9 +16,29 @@ export const executeApply = createCommandHandler("apply", async (options, output
     const { monitors } = await discoverLocalMonitors(state);
     const remoteMonitors = await fetchRemoteMonitors(sdk, state.projectId, envName);
     const resolvedMonitors = await resolveLocalMonitors(monitors, state.projectId, envName);
-    const diff = computeDiff(resolvedMonitors, remoteMonitors, {
+    let diff = computeDiff(resolvedMonitors, remoteMonitors, {
         includeDeletions: options.prune || false,
     });
+    if (options.monitor) {
+        const name = options.monitor;
+        const filtered = diff.actions.filter((a) => a.monitor?.name === name || a.remoteMonitor?.name === name);
+        if (filtered.length === 0) {
+            const inPlan = diff.actions.map((a) => a.monitor?.name ?? a.remoteMonitor?.name ?? "").filter(Boolean);
+            const data = monitorNotFoundData(name, [...new Set(inPlan)]);
+            throw new OutputError("NOT_FOUND", `Monitor "${name}" not found in plan`, { available: data.available }, data.available.length
+                ? "Available: " + data.available.join(", ")
+                : undefined);
+        }
+        diff = {
+            actions: filtered,
+            summary: {
+                creates: filtered.filter((a) => a.type === "create").length,
+                updates: filtered.filter((a) => a.type === "update").length,
+                deletes: filtered.filter((a) => a.type === "delete").length,
+                noops: filtered.filter((a) => a.type === "noop").length,
+            },
+        };
+    }
     output.blank();
     output.log(formatDiff(diff));
     output.blank();

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

@@ -1,6 +1,7 @@
 export interface PlanOptions {
     json?: boolean;
     env: string;
+    monitor?: string;
 }
 /**
  * Show what changes would be applied

package/dist/commands/hub/monitor.js

@@ -2,7 +2,8 @@ import { resolveEnvironment } from "../../core/state.js";
 import { createSdkAndState } from "../../core/sdk.js";
 import { computeDiff, formatDiff, formatDiffJson } from "../../core/diff.js";
 import { createCommandHandler } from "../../utils/command-wrapper.js";
-import { discoverLocalMonitors, fetchRemoteMonitors, resolveLocalMonitors, } from "../../core/monitor-helpers.js";
+import { discoverLocalMonitors, fetchRemoteMonitors, resolveLocalMonitors, monitorNotFoundData, } from "../../core/monitor-helpers.js";
+import { OutputError } from "../../utils/output.js";
 /**
  * Show what changes would be applied
  */
@@ -11,8 +12,23 @@ export const executePlan = createCommandHandler("plan", async (options, output)
     const envName = await resolveEnvironment(options.env);
     const { monitors } = await discoverLocalMonitors(state);
     const remoteMonitors = await fetchRemoteMonitors(sdk, state.projectId, envName);
-    const resolvedMonitors = await resolveLocalMonitors(monitors, state.projectId, envName);
-    const diff = computeDiff(resolvedMonitors, remoteMonitors, {
+    let resolvedMonitors = await resolveLocalMonitors(monitors, state.projectId, envName);
+    let remoteFiltered = remoteMonitors;
+    if (options.monitor) {
+        const name = options.monitor;
+        resolvedMonitors = resolvedMonitors.filter((m) => m.name === name);
+        remoteFiltered = remoteMonitors.filter((m) => m.name === name);
+        if (resolvedMonitors.length === 0 && remoteFiltered.length === 0) {
+            const localNames = monitors.map((m) => m.monitor.name);
+            const remoteNames = remoteMonitors.map((m) => m.name);
+            const available = [...new Set([...localNames, ...remoteNames])];
+            const data = monitorNotFoundData(name, available);
+            throw new OutputError("NOT_FOUND", `Monitor "${name}" not found locally or on hub`, { available: data.available }, data.available.length
+                ? "Available: " + data.available.join(", ")
+                : undefined);
+        }
+    }
+    const diff = computeDiff(resolvedMonitors, remoteFiltered, {
         includeDeletions: false,
     });
     output.setData({

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

@@ -1,5 +1,14 @@
+import type { ExecutionResult } from "@griffin-app/griffin-executor";
+export type TestResultPhase = "load" | "validate" | "resolve" | "execute" | "assert";
+export interface TestResult {
+    success: boolean;
+    error?: string;
+    phase?: TestResultPhase;
+    executionResult?: ExecutionResult;
+}
 export interface RunLocalOptions {
     env: string;
+    monitor?: string;
     json?: boolean;
 }
 export declare const executeRunLocal: (options: RunLocalOptions) => Promise<void>;

package/dist/commands/local/run.js

@@ -1,15 +1,53 @@
 import { findTestFiles } from "../../monitor-discovery.js";
-import { runTestFile } from "../../monitor-runner.js";
+import { runTestFile, MonitorRunnerError } from "../../monitor-runner.js";
+import { loadState } from "../../core/state.js";
 import { resolveEnvironment } from "../../core/state.js";
+import { formatDiscoveryErrors } from "../../core/discovery.js";
+import { discoverLocalMonitorsSilent, filterDiscoveredByName, monitorNotFoundData, } from "../../core/monitor-helpers.js";
+import { OutputError } from "../../utils/output.js";
 import { basename } from "path";
 import { createCommandHandler } from "../../utils/command-wrapper.js";
+function inferPhaseFromMessage(message) {
+    if (message.startsWith("Invalid monitor") || message.includes("valid TestMonitor"))
+        return "validate";
+    if (message.startsWith("Failed to load"))
+        return "load";
+    if (message.startsWith("Error executing monitor"))
+        return "execute";
+    return "execute";
+}
 export const executeRunLocal = createCommandHandler("test", async (options, output) => {
     const envName = await resolveEnvironment(options.env);
     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();
+    let testFiles;
+    if (options.monitor) {
+        const state = await loadState();
+        const result = await discoverLocalMonitorsSilent(state);
+        if (result.errors.length > 0) {
+            spinner.fail("Discovery failed");
+            output.setData({
+                error: "DISCOVERY_FAILED",
+                message: formatDiscoveryErrors(result.errors),
+            });
+            output.error(formatDiscoveryErrors(result.errors));
+            output.exit(1);
+        }
+        const filtered = filterDiscoveredByName(result.monitors, options.monitor);
+        if (filtered.length === 0) {
+            spinner.fail(`Monitor "${options.monitor}" not found`);
+            const data = monitorNotFoundData(options.monitor, result.monitors.map((m) => m.monitor.name));
+            throw new OutputError("NOT_FOUND", data.message, { available: data.available }, data.available.length
+                ? "Available: " + data.available.join(", ")
+                : undefined);
+        }
+        testFiles = [...new Set(filtered.map((m) => m.filePath))];
+    }
+    else {
+        testFiles = findTestFiles();
+    }
     if (testFiles.length === 0) {
         spinner.fail("No test files found");
         output.setData({
@@ -22,9 +60,9 @@ export const executeRunLocal = createCommandHandler("test", async (options, outp
         output.exit(1);
     }
     spinner.succeed(`Found ${output.colors.bold(testFiles.length.toString())} test file(s)`);
-    testFiles.forEach((file) => output.dim(`  - ${file}`));
+    testFiles.forEach((file) => output.dim(`  - ${basename(file)}`));
     output.blank();
-    const results = await Promise.all(testFiles.map(async (file) => {
+    const rawResults = await Promise.all(testFiles.map(async (file) => {
         const fileName = basename(file);
         const testSpinner = output
             .spinner(`Running ${output.colors.cyan(fileName)}`)
@@ -35,32 +73,74 @@ export const executeRunLocal = createCommandHandler("test", async (options, outp
         }
         else {
             testSpinner.fail(`${output.colors.cyan(fileName)} failed`);
+            if (result.error) {
+                output.dim(`  ${result.error}`);
+            }
+            if (result.executionResult?.errors &&
+                result.executionResult.errors.length > 0) {
+                for (const err of result.executionResult.errors) {
+                    output.dim(`  • ${err}`);
+                }
+            }
+        }
+        const row = {
+            file: fileName,
+            success: result.success,
+        };
+        if (!result.success) {
+            row.error = result.error;
+            row.phase = result.phase;
+            if (result.executionResult?.errors &&
+                result.executionResult.errors.length > 0) {
+                row.errors = result.executionResult.errors;
+            }
         }
-        return { file: fileName, success: result.success };
+        return row;
     }));
-    const passed = results.filter((r) => r.success).length;
-    const failed = results.length - passed;
+    const passed = rawResults.filter((r) => r.success).length;
+    const failed = rawResults.length - passed;
     output.setData({
-        results,
+        results: rawResults,
         passed,
         failed,
     });
     output.blank();
     if (failed === 0) {
-        output.success(`All tests passed (${output.colors.bold(passed.toString())} / ${results.length})`);
+        output.success(`All tests passed (${output.colors.bold(passed.toString())} / ${rawResults.length})`);
     }
     else {
         output.error(`${output.colors.bold(failed.toString())} test(s) failed, ${output.colors.bold(passed.toString())} passed`);
+        const failedResults = rawResults.filter((r) => !r.success);
+        for (const r of failedResults) {
+            output.dim(`  • ${r.file}: ${r.error ?? "unknown error"}`);
+        }
         output.exit(1);
     }
 });
 async function runTest(file, envName) {
     try {
         const result = await runTestFile(file, envName);
-        return { success: result.success };
+        if (result.success) {
+            return { success: true };
+        }
+        const error = result.errors?.[0] ?? (result.errors?.length ? result.errors.join("; ") : undefined);
+        return {
+            success: false,
+            error: error ?? "Monitor run failed",
+            phase: "assert",
+            executionResult: result,
+        };
     }
     catch (error) {
-        console.error(error.message || String(error));
-        return { success: false };
+        const err = error;
+        const message = err?.message ?? String(error);
+        const phase = error instanceof MonitorRunnerError
+            ? error.phase
+            : inferPhaseFromMessage(message);
+        return {
+            success: false,
+            error: message,
+            phase,
+        };
     }
 }

package/dist/commands/validate.d.ts

@@ -1,4 +1,5 @@
 export interface ValidateOptions {
+    monitor?: string;
     json?: boolean;
 }
 /**

package/dist/commands/validate.js

@@ -1,15 +1,26 @@
 import { loadState } from "../core/state.js";
 import { createCommandHandler } from "../utils/command-wrapper.js";
-import { discoverLocalMonitors } from "../core/monitor-helpers.js";
+import { OutputError } from "../utils/output.js";
+import { discoverLocalMonitors, filterDiscoveredByName, monitorNotFoundData, } from "../core/monitor-helpers.js";
 /**
  * Validate test monitor files without syncing
  */
-export const executeValidate = createCommandHandler("validate", async (_options, output) => {
+export const executeValidate = createCommandHandler("validate", async (options, output) => {
     const state = await loadState();
     const { monitors } = await discoverLocalMonitors(state);
+    let toValidate = monitors;
+    if (options.monitor) {
+        toValidate = filterDiscoveredByName(monitors, options.monitor);
+        if (toValidate.length === 0) {
+            const data = monitorNotFoundData(options.monitor, monitors.map((m) => m.monitor.name));
+            throw new OutputError("NOT_FOUND", data.message, { available: data.available }, data.available.length
+                ? "Available: " + data.available.join(", ")
+                : undefined);
+        }
+    }
     output.setData({
         valid: true,
-        monitors: monitors.map(({ monitor, filePath, exportName }) => ({
+        monitors: toValidate.map(({ monitor, filePath, exportName }) => ({
             name: monitor.name,
             filePath: filePath.replace(process.cwd(), "."),
             exportName,
@@ -21,7 +32,7 @@ export const executeValidate = createCommandHandler("validate", async (_options,
         })),
     });
     output.blank();
-    for (const { monitor, filePath, exportName } of monitors) {
+    for (const { monitor, filePath, exportName } of toValidate) {
         const shortPath = filePath.replace(process.cwd(), ".");
         const exportInfo = exportName === "default" ? "" : output.colors.dim(` (${exportName})`);
         output.log(`  ${output.colors.green("●")} ${output.colors.cyan(monitor.name)}${exportInfo}`);

package/dist/core/apply.js

@@ -84,7 +84,6 @@ async function applyUpdate(action, sdk, applied) {
         },
         body: resolvedMonitor,
     });
-    console.log(JSON.stringify(result.data, null, 2));
     applied.push({
         type: "update",
         monitorName: action.remoteMonitor.name,

package/dist/core/monitor-helpers.d.ts

@@ -1,7 +1,19 @@
 import type { GriffinHubSdk, MonitorV1 } from "@griffin-app/griffin-hub-sdk";
 import type { StateFile } from "../schemas/state.js";
-import { type DiscoveryResult } from "./discovery.js";
+import { type DiscoveredMonitor, type DiscoveryResult } from "./discovery.js";
 import { MonitorDSL } from "@griffin-app/griffin-core/types";
+/**
+ * Get discovery pattern and ignore list from state (shared defaults).
+ */
+export declare function getDiscoveryConfig(state?: StateFile): {
+    pattern: string;
+    ignore: string[];
+};
+/**
+ * Discover local monitors using state-configured patterns, without spinner or exit.
+ * Caller handles errors and UI. Use when you need to discover and then filter or handle errors yourself (e.g. test --monitor).
+ */
+export declare function discoverLocalMonitorsSilent(state?: StateFile): Promise<DiscoveryResult>;
 /**
  * Discover local monitors using state-configured patterns.
  * Shows spinner, handles errors, and returns the discovery result.
@@ -18,3 +30,16 @@ export declare function fetchRemoteMonitors(sdk: GriffinHubSdk, projectId: strin
 export declare function resolveLocalMonitors(monitors: {
     monitor: MonitorDSL;
 }[], projectId: string, envName: string): Promise<Omit<MonitorV1, "id">[]>;
+/**
+ * Filter discovered monitors by name (exact match).
+ */
+export declare function filterDiscoveredByName(monitors: DiscoveredMonitor[], name: string): DiscoveredMonitor[];
+/**
+ * Build NOT_FOUND error data for JSON output when a monitor name is missing.
+ * Use with output.setData() then output.error(), output.info("Available monitors:"), etc., and output.exit(1).
+ */
+export declare function monitorNotFoundData(monitorName: string, availableNames: string[]): {
+    error: "NOT_FOUND";
+    message: string;
+    available: string[];
+};

package/dist/core/monitor-helpers.js

@@ -3,18 +3,31 @@ import { terminal } from "../utils/terminal.js";
 import { withSDKErrorHandling } from "../utils/sdk-error.js";
 import { loadVariables } from "./variables.js";
 import { resolveMonitor } from "../resolve.js";
+/**
+ * Get discovery pattern and ignore list from state (shared defaults).
+ */
+export function getDiscoveryConfig(state) {
+    return {
+        pattern: state?.discovery?.pattern ?? "**/__griffin__/*.{ts,js}",
+        ignore: state?.discovery?.ignore ?? ["node_modules/**", "dist/**"],
+    };
+}
+/**
+ * Discover local monitors using state-configured patterns, without spinner or exit.
+ * Caller handles errors and UI. Use when you need to discover and then filter or handle errors yourself (e.g. test --monitor).
+ */
+export async function discoverLocalMonitorsSilent(state) {
+    const { pattern, ignore } = getDiscoveryConfig(state);
+    return discoverMonitors(pattern, ignore);
+}
 /**
  * Discover local monitors using state-configured patterns.
  * Shows spinner, handles errors, and returns the discovery result.
  */
 export async function discoverLocalMonitors(state) {
-    const discoveryPattern = state?.discovery?.pattern || "**/__griffin__/*.{ts,js}";
-    const discoveryIgnore = state?.discovery?.ignore || [
-        "node_modules/**",
-        "dist/**",
-    ];
+    const { pattern, ignore } = getDiscoveryConfig(state);
     const spinner = terminal.spinner("Discovering local monitors...").start();
-    const result = await discoverMonitors(discoveryPattern, discoveryIgnore);
+    const result = await discoverMonitors(pattern, ignore);
     if (result.errors.length > 0) {
         spinner.fail("Discovery failed");
         terminal.error(formatDiscoveryErrors(result.errors));
@@ -46,3 +59,20 @@ export async function resolveLocalMonitors(monitors, projectId, envName) {
     const variables = await loadVariables(envName);
     return monitors.map((p) => resolveMonitor(p.monitor, projectId, envName, variables));
 }
+/**
+ * Filter discovered monitors by name (exact match).
+ */
+export function filterDiscoveredByName(monitors, name) {
+    return monitors.filter((m) => m.monitor.name === name);
+}
+/**
+ * Build NOT_FOUND error data for JSON output when a monitor name is missing.
+ * Use with output.setData() then output.error(), output.info("Available monitors:"), etc., and output.exit(1).
+ */
+export function monitorNotFoundData(monitorName, availableNames) {
+    return {
+        error: "NOT_FOUND",
+        message: `Monitor "${monitorName}" not found`,
+        available: availableNames,
+    };
+}

package/dist/monitor-runner.d.ts

@@ -1,5 +1,10 @@
 import "tsx";
 import { ExecutionResult } from "@griffin-app/griffin-executor";
+export type MonitorRunnerPhase = "load" | "validate" | "resolve" | "execute" | "assert";
+export declare class MonitorRunnerError extends Error {
+    readonly phase: MonitorRunnerPhase;
+    constructor(phase: MonitorRunnerPhase, message: string, cause?: unknown);
+}
 /**
  * Runs a TypeScript test file and executes the resulting JSON monitor.
  */

package/dist/monitor-runner.js

@@ -6,9 +6,20 @@ import { randomUUID } from "crypto";
 import { loadVariables } from "./core/variables.js";
 import { getProjectId } from "./core/state.js";
 import { resolveMonitor } from "./resolve.js";
-import { terminal } from "./utils/terminal.js";
 import { createEnvSecretsProvider, HubSecretProvider } from "./core/secrets.js";
 import { createSdkFromState } from "./core/sdk.js";
+export class MonitorRunnerError extends Error {
+    phase;
+    constructor(phase, message, cause) {
+        super(message);
+        this.phase = phase;
+        this.name = "MonitorRunnerError";
+        if (cause !== undefined && cause instanceof Error && cause.cause === undefined) {
+            this.cause = cause;
+        }
+        Object.setPrototypeOf(this, MonitorRunnerError.prototype);
+    }
+}
 function validateDsl(monitor) {
     const errors = Value.Errors(MonitorDSLSchema, monitor);
     if (errors.length > 0) {
@@ -16,16 +27,43 @@ function validateDsl(monitor) {
     }
     return monitor;
 }
+function messageFromCause(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
 /**
  * Runs a TypeScript test file and executes the resulting JSON monitor.
  */
 export async function runTestFile(filePath, envName) {
-    const variables = await loadVariables(envName);
-    const projectId = await getProjectId();
-    const defaultExport = await import(filePath);
-    const rawMonitor = validateDsl(defaultExport.default);
-    terminal.dim(`Project ID: ${projectId}`);
-    const resolvedMonitor = resolveMonitor(rawMonitor, projectId, envName, variables);
+    let variables;
+    let projectId;
+    try {
+        variables = await loadVariables(envName);
+        projectId = await getProjectId();
+    }
+    catch (cause) {
+        throw new MonitorRunnerError("resolve", messageFromCause(cause), cause);
+    }
+    let defaultExport;
+    try {
+        defaultExport = await import(filePath);
+    }
+    catch (cause) {
+        throw new MonitorRunnerError("load", messageFromCause(cause), cause);
+    }
+    let rawMonitor;
+    try {
+        rawMonitor = validateDsl(defaultExport.default);
+    }
+    catch (cause) {
+        throw new MonitorRunnerError("validate", messageFromCause(cause), cause);
+    }
+    let resolvedMonitor;
+    try {
+        resolvedMonitor = resolveMonitor(rawMonitor, projectId, envName, variables);
+    }
+    catch (cause) {
+        throw new MonitorRunnerError("resolve", messageFromCause(cause), cause);
+    }
     // Create secret provider: prefer hub (authenticated) for cloud secrets,
     // fall back to env provider for fully-local runs.
     const monitorV1 = { ...resolvedMonitor, id: randomUUID() };
@@ -46,6 +84,7 @@ export async function runTestFile(filePath, envName) {
         return result;
     }
     catch (error) {
-        throw new Error(`Error executing monitor: ${error instanceof Error ? error.message : String(error)}`);
+        const message = error instanceof Error ? error.message : String(error);
+        throw new MonitorRunnerError("execute", `Error executing monitor: ${message}`, error);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@griffin-app/griffin-cli",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "CLI tool for running and managing griffin API tests",
   "type": "module",
   "main": "dist/index.js",
@@ -24,9 +24,9 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@griffin-app/griffin-core": "0.2.4",
-    "@griffin-app/griffin-executor": "0.1.7",
-    "@griffin-app/griffin-hub-sdk": "1.0.29",
+    "@griffin-app/griffin-core": "0.2.6",
+    "@griffin-app/griffin-executor": "0.1.8",
+    "@griffin-app/griffin-hub-sdk": "1.0.30",
     "better-auth": "^1.4.17",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",