@griffin-app/griffin-cli 1.0.39 → 1.0.40

package/dist/commands/local/config.js

@@ -0,0 +1,82 @@
+import { addTarget, removeTarget, listEnvironments, setDefaultEnvironment, } from "../../core/state.js";
+/**
+ * List all local environments and their targets
+ */
+export async function executeConfigList() {
+    try {
+        const environments = await listEnvironments();
+        const envNames = Object.keys(environments);
+        if (envNames.length === 0) {
+            console.log("No environments configured.");
+            console.log("");
+            console.log("Add a target to create an environment:");
+            console.log("  griffin local config add-target --env <name> --key <key> --url <url>");
+            return;
+        }
+        console.log("Local environments:");
+        console.log("");
+        for (const envName of envNames) {
+            const env = environments[envName];
+            const marker = env.isDefault ? " (default)" : "";
+            console.log(`  ${envName}${marker}`);
+            const targetKeys = Object.keys(env.targets);
+            if (targetKeys.length === 0) {
+                console.log("    (no targets)");
+            }
+            else {
+                for (const [key, url] of Object.entries(env.targets)) {
+                    console.log(`    ${key}: ${url}`);
+                }
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Add a target to a local environment
+ */
+export async function executeConfigAddTarget(options) {
+    try {
+        await addTarget(options.env, options.key, options.url);
+        console.log(`✓ Target added to '${options.env}' environment`);
+        console.log(`  ${options.key}: ${options.url}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Remove a target from a local environment
+ */
+export async function executeConfigRemoveTarget(options) {
+    try {
+        await removeTarget(options.env, options.key);
+        console.log(`✓ Target removed from '${options.env}' environment`);
+        console.log(`  Key: ${options.key}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Set the default environment
+ */
+export async function executeConfigSetDefaultEnv(options) {
+    try {
+        await setDefaultEnvironment(options.env);
+        console.log(`✓ Set '${options.env}' as default environment`);
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1 @@
+export declare function executeLogs(checkName: string): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,20 @@
+import { getRunnerHost } from "./configure-runner-host";
+const axios = require("axios");
+export async function executeLogs(checkName) {
+    const runnerHost = getRunnerHost();
+    if (!runnerHost) {
+        console.error("ERROR: No runner host configured. Run: griffin configure-runner-host <host>");
+        process.exit(1);
+    }
+    console.log(`Fetching logs for: ${checkName}`);
+    try {
+        // TODO: Implement log fetching from runner API
+        const response = await axios.get(`${runnerHost}/api/tests/${checkName}/logs`);
+        console.log(JSON.stringify(response.data, null, 2));
+    }
+    catch (error) {
+        console.error("ERROR: Failed to fetch logs");
+        console.error(error.message || String(error));
+        process.exit(1);
+    }
+}

package/dist/commands/plan.d.ts

@@ -0,0 +1,8 @@
+export interface MonitorOptions {
+    json?: boolean;
+    env?: string;
+}
+/**
+ * Show what changes would be applied
+ */
+export declare function executeMonitor(options: MonitorOptions): Promise<void>;

package/dist/commands/plan.js

@@ -0,0 +1,58 @@
+import { loadState, resolveEnvironment } from "../core/state.js";
+import { discoverMonitors, formatDiscoveryErrors } from "../core/discovery.js";
+import { createSdkClients } from "../core/sdk.js";
+import { computeDiff, formatDiff, formatDiffJson } from "../core/diff.js";
+/**
+ * Show what changes would be applied
+ */
+export async function executeMonitor(options) {
+    try {
+        // Load state
+        const state = await loadState();
+        // Resolve environment
+        const envName = await resolveEnvironment(options.env);
+        if (!state.runner?.baseUrl) {
+            console.error("Error: Runner URL not configured.");
+            console.log("Configure with:");
+            console.log("  griffin runner set --base-url <url> --api-token <token>");
+            process.exit(1);
+        }
+        // Discover local monitors
+        const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
+        const discoveryIgnore = state.discovery?.ignore || [
+            "node_modules/**",
+            "dist/**",
+        ];
+        const { monitors, errors } = await discoverMonitors(discoveryPattern, discoveryIgnore);
+        if (errors.length > 0) {
+            console.error(formatDiscoveryErrors(errors));
+            process.exit(1);
+        }
+        // Create SDK clients
+        const { planApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken || undefined,
+        });
+        // Fetch remote monitors for this project
+        const response = await planApi.planGet(state.projectId);
+        const remoteMonitors = response.data.data.map((p) => p);
+        // Compute diff for this environment
+        const diff = computeDiff(monitors.map((p) => p.monitor), state, remoteMonitors, envName);
+        // Output
+        if (options.json) {
+            console.log(formatDiffJson(diff));
+        }
+        else {
+            console.log(formatDiff(diff));
+        }
+        // Exit with error code if there are changes
+        if (diff.summary.creates + diff.summary.updates + diff.summary.deletes >
+            0) {
+            process.exit(2); // Exit code 2 indicates changes pending
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/run-remote.d.ts

@@ -0,0 +1,11 @@
+export interface RunOptions {
+    planId?: string;
+    planName?: string;
+    wait?: boolean;
+    env?: string;
+    targetEnv?: string;
+}
+/**
+ * Trigger a monitor run on the runner
+ */
+export declare function executeRun(options: RunOptions): Promise<void>;

package/dist/commands/run-remote.js

@@ -0,0 +1,98 @@
+import { loadState, resolveEnvironment } from "../core/state.js";
+import { createSdkClients } from "../core/sdk.js";
+/**
+ * Trigger a monitor run on the runner
+ */
+export async function executeRun(options) {
+    try {
+        // TODO: remove this. Users shoud be able to execute all monitors if they want.
+        if (!options.planId && !options.planName) {
+            console.error("Error: Either --monitor-id or --monitor-name must be provided");
+            process.exit(1);
+        }
+        if (!options.targetEnv) {
+            console.error("Error: --target-env must be provided (e.g., staging, production)");
+            process.exit(1);
+        }
+        // Load state
+        const state = await loadState();
+        if (!state.runner?.baseUrl) {
+            console.error("Error: Runner URL not configured.");
+            console.log("Configure with:");
+            console.log("  griffin runner set --base-url <url> --api-token <token>");
+            process.exit(1);
+        }
+        // Create SDK clients (for status polling)
+        const { runsApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken || undefined,
+        });
+        // Resolve monitor ID from name if needed
+        let planId = options.planId;
+        if (!planId && options.planName) {
+            // Resolve environment to search in
+            const envName = await resolveEnvironment(options.env);
+            const envMonitors = state.monitors[envName] || [];
+            const stateEntry = envMonitors.find((p) => p.planName === options.planName);
+            if (!stateEntry) {
+                console.error(`Error: Monitor "${options.planName}" not found in state`);
+                console.error("Run 'griffin apply' to sync your monitors first");
+                process.exit(1);
+            }
+            planId = stateEntry.planId;
+        }
+        // Trigger the run with environment
+        console.log(`Triggering run for monitor: ${planId}`);
+        console.log(`Target environment: ${options.targetEnv}`);
+        const response = await runsApi.runsTriggerMonitorIdPost(planId, {
+            environment: options.targetEnv,
+        });
+        console.log(`Run ID: ${response.data.data.id}`);
+        console.log(`Status: ${response.data.data.status}`);
+        console.log(`Started: ${new Date(response.data.data.startedAt).toLocaleString()}`);
+        // Wait for completion if requested
+        if (options.wait) {
+            console.log("");
+            console.log("Waiting for run to complete...");
+            const runId = response.data.data.id;
+            let completed = false;
+            while (!completed) {
+                await new Promise((resolve) => setTimeout(resolve, 2000)); // Poll every 2 seconds
+                const { data: runResponse } = await runsApi.runsIdGet(runId);
+                const run = runResponse.data;
+                if (run.status === "completed" || run.status === "failed") {
+                    completed = true;
+                    console.log("");
+                    console.log(`✓ Run ${run.status}`);
+                    if (run.duration_ms) {
+                        console.log(`Duration: ${(run.duration_ms / 1000).toFixed(2)}s`);
+                    }
+                    if (run.success !== undefined) {
+                        console.log(`Success: ${run.success ? "Yes" : "No"}`);
+                    }
+                    if (run.errors && run.errors.length > 0) {
+                        console.log("");
+                        console.log("Errors:");
+                        for (const error of run.errors) {
+                            console.log(`  - ${error}`);
+                        }
+                    }
+                    if (!run.success) {
+                        process.exit(1);
+                    }
+                }
+                else {
+                    process.stdout.write(".");
+                }
+            }
+        }
+        else {
+            console.log("");
+            console.log("Run started. Use 'griffin status' to check progress.");
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/run.d.ts

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

package/dist/commands/run.js

@@ -0,0 +1,86 @@
+import { findTestFiles } from "../test-discovery.js";
+import { runTestFile } from "../test-runner.js";
+import { resolveEnvironment, getEnvironment } from "../core/state.js";
+import { basename } from "path";
+export async function executeRunLocal(options = {}) {
+    try {
+        // Resolve environment
+        const envName = await resolveEnvironment(options.env);
+        const envConfig = await getEnvironment(envName);
+        console.log(`Running tests locally against '${envName}' environment`);
+        console.log(`Target: ${envConfig.baseUrl}`);
+        console.log("");
+        const testFiles = findTestFiles();
+        if (testFiles.length === 0) {
+            console.error("No test files found. Looking for .ts files in __griffin__ directories.");
+            process.exit(1);
+        }
+        console.log(`Found ${testFiles.length} test file(s):`);
+        testFiles.forEach((file) => console.log(`  - ${file}`));
+        console.log("");
+        const results = await Promise.all(testFiles.map(async (file) => {
+            const fileName = basename(file);
+            console.log(`Running ${fileName}`);
+            const result = await runTest(file, envConfig.baseUrl);
+            return result;
+        }));
+        // Print summary
+        const successful = results.filter((r) => r.success).length;
+        const failed = results.length - successful;
+        console.log("");
+        console.log(`Summary: ${successful} passed, ${failed} failed`);
+        if (failed > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+async function runTest(file, baseUrl) {
+    try {
+        const result = await runTestFile(file, baseUrl);
+        console.log("SUCCESS: result", result);
+        return { success: result.success };
+    }
+    catch (error) {
+        console.error("ERROR: Failed to run test");
+        console.error(error.message || String(error));
+        return { success: false };
+    }
+}
+function displayResults(result) {
+    if (!result)
+        return false;
+    const success = result.success || false;
+    const nodeResults = result.results || [];
+    const errors = result.errors || [];
+    nodeResults.forEach((nodeResult) => {
+        const nodeId = nodeResult.nodeId || "unknown";
+        const nodeSuccess = nodeResult.success || false;
+        const status = nodeSuccess ? "." : "E";
+        process.stdout.write(status);
+        if (!nodeSuccess) {
+            const error = nodeResult.error || "Unknown error";
+            console.log("");
+            console.log(`ERROR in ${nodeId}: ${error}`);
+        }
+    });
+    console.log("");
+    if (errors.length > 0) {
+        console.log("Errors:");
+        errors.forEach((error) => console.log(`  - ${error}`));
+    }
+    // Check if any node failed or if there are errors
+    const anyFailed = nodeResults.some((nodeResult) => !nodeResult.success) ||
+        errors.length > 0;
+    const testPassed = success && !anyFailed;
+    if (testPassed) {
+        console.log("✓ Test passed");
+    }
+    else {
+        console.log("✗ Test failed");
+    }
+    return testPassed;
+}

package/dist/commands/runner.d.ts

@@ -0,0 +1,12 @@
+export interface RunnerSetOptions {
+    baseUrl: string;
+    apiToken?: string;
+}
+/**
+ * Configure runner connection settings
+ */
+export declare function executeRunnerSet(options: RunnerSetOptions): Promise<void>;
+/**
+ * Show current runner configuration
+ */
+export declare function executeRunnerShow(): Promise<void>;

package/dist/commands/runner.js

@@ -0,0 +1,53 @@
+import { loadState, saveState } from "../core/state.js";
+/**
+ * Configure runner connection settings
+ */
+export async function executeRunnerSet(options) {
+    try {
+        const state = await loadState();
+        // Update runner config
+        state.runner = {
+            baseUrl: options.baseUrl,
+            apiToken: options.apiToken,
+        };
+        await saveState(state);
+        console.log("✓ Runner configuration updated");
+        console.log(`  Base URL: ${options.baseUrl}`);
+        if (options.apiToken) {
+            console.log("  API Token: ***");
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Show current runner configuration
+ */
+export async function executeRunnerShow() {
+    try {
+        const state = await loadState();
+        if (!state.runner) {
+            console.log("No runner configured.");
+            console.log("");
+            console.log("Configure with:");
+            console.log("  griffin runner set --base-url <url> --api-token <token>");
+            return;
+        }
+        console.log("Runner configuration:");
+        console.log(`  Base URL: ${state.runner.baseUrl}`);
+        if (state.runner.apiToken) {
+            console.log(`  API Token: ${state.runner.apiToken.substring(0, 8)}...`);
+        }
+        else {
+            console.log("  API Token: (not set)");
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,8 @@
+export interface StatusOptions {
+    planId?: string;
+    limit?: number;
+}
+/**
+ * Show runner status and recent runs
+ */
+export declare function executeStatus(options: StatusOptions): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,75 @@
+import { loadState } from "../core/state.js";
+import { createSdkClients } from "../core/sdk.js";
+/**
+ * Show runner status and recent runs
+ */
+export async function executeStatus(options) {
+    try {
+        // Load state
+        const state = await loadState();
+        if (!state.runner?.baseUrl) {
+            console.error("Error: Runner URL not configured.");
+            console.log("Configure with:");
+            console.log("  griffin runner set --base-url <url> --api-token <token>");
+            process.exit(1);
+        }
+        // Create SDK clients
+        const { runsApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken || undefined,
+        });
+        console.log(`Runner: ${state.runner.baseUrl}`);
+        console.log("");
+        // Get recent runs
+        const limit = options.limit || 10;
+        const response = await runsApi.runsGet(options.planId, undefined, limit, 0);
+        const runs = response.data;
+        if (runs.total === 0) {
+            console.log("No runs found.");
+            return;
+        }
+        console.log(`Recent runs (${runs.total} total):`);
+        console.log("");
+        for (const run of runs.runs) {
+            const statusIcon = getStatusIcon(run.status, run.success);
+            const duration = run.duration_ms
+                ? ` (${(run.duration_ms / 1000).toFixed(2)}s)`
+                : "";
+            console.log(`${statusIcon} ${run.planName}`);
+            console.log(`  ID: ${run.id}`);
+            console.log(`  Status: ${run.status}${duration}`);
+            console.log(`  Started: ${new Date(run.startedAt).toLocaleString()}`);
+            if (run.completedAt) {
+                console.log(`  Completed: ${new Date(run.completedAt).toLocaleString()}`);
+            }
+            if (run.errors && run.errors.length > 0) {
+                console.log(`  Errors:`);
+                for (const error of run.errors.slice(0, 3)) {
+                    console.log(`    - ${error}`);
+                }
+                if (run.errors.length > 3) {
+                    console.log(`    ... and ${run.errors.length - 3} more`);
+                }
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+function getStatusIcon(status, success) {
+    switch (status) {
+        case "pending":
+            return "⏳";
+        case "running":
+            return "🏃";
+        case "completed":
+            return success ? "✓" : "✗";
+        case "failed":
+            return "✗";
+        default:
+            return "•";
+    }
+}

package/dist/core/plan-diff.d.ts

@@ -0,0 +1,41 @@
+import { MonitorV1 } from "@griffin-app/griffin-hub-sdk";
+/**
+ * Represents a change to a single field
+ */
+export interface FieldChange {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+/**
+ * Represents a change to a node (add/remove/modify)
+ */
+export interface NodeChange {
+    type: "add" | "remove" | "modify";
+    nodeId: string;
+    nodeType: "ASSERTION" | "HTTP_REQUEST" | "WAIT";
+    summary: string;
+    fieldChanges: FieldChange[];
+}
+/**
+ * Represents a change to an edge (add/remove)
+ */
+export interface EdgeChange {
+    type: "add" | "remove";
+    from: string;
+    to: string;
+}
+/**
+ * Complete set of changes between local and remote monitors
+ */
+export interface MonitorChanges {
+    hasChanges: boolean;
+    nodes: NodeChange[];
+    edges: EdgeChange[];
+    topLevel: FieldChange[];
+}
+/**
+ * Compare two test monitors and return granular changes.
+ * Local monitor should be resolved (variables replaced with actual values).
+ */
+export declare function compareMonitors(local: MonitorV1, remote: MonitorV1): MonitorChanges;