@griffin-app/griffin-cli 1.0.39 → 1.0.40

package/dist/commands/apply.d.ts

@@ -0,0 +1,9 @@
+export interface ApplyOptions {
+    autoApprove?: boolean;
+    dryRun?: boolean;
+    env?: string;
+}
+/**
+ * Apply changes to the runner
+ */
+export declare function executeApply(options: ApplyOptions): Promise<void>;

package/dist/commands/apply.js

@@ -0,0 +1,76 @@
+import { loadState, resolveEnvironment } from "../core/state.js";
+import { discoverMonitors, formatDiscoveryErrors } from "../core/discovery.js";
+import { computeDiff, formatDiff } from "../core/diff.js";
+import { applyDiff, formatApplyResult } from "../core/apply.js";
+import { createSdkClients } from "../core/sdk.js";
+/**
+ * Apply changes to the runner
+ */
+export async function executeApply(options) {
+    try {
+        // Load state
+        const state = await loadState();
+        // Resolve environment
+        const envName = await resolveEnvironment(options.env);
+        // Check if runner is configured
+        if (!state.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);
+        }
+        console.log(`Applying to '${envName}' environment`);
+        console.log("");
+        // Create SDK clients
+        const { planApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken || undefined,
+        });
+        // 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);
+        }
+        // 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);
+        // Show monitor
+        console.log(formatDiff(diff));
+        console.log("");
+        // Check if there are changes
+        if (diff.summary.creates + diff.summary.updates + diff.summary.deletes ===
+            0) {
+            console.log("No changes to apply.");
+            return;
+        }
+        // Ask for confirmation unless auto-approved
+        if (!options.autoApprove && !options.dryRun) {
+            console.log("Do you want to perform these actions? (yes/no)");
+            // For now, just proceed - in a real implementation, we'd use readline
+            // to get user input
+            console.log("Note: Use --auto-approve flag to skip confirmation");
+            console.log("");
+        }
+        // Apply changes
+        const result = await applyDiff(diff, state, planApi, envName, {
+            dryRun: options.dryRun,
+        });
+        console.log("");
+        console.log(formatApplyResult(result));
+        if (!result.success) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,36 @@
+export interface ConfigSetOptions {
+    organizationId: string;
+    environment: string;
+    targetKey: string;
+    baseUrl: string;
+}
+/**
+ * Set a target for an organization and environment
+ */
+export declare function executeConfigSet(options: ConfigSetOptions): Promise<void>;
+export interface ConfigGetOptions {
+    organizationId: string;
+    environment: string;
+    targetKey: string;
+}
+/**
+ * Get a target for an organization and environment
+ */
+export declare function executeConfigGet(options: ConfigGetOptions): Promise<void>;
+export interface ConfigListOptions {
+    organizationId?: string;
+    environment?: string;
+}
+/**
+ * List all runner configs
+ */
+export declare function executeConfigList(options: ConfigListOptions): Promise<void>;
+export interface ConfigDeleteOptions {
+    organizationId: string;
+    environment: string;
+    targetKey: string;
+}
+/**
+ * Delete a target from an organization and environment
+ */
+export declare function executeConfigDelete(options: ConfigDeleteOptions): Promise<void>;

package/dist/commands/config.js

