@griffin-app/griffin-cli 1.0.0 → 1.0.2

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { executeInit } from "./commands/init.js";
+import { executeValidate } from "./commands/validate.js";
+import { executeGenerateKey } from "./commands/generate-key.js";
+// Local commands
+import { executeRunLocal } from "./commands/local/run.js";
+// Hub commands
+import { executeConnect } from "./commands/hub/connect.js";
+import { executeStatus } from "./commands/hub/status.js";
+import { executeRuns } from "./commands/hub/runs.js";
+import { executePlan } from "./commands/hub/plan.js";
+import { executeApply } from "./commands/hub/apply.js";
+import { executeRun } from "./commands/hub/run.js";
+const program = new Command();
+program
+    .name("griffin")
+    .description("Griffin CLI - Monitoring as Code")
+    .version("1.0.0");
+// Top-level commands
+program
+    .command("init")
+    .description("Initialize griffin in the current directory")
+    .option("--project <name>", "Project ID (defaults to package.json name or directory name)")
+    .action(async (options) => {
+    await executeInit(options);
+});
+program
+    .command("validate")
+    .description("Validate test plan files without syncing")
+    .action(async () => {
+    await executeValidate();
+});
+program
+    .command("generate-key")
+    .description("Generate a cryptographically secure API key for authentication")
+    .action(async () => {
+    await executeGenerateKey();
+});
+// Local command group
+const local = program.command("local").description("Local test execution");
+local
+    .command("run")
+    .description("Run tests locally against an environment")
+    .option("--env <name>", "Environment to run against (uses default if not specified)")
+    .action(async (options) => {
+    await executeRunLocal(options);
+});
+// Hub command group
+const hub = program.command("hub").description("Griffin Hub operations");
+hub
+    .command("connect")
+    .description("Configure hub connection")
+    .requiredOption("--url <url>", "Hub URL")
+    .option("--token <token>", "API authentication token")
+    .action(async (options) => {
+    await executeConnect(options);
+});
+hub
+    .command("status")
+    .description("Show hub connection status")
+    .action(async () => {
+    await executeStatus();
+});
+hub
+    .command("runs")
+    .description("Show recent runs from the hub")
+    .option("--plan <name>", "Filter by plan name")
+    .option("--limit <number>", "Number of runs to show", "10")
+    .action(async (options) => {
+    await executeRuns({
+        ...options,
+        limit: parseInt(options.limit, 10),
+    });
+});
+hub
+    .command("plan")
+    .description("Show what changes would be applied")
+    .option("--env <name>", "Environment to plan for (uses default if not specified)")
+    .option("--json", "Output in JSON format")
+    .action(async (options) => {
+    await executePlan(options);
+});
+hub
+    .command("apply")
+    .description("Apply changes to the hub")
+    .option("--env <name>", "Environment to apply to (uses default if not specified)")
+    .option("--auto-approve", "Skip confirmation prompt")
+    .option("--dry-run", "Show what would be done without making changes")
+    .option("--prune", "Delete plans on hub that don't exist locally")
+    .action(async (options) => {
+    await executeApply(options);
+});
+hub
+    .command("run")
+    .description("Trigger a plan run on the hub")
+    .requiredOption("--plan <name>", "Plan name to run")
+    .requiredOption("--env <name>", "Target environment")
+    .option("--wait", "Wait for run to complete")
+    .option("--force", "Run even if local plan differs from hub")
+    .action(async (options) => {
+    await executeRun(options);
+});
+// Parse arguments
+program.parse();

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 { discoverPlans, 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 plans
+        const discoveryPattern = state.discovery?.pattern || "**/__griffin__/*.{ts,js}";
+        const discoveryIgnore = state.discovery?.ignore || [
+            "node_modules/**",
+            "dist/**",
+        ];
+        const { plans, errors } = await discoverPlans(discoveryPattern, discoveryIgnore);
+        if (errors.length > 0) {
+            console.error(formatDiscoveryErrors(errors));
+            process.exit(1);
+        }
+        // Fetch remote plans for this project
+        const response = await planApi.planGet(state.projectId);
+        const remotePlans = response.data.data.map((p) => p);
+        // Compute diff for this environment
+        const diff = computeDiff(plans.map((p) => p.plan), state, remotePlans, envName);
+        // Show plan
+        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 plan
+    // - 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/env.d.ts

@@ -0,0 +1,25 @@
+export interface EnvAddOptions {
+    baseUrl: string;
+}
+export interface EnvRemoveOptions {
+    name: string;
+}
+export interface EnvDefaultOptions {
+    name: string;
+}
+/**
+ * List all environments
+ */
+export declare function executeEnvList(): Promise<void>;
+/**
+ * Add or update an environment
+ */
+export declare function executeEnvAdd(name: string, options: EnvAddOptions): Promise<void>;
+/**
+ * Remove an environment
+ */
+export declare function executeEnvRemove(name: string): Promise<void>;
+/**
+ * Set default environment
+ */
+export declare function executeEnvDefault(name: string): Promise<void>;

package/dist/commands/env.js

@@ -0,0 +1,121 @@
+import { loadState, addEnvironment, removeEnvironment, setDefaultEnvironment, } from "../core/state.js";
+/**
+ * List all environments
+ */
+export async function executeEnvList() {
+    try {
+        const state = await loadState();
+        const envNames = Object.keys(state.environments);
+        if (envNames.length === 0) {
+            console.log("No environments configured.");
+            console.log("");
+            console.log("Add an environment with:");
+            console.log("  griffin env add <name> --base-url <url>");
+            return;
+        }
+        console.log("Environments:");
+        console.log("");
+        envNames.forEach((name) => {
+            const config = state.environments[name];
+            const isDefault = name === state.defaultEnvironment;
+            const marker = isDefault ? " (default)" : "";
+            console.log(`  ${name}${marker}`);
+            console.log(`    URL: ${config.baseUrl}`);
+        });
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Add or update an environment
+ */
+export async function executeEnvAdd(name, options) {
+    try {
+        const state = await loadState();
+        const isUpdate = name in state.environments;
+        await addEnvironment(name, { baseUrl: options.baseUrl });
+        if (isUpdate) {
+            console.log(`✓ Updated environment '${name}'`);
+        }
+        else {
+            console.log(`✓ Added environment '${name}'`);
+        }
+        console.log(`  URL: ${options.baseUrl}`);
+        // Show if this was set as default
+        const updatedState = await loadState();
+        if (updatedState.defaultEnvironment === name && !isUpdate) {
+            console.log("  (set as default - first environment)");
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Remove an environment
+ */
+export async function executeEnvRemove(name) {
+    try {
+        const state = await loadState();
+        // Check if environment exists
+        if (!(name in state.environments)) {
+            console.error(`Error: Environment '${name}' does not exist`);
+            console.log("");
+            console.log("Available environments:");
+            Object.keys(state.environments).forEach((env) => {
+                console.log(`  - ${env}`);
+            });
+            process.exit(1);
+        }
+        // Warn if there are plans in this environment
+        const planCount = state.plans[name]?.length || 0;
+        if (planCount > 0) {
+            console.log(`Warning: Environment '${name}' has ${planCount} synced plan(s).`);
+            console.log("This will remove all plan state for this environment.");
+            console.log("");
+        }
+        await removeEnvironment(name);
+        console.log(`✓ Removed environment '${name}'`);
+        // Show new default if it changed
+        const updatedState = await loadState();
+        if (updatedState.defaultEnvironment &&
+            updatedState.defaultEnvironment !== name) {
+            console.log(`  New default: ${updatedState.defaultEnvironment}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Set default environment
+ */
+export async function executeEnvDefault(name) {
+    try {
+        const state = await loadState();
+        // Check if environment exists
+        if (!(name in state.environments)) {
+            console.error(`Error: Environment '${name}' does not exist`);
+            console.log("");
+            console.log("Available environments:");
+            Object.keys(state.environments).forEach((env) => {
+                console.log(`  - ${env}`);
+            });
+            process.exit(1);
+        }
+        await setDefaultEnvironment(name);
+        console.log(`✓ Set '${name}' as default environment`);
+        console.log("");
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}

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/generate-key.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate a cryptographically secure API key for griffin-runner authentication.
+ *
+ * The key format is: grfn_sk_<48-character-hex-string>
+ * - grfn: Griffin prefix
+ * - sk: Secret Key
+ * - 48 hex chars: 24 random bytes = 192 bits of entropy
+ */
+export declare function executeGenerateKey(): Promise<void>;