@@ -0,0 +1,144 @@
+import { loadState } from "../core/state.js";
+import { createSdkClients } from "../core/sdk.js";
+/**
+ * Set a target for an organization and environment
+ */
+export async function executeConfigSet(options) {
+    try {
+        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);
+        }
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        const result = await configApi.configOrganizationIdEnvironmentTargetsTargetKeyPut(options.organizationId, options.environment, options.targetKey, {
+            baseUrl: options.baseUrl,
+        });
+        //.setTarget(options.organizationId, options.environment, options.targetKey, options.baseUrl);
+        //const result = await runnerRequest<{ data: RunnerConfig }>(
+        //  state.runner.baseUrl,
+        //  state.runner.apiToken,
+        //  path,
+        //  {
+        //    method: "PUT",
+        //    body: JSON.stringify({ baseUrl: options.baseUrl }),
+        //  },
+        //);
+        console.log(`✓ Target "${options.targetKey}" set to ${options.baseUrl}`);
+        console.log(`  Organization: ${options.organizationId}`);
+        console.log(`  Environment: ${options.environment}`);
+        console.log(`  Updated at: ${new Date(result.data.data.updatedAt).toLocaleString()}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Get a target for an organization and environment
+ */
+export async function executeConfigGet(options) {
+    try {
+        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);
+        }
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        const result = await configApi.configOrganizationIdEnvironmentTargetsTargetKeyGet(options.organizationId, options.environment, options.targetKey);
+        console.log(`Target: ${options.targetKey}`);
+        console.log(`Base URL: ${result.data.data.baseUrl}`);
+        console.log(`Organization: ${options.organizationId}`);
+        console.log(`Environment: ${options.environment}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * List all runner configs
+ */
+export async function executeConfigList(options) {
+    try {
+        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);
+        }
+        const params = new URLSearchParams();
+        if (options.organizationId)
+            params.append("organizationId", options.organizationId);
+        if (options.environment)
+            params.append("environment", options.environment);
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        const result = await configApi.configGet(options.organizationId, options.environment);
+        if (result.data.data.length === 0 || !result.data.data) {
+            console.log("No runner configs found.");
+            return;
+        }
+        console.log(`Found ${result.data.data.length} runner config(s):`);
+        console.log("");
+        for (const config of result.data.data) {
+            console.log(`Organization: ${config.organizationId}`);
+            console.log(`Environment: ${config.environment}`);
+            console.log(`Targets:`);
+            const targetCount = Object.keys(config.targets).length;
+            if (targetCount === 0) {
+                console.log("  (none)");
+            }
+            else {
+                for (const [key, baseUrl] of Object.entries(config.targets)) {
+                    console.log(`  ${key}: ${baseUrl}`);
+                }
+            }
+            console.log(`Updated: ${new Date(config.updatedAt).toLocaleString()}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Delete a target from an organization and environment
+ */
+export async function executeConfigDelete(options) {
+    try {
+        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);
+        }
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        await configApi.configOrganizationIdEnvironmentTargetsTargetKeyDelete(options.organizationId, options.environment, options.targetKey);
+        console.log(`✓ Target "${options.targetKey}" deleted`);
+        console.log(`  Organization: ${options.organizationId}`);
+        console.log(`  Environment: ${options.environment}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/configure-runner-host.d.ts

@@ -0,0 +1,2 @@
+export declare function executeConfigureRunnerHost(host: string): Promise<void>;
+export declare function getRunnerHost(): string | null;

package/dist/commands/configure-runner-host.js

@@ -0,0 +1,41 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const CONFIG_DIR = path.join(os.homedir(), ".griffin");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export async function executeConfigureRunnerHost(host) {
+    console.log(`Configuring runner host: ${host}`);
+    // Ensure config directory exists
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // Read existing config or create new one
+    let config = {};
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const configData = fs.readFileSync(CONFIG_FILE, "utf-8");
+            config = JSON.parse(configData);
+        }
+        catch (error) {
+            console.warn("Warning: Could not read existing config, creating new one");
+        }
+    }
+    // Update runner host
+    config.runnerHost = host;
+    // Write config
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    console.log(`Configuration saved to ${CONFIG_FILE}`);
+}
+export function getRunnerHost() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const configData = fs.readFileSync(CONFIG_FILE, "utf-8");
+        const config = JSON.parse(configData);
+        return config.runnerHost || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/deploy.d.ts

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

package/dist/commands/deploy.js

@@ -0,0 +1,36 @@
+import { findTestFiles } from "../test-discovery";
+import { getRunnerHost } from "./configure-runner-host";
+import * as path from "path";
+import * as fs from "fs";
+export async function executeDeploy() {
+    const runnerHost = getRunnerHost();
+    if (!runnerHost) {
+        console.error("ERROR: No runner host configured. Run: griffin configure-runner-host <host>");
+        process.exit(1);
+    }
+    console.log("Deploying tests to runner...");
+    const testFiles = findTestFiles();
+    const workspaceRoot = findWorkspaceRoot();
+    const testSystemPath = path.join(workspaceRoot, "griffin-ts", "dist");
+    if (!fs.existsSync(testSystemPath)) {
+        throw new Error("Test system not built. Please run: cd griffin-ts && npm install && npm run build");
+    }
+    // TODO: Implement deployment logic
+    // - Read each test file
+    // - Execute it to get JSON monitor
+    // - Send to runner API
+    // - Handle responses
+    console.log("Deployed.");
+}
+function findWorkspaceRoot() {
+    let current = process.cwd();
+    while (current !== path.dirname(current)) {
+        const griffinCliPath = path.join(current, "griffin-cli");
+        const testSystemPath = path.join(current, "griffin-ts");
+        if (fs.existsSync(griffinCliPath) && fs.existsSync(testSystemPath)) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}

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

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

package/dist/commands/execute-remote.js

@@ -0,0 +1,33 @@
+import { getRunnerHost } from "./configure-runner-host";
+const axios = require("axios");
+import * as readline from "readline";
+export async function executeExecuteRemote(checkName) {
+    const runnerHost = getRunnerHost();
+    if (!runnerHost) {
+        console.error("ERROR: No runner host configured. Run: griffin configure-runner-host <host>");
+        process.exit(1);
+    }
+    console.log("WARNING: Your local checks will be deployed and executed remotely.");
+    console.log("Do you want to continue? (y/n)");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    rl.question("", async (answer) => {
+        rl.close();
+        if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+            console.log("Cancelled.");
+            process.exit(0);
+        }
+        try {
+            // TODO: Implement remote execution
+            const response = await axios.post(`${runnerHost}/api/tests/${checkName}/execute`);
+            console.log(JSON.stringify(response.data, null, 2));
+        }
+        catch (error) {
+            console.error("ERROR: Failed to execute remotely");
+            console.error(error.message || String(error));
+            process.exit(1);
+        }
+    });
+}

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

@@ -0,0 +1,27 @@
+export interface ConfigAddTargetOptions {
+    org: string;
+    env: string;
+    key: string;
+    url: string;
+}
+export interface ConfigRemoveTargetOptions {
+    org: string;
+    env: string;
+    key: string;
+}
+export interface ConfigListOptions {
+    org?: string;
+    env?: string;
+}
+/**
+ * Add a target to hub configuration
+ */
+export declare function executeConfigAddTarget(options: ConfigAddTargetOptions): Promise<void>;
+/**
+ * Remove a target from hub configuration
+ */
+export declare function executeConfigRemoveTarget(options: ConfigRemoveTargetOptions): Promise<void>;
+/**
+ * List all hub configurations
+ */
+export declare function executeConfigList(options: ConfigListOptions): Promise<void>;

package/dist/commands/hub/config.js

@@ -0,0 +1,102 @@
+import { loadState } from "../../core/state.js";
+import { createSdkClients } from "../../core/sdk.js";
+/**
+ * Add a target to hub configuration
+ */
+export async function executeConfigAddTarget(options) {
+    try {
+        const state = await loadState();
+        if (!state.runner?.baseUrl) {
+            console.error("Error: Hub connection not configured.");
+            console.log("Connect with:");
+            console.log("  griffin hub connect --url <url> --token <token>");
+            process.exit(1);
+        }
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        const result = await configApi.configOrganizationIdEnvironmentTargetsTargetKeyPut(options.org, options.env, options.key, {
+            baseUrl: options.url,
+        });
+        console.log(`✓ Target "${options.key}" set to ${options.url}`);
+        console.log(`  Organization: ${options.org}`);
+        console.log(`  Environment: ${options.env}`);
+        console.log(`  Updated at: ${new Date(result.data.data.updatedAt).toLocaleString()}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Remove a target from hub configuration
+ */
+export async function executeConfigRemoveTarget(options) {
+    try {
+        const state = await loadState();
+        if (!state.runner?.baseUrl) {
+            console.error("Error: Hub connection not configured.");
+            console.log("Connect with:");
+            console.log("  griffin hub connect --url <url> --token <token>");
+            process.exit(1);
+        }
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        await configApi.configOrganizationIdEnvironmentTargetsTargetKeyDelete(options.org, options.env, options.key);
+        console.log(`✓ Target "${options.key}" deleted`);
+        console.log(`  Organization: ${options.org}`);
+        console.log(`  Environment: ${options.env}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * List all hub configurations
+ */
+export async function executeConfigList(options) {
+    try {
+        const state = await loadState();
+        if (!state.runner?.baseUrl) {
+            console.error("Error: Hub connection not configured.");
+            console.log("Connect with:");
+            console.log("  griffin hub connect --url <url> --token <token>");
+            process.exit(1);
+        }
+        const { configApi } = createSdkClients({
+            baseUrl: state.runner.baseUrl,
+            apiToken: state.runner.apiToken,
+        });
+        const result = await configApi.configGet(options.org, options.env);
+        if (result.data.data.length === 0 || !result.data.data) {
+            console.log("No hub configurations found.");
+            return;
+        }
+        console.log(`Found ${result.data.data.length} configuration(s):`);
+        console.log("");
+        for (const config of result.data.data) {
+            console.log(`Organization: ${config.organizationId}`);
+            console.log(`Environment: ${config.environment}`);
+            console.log(`Targets:`);
+            const targetCount = Object.keys(config.targets).length;
+            if (targetCount === 0) {
+                console.log("  (none)");
+            }
+            else {
+                for (const [key, baseUrl] of Object.entries(config.targets)) {
+                    console.log(`  ${key}: ${baseUrl}`);
+                }
+            }
+            console.log(`Updated: ${new Date(config.updatedAt).toLocaleString()}`);
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/hub/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/hub/plan.js

@@ -0,0 +1,75 @@
+import { loadState, resolveEnvironment } from "../../core/state.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";
+import { withSDKErrorHandling } from "../../utils/sdk-error.js";
+import { loadVariables } from "../../core/variables.js";
+import { resolveMonitor } from "../../resolve.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.hub?.baseUrl) {
+            terminal.error("Hub connection not configured.");
+            terminal.dim("Connect with:");
+            terminal.dim("  griffin hub connect --url <url> --token <token>");
+            terminal.exit(1);
+        }
+        // Discover local monitors
+        const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
+        const discoveryIgnore = state.discovery?.ignore || [
+            "node_modules/**",
+            "dist/**",
+        ];
+        const spinner = terminal.spinner("Discovering local monitors...").start();
+        const { monitors, errors } = await discoverMonitors(discoveryPattern, discoveryIgnore);
+        if (errors.length > 0) {
+            spinner.fail("Discovery failed");
+            terminal.error(formatDiscoveryErrors(errors));
+            terminal.exit(1);
+        }
+        spinner.succeed(`Found ${monitors.length} local monitor(s)`);
+        // 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 response = await withSDKErrorHandling(() => sdk.getMonitor({
+            query: {
+                projectId: state.projectId,
+                environment: envName,
+            },
+        }), "Failed to fetch remote monitors");
+        const remoteMonitors = response?.data?.data;
+        fetchSpinner.succeed(`Found ${remoteMonitors.length} remote monitor(s)`);
+        // Load variables and resolve local monitors before computing diff
+        const variables = await loadVariables(envName);
+        const resolvedMonitors = monitors.map((p) => resolveMonitor(p.monitor, state.projectId, envName, variables));
+        // Compute diff (no deletions shown by default)
+        const diff = computeDiff(resolvedMonitors, remoteMonitors, {
+            includeDeletions: false,
+        });
+        terminal.blank();
+        // Output
+        if (options.json) {
+            terminal.log(formatDiffJson(diff));
+        }
+        else {
+            terminal.log(formatDiff(diff));
+        }
+        // Exit with error code if there are changes
+        if (diff.summary.creates + diff.summary.updates + diff.summary.deletes >
+            0) {
+            terminal.exit(2); // Exit code 2 indicates changes pending
+        }
+    }
+    catch (error) {
+        terminal.error(error.message);
+        terminal.exit(1);
+    }
+}

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

@@ -0,0 +1,28 @@
+export interface ConfigAddTargetOptions {
+    env: string;
+    key: string;
+    url: string;
+}
+export interface ConfigRemoveTargetOptions {
+    env: string;
+    key: string;
+}
+export interface ConfigSetDefaultEnvOptions {
+    env: string;
+}
+/**
+ * List all local environments and their targets
+ */
+export declare function executeConfigList(): Promise<void>;
+/**
+ * Add a target to a local environment
+ */
+export declare function executeConfigAddTarget(options: ConfigAddTargetOptions): Promise<void>;
+/**
+ * Remove a target from a local environment
+ */
+export declare function executeConfigRemoveTarget(options: ConfigRemoveTargetOptions): Promise<void>;
+/**
+ * Set the default environment
+ */
+export declare function executeConfigSetDefaultEnv(options: ConfigSetDefaultEnvOptions): Promise<void>;