@griffin-app/griffin-cli 1.0.0 → 1.0.2

package/dist/core/state.js

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Value } from "typebox/value";
+import { StateFileSchema, createEmptyState, } from "../schemas/state.js";
+export const STATE_DIR = ".griffin";
+export const STATE_FILE = "state.json";
+/**
+ * Get the state directory path (in current working directory)
+ */
+export function getStateDirPath() {
+    return path.join(process.cwd(), STATE_DIR);
+}
+/**
+ * Get the state file path
+ */
+export function getStateFilePath() {
+    return path.join(getStateDirPath(), STATE_FILE);
+}
+/**
+ * Check if state file exists
+ */
+export async function stateExists() {
+    try {
+        await fs.access(getStateFilePath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load state file from disk
+ * Throws if file doesn't exist or is invalid
+ */
+export async function loadState() {
+    const stateFilePath = getStateFilePath();
+    try {
+        const content = await fs.readFile(stateFilePath, "utf-8");
+        const data = JSON.parse(content);
+        // Check if it's v1
+        if (Value.Check(StateFileSchema, data)) {
+            return data;
+        }
+        // Invalid schema
+        const errors = [...Value.Errors(StateFileSchema, data)];
+        throw new Error(`Invalid state file schema:\n${errors.map((e) => `  - ${e.path || "unknown"}: ${e.message}`).join("\n")}`);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`State file not found. Run 'griffin init' first.\nExpected: ${stateFilePath}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Save state file to disk
+ */
+export async function saveState(state) {
+    const stateDirPath = getStateDirPath();
+    const stateFilePath = getStateFilePath();
+    // Ensure directory exists
+    await fs.mkdir(stateDirPath, { recursive: true });
+    // Validate before saving
+    if (!Value.Check(StateFileSchema, state)) {
+        const errors = [...Value.Errors(StateFileSchema, state)];
+        throw new Error(`Invalid state data:\n${errors.map((e) => `  - ${e.path || "unknown"}: ${e.message}`).join("\n")}`);
+    }
+    // Write with pretty formatting
+    await fs.writeFile(stateFilePath, JSON.stringify(state, null, 2), "utf-8");
+}
+/**
+ * Initialize a new state file
+ */
+export async function initState(projectId) {
+    if (await stateExists()) {
+        throw new Error(`State file already exists: ${getStateFilePath()}\nUse 'griffin plan' to see current state.`);
+    }
+    const state = createEmptyState(projectId);
+    await saveState(state);
+}
+/**
+ * Add or update an environment
+ */
+export async function addEnvironment(name, config) {
+    const state = await loadState();
+    state.environments[name] = config;
+    // Set as default if it's the first environment
+    if (Object.keys(state.environments).length === 1) {
+        state.defaultEnvironment = name;
+    }
+    await saveState(state);
+}
+/**
+ * Remove an environment
+ */
+export async function removeEnvironment(name) {
+    const state = await loadState();
+    if (!(name in state.environments)) {
+        throw new Error(`Environment '${name}' does not exist`);
+    }
+    delete state.environments[name];
+    // Update default if we removed it
+    if (state.defaultEnvironment === name) {
+        const remaining = Object.keys(state.environments);
+        state.defaultEnvironment = remaining.length > 0 ? remaining[0] : undefined;
+    }
+    await saveState(state);
+}
+/**
+ * Set the default environment
+ */
+export async function setDefaultEnvironment(name) {
+    const state = await loadState();
+    if (!(name in state.environments)) {
+        throw new Error(`Environment '${name}' does not exist`);
+    }
+    state.defaultEnvironment = name;
+    await saveState(state);
+}
+/**
+ * Get the current environment name (from flag, env var, or default)
+ */
+export async function resolveEnvironment(envFlag) {
+    const state = await loadState();
+    // Priority: CLI flag > ENV var > default > error
+    const envName = envFlag || process.env.GRIFFIN_ENV || state.defaultEnvironment;
+    if (!envName) {
+        throw new Error("No environment specified. Use --env flag, GRIFFIN_ENV env var, or set a default with 'griffin env default <name>'");
+    }
+    if (!(envName in state.environments)) {
+        throw new Error(`Environment '${envName}' not found. Available: ${Object.keys(state.environments).join(", ")}`);
+    }
+    return envName;
+}
+/**
+ * Get environment configuration
+ */
+export async function getEnvironment(name) {
+    const state = await loadState();
+    if (!(name in state.environments)) {
+        throw new Error(`Environment '${name}' does not exist`);
+    }
+    return state.environments[name];
+}
+/**
+ * Get the project ID
+ */
+export async function getProjectId() {
+    const state = await loadState();
+    return state.projectId;
+}

package/dist/core/variables.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Load variables from variables.yaml for a specific environment.
+ *
+ * @param envName - The environment name to load variables for
+ * @returns Record of variable key-value pairs
+ * @throws Error if variables.yaml doesn't exist or environment not found
+ */
+export declare function loadVariables(envName: string): Promise<Record<string, string>>;
+/**
+ * Recursively walk a plan object and resolve all variable references.
+ *
+ * This function deeply traverses the plan structure, replacing any
+ * { $variable: { key, template? } } objects with resolved string values.
+ *
+ * @param obj - The plan object or value to resolve
+ * @param variables - Map of variable key-value pairs
+ * @returns The plan with all variables resolved to strings
+ */
+export declare function resolveVariablesInPlan(obj: unknown, variables: Record<string, string>): unknown;

package/dist/core/variables.js

@@ -0,0 +1,100 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse } from "yaml";
+/**
+ * Load variables from variables.yaml for a specific environment.
+ *
+ * @param envName - The environment name to load variables for
+ * @returns Record of variable key-value pairs
+ * @throws Error if variables.yaml doesn't exist or environment not found
+ */
+export async function loadVariables(envName) {
+    const yamlPath = path.join(process.cwd(), "variables.yaml");
+    try {
+        const content = await fs.readFile(yamlPath, "utf-8");
+        const config = parse(content);
+        if (!config.environments) {
+            throw new Error(`Invalid variables.yaml: missing "environments" key.\nExpected format:\nenvironments:\n  ${envName}:\n    key: value`);
+        }
+        if (!config.environments[envName]) {
+            const availableEnvs = Object.keys(config.environments);
+            throw new Error(`Environment "${envName}" not found in variables.yaml.\nAvailable environments: ${availableEnvs.join(", ")}`);
+        }
+        return config.environments[envName];
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`variables.yaml not found in ${process.cwd()}.\nCreate one with:\nenvironments:\n  ${envName}:\n    my-variable: my-value`);
+        }
+        throw error;
+    }
+}
+/**
+ * Check if a value is a variable reference.
+ */
+function isVariableRef(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const obj = value;
+    if (!("$variable" in obj) ||
+        typeof obj.$variable !== "object" ||
+        obj.$variable === null) {
+        return false;
+    }
+    const varData = obj.$variable;
+    return (typeof varData.key === "string" &&
+        (varData.template === undefined || typeof varData.template === "string"));
+}
+/**
+ * Resolve a single variable reference to its string value.
+ *
+ * @param varRef - Variable reference to resolve
+ * @param variables - Map of variable key-value pairs
+ * @returns Resolved string value
+ */
+function resolveVariable(varRef, variables) {
+    const { key, template } = varRef.$variable;
+    const value = variables[key];
+    if (value === undefined) {
+        const availableKeys = Object.keys(variables);
+        throw new Error(`Variable "${key}" not found.\nAvailable variables: ${availableKeys.join(", ")}`);
+    }
+    // If no template, return the value directly
+    if (!template) {
+        return value;
+    }
+    // Replace ${key} with the value in the template
+    const placeholder = `\${${key}}`;
+    return template.replace(placeholder, value);
+}
+/**
+ * Recursively walk a plan object and resolve all variable references.
+ *
+ * This function deeply traverses the plan structure, replacing any
+ * { $variable: { key, template? } } objects with resolved string values.
+ *
+ * @param obj - The plan object or value to resolve
+ * @param variables - Map of variable key-value pairs
+ * @returns The plan with all variables resolved to strings
+ */
+export function resolveVariablesInPlan(obj, variables) {
+    // Check if this is a variable reference
+    if (isVariableRef(obj)) {
+        return resolveVariable(obj, variables);
+    }
+    // Recursively process arrays
+    if (Array.isArray(obj)) {
+        return obj.map((item) => resolveVariablesInPlan(item, variables));
+    }
+    // Recursively process objects
+    if (typeof obj === "object" && obj !== null) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = resolveVariablesInPlan(value, variables);
+        }
+        return result;
+    }
+    // Return primitives as-is
+    return obj;
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export type { StateFile, RunnerConfig } from "./schemas/state.js";
+export type { DiscoveredPlan, DiscoveryResult, DiscoveryError, } from "./core/discovery.js";
+export type { DiffAction, DiffResult } from "./core/diff.js";
+export type { ApplyResult, ApplyAction, ApplyError } from "./core/apply.js";
+export { createEmptyState, StateFileSchema, RunnerConfigSchema, } from "./schemas/state.js";
+export { getStateDirPath, getStateFilePath, stateExists, loadState, saveState, initState, addEnvironment, removeEnvironment, setDefaultEnvironment, resolveEnvironment, getEnvironment, } from "./core/state.js";
+export { discoverPlans, formatDiscoveryErrors } from "./core/discovery.js";
+export { computeDiff, formatDiff, formatDiffJson } from "./core/diff.js";
+export { applyDiff, formatApplyResult } from "./core/apply.js";
+export { createSdkClients, injectProjectId } from "./core/sdk.js";
+export { detectProjectId } from "./core/project.js";
+export { executeInit } from "./commands/init.js";
+export { executeValidate } from "./commands/validate.js";
+export { executeGenerateKey } from "./commands/generate-key.js";
+export { executeRunLocal } from "./commands/local/run.js";
+export { executeConnect } from "./commands/hub/connect.js";
+export { executeStatus } from "./commands/hub/status.js";
+export { executeRuns } from "./commands/hub/runs.js";
+export { executePlan } from "./commands/hub/plan.js";
+export { executeApply } from "./commands/hub/apply.js";
+export { executeRun } from "./commands/hub/run.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+// Export core functions
+export { createEmptyState, StateFileSchema, RunnerConfigSchema, } from "./schemas/state.js";
+export { getStateDirPath, getStateFilePath, stateExists, loadState, saveState, initState, addEnvironment, removeEnvironment, setDefaultEnvironment, resolveEnvironment, getEnvironment, } from "./core/state.js";
+export { discoverPlans, formatDiscoveryErrors } from "./core/discovery.js";
+export { computeDiff, formatDiff, formatDiffJson } from "./core/diff.js";
+export { applyDiff, formatApplyResult } from "./core/apply.js";
+export { createSdkClients, injectProjectId } from "./core/sdk.js";
+export { detectProjectId } from "./core/project.js";
+// Export command executors (for programmatic use)
+export { executeInit } from "./commands/init.js";
+export { executeValidate } from "./commands/validate.js";
+export { executeGenerateKey } from "./commands/generate-key.js";
+// Local commands
+export { executeRunLocal } from "./commands/local/run.js";
+// Hub commands
+export { executeConnect } from "./commands/hub/connect.js";
+export { executeStatus } from "./commands/hub/status.js";
+export { executeRuns } from "./commands/hub/runs.js";
+export { executePlan } from "./commands/hub/plan.js";
+export { executeApply } from "./commands/hub/apply.js";
+export { executeRun } from "./commands/hub/run.js";

package/dist/schemas/payload.d.ts

@@ -0,0 +1,6 @@
+import { type TestPlanV1 } from "griffin-hub-sdk";
+/**
+ * Compute a deterministic hash of a plan payload.
+ * Used for change detection.
+ */
+export declare function hashPlanPayload(plan: TestPlanV1): string;

package/dist/schemas/payload.js

@@ -0,0 +1,8 @@
+import objectHash from "object-hash";
+/**
+ * Compute a deterministic hash of a plan payload.
+ * Used for change detection.
+ */
+export function hashPlanPayload(plan) {
+    return objectHash(plan);
+}

package/dist/schemas/state.d.ts

@@ -0,0 +1,43 @@
+import { Type, type Static } from "typebox";
+/**
+ * State file schema for tracking project configuration
+ * Stored in .griffin/state.json
+ *
+ * Note: The hub is now the source of truth for plans.
+ * This file only stores configuration (project, environments, runner connection).
+ */
+export declare const EnvironmentConfigSchema: Type.TObject<{}>;
+export type EnvironmentConfig = Static<typeof EnvironmentConfigSchema>;
+export declare const RunnerConfigSchema: Type.TObject<{
+    baseUrl: Type.TString;
+    apiToken: Type.TOptional<Type.TString>;
+}>;
+export type RunnerConfig = Static<typeof RunnerConfigSchema>;
+export declare const DiscoveryConfigSchema: Type.TObject<{
+    pattern: Type.TOptional<Type.TString>;
+    ignore: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export type DiscoveryConfig = Static<typeof DiscoveryConfigSchema>;
+export declare const StateFileSchema: Type.TObject<{
+    stateVersion: Type.TLiteral<1>;
+    projectId: Type.TString;
+    environments: Type.TRecord<"^.*$", Type.TObject<{}>>;
+    defaultEnvironment: Type.TOptional<Type.TString>;
+    runner: Type.TOptional<Type.TObject<{
+        baseUrl: Type.TString;
+        apiToken: Type.TOptional<Type.TString>;
+    }>>;
+    discovery: Type.TOptional<Type.TObject<{
+        pattern: Type.TOptional<Type.TString>;
+        ignore: Type.TOptional<Type.TArray<Type.TString>>;
+    }>>;
+}>;
+export type StateFile = Static<typeof StateFileSchema>;
+/**
+ * Create an empty state file
+ */
+export declare function createEmptyState(projectId: string): StateFile;
+/**
+ * Create state file with a default local environment
+ */
+export declare function createStateWithDefaultEnv(projectId: string): StateFile;

package/dist/schemas/state.js

@@ -0,0 +1,54 @@
+import { Type } from "typebox";
+/**
+ * State file schema for tracking project configuration
+ * Stored in .griffin/state.json
+ *
+ * Note: The hub is now the source of truth for plans.
+ * This file only stores configuration (project, environments, runner connection).
+ */
+export const EnvironmentConfigSchema = Type.Object({
+// Empty for now - may be used for environment-specific config in the future
+});
+export const RunnerConfigSchema = Type.Object({
+    baseUrl: Type.String(),
+    apiToken: Type.Optional(Type.String()),
+});
+export const DiscoveryConfigSchema = Type.Object({
+    pattern: Type.Optional(Type.String()),
+    ignore: Type.Optional(Type.Array(Type.String())),
+});
+// State schema (hub is source of truth for plans)
+export const StateFileSchema = Type.Object({
+    stateVersion: Type.Literal(1),
+    projectId: Type.String(),
+    // Environment configuration
+    environments: Type.Record(Type.String(), EnvironmentConfigSchema),
+    defaultEnvironment: Type.Optional(Type.String()),
+    // Runner connection (for remote execution)
+    runner: Type.Optional(RunnerConfigSchema),
+    // Discovery settings
+    discovery: Type.Optional(DiscoveryConfigSchema),
+});
+/**
+ * Create an empty state file
+ */
+export function createEmptyState(projectId) {
+    return {
+        stateVersion: 1,
+        projectId,
+        environments: {},
+    };
+}
+/**
+ * Create state file with a default local environment
+ */
+export function createStateWithDefaultEnv(projectId) {
+    return {
+        stateVersion: 1,
+        projectId,
+        environments: {
+            local: {},
+        },
+        defaultEnvironment: "local",
+    };
+}

package/dist/test-discovery.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Discovers test files in __griffin__ directories.
+ */
+export declare function findTestFiles(basePath?: string): string[];

package/dist/test-discovery.js

@@ -0,0 +1,25 @@
+import * as path from "path";
+import { glob } from "glob";
+/**
+ * Discovers test files in __griffin__ directories.
+ */
+export function findTestFiles(basePath = ".") {
+    const absolutePath = path.resolve(basePath);
+    // Find all __griffin__ directories
+    const griffinDirs = findgriffinDirectories(absolutePath);
+    // Find all .ts files in those directories
+    const testFiles = [];
+    for (const griffinDir of griffinDirs) {
+        const tsFiles = findTsFiles(griffinDir);
+        testFiles.push(...tsFiles);
+    }
+    return testFiles;
+}
+function findgriffinDirectories(basePath) {
+    const pattern = path.join(basePath, "**", "__griffin__");
+    return glob.sync(pattern, { absolute: true });
+}
+function findTsFiles(griffinDir) {
+    const pattern = path.join(griffinDir, "*.ts");
+    return glob.sync(pattern, { absolute: true });
+}

package/dist/test-runner.d.ts

@@ -0,0 +1,6 @@
+import "tsx";
+import { ExecutionResult } from "@griffin-app/griffin-plan-executor";
+/**
+ * Runs a TypeScript test file and executes the resulting JSON plan.
+ */
+export declare function runTestFile(filePath: string, envName: string): Promise<ExecutionResult>;

package/dist/test-runner.js

@@ -0,0 +1,59 @@
+import "tsx";
+import { Value } from "typebox/value";
+import { executePlanV1, AxiosAdapter, EnvSecretProvider, SecretProviderRegistry, } from "@griffin-app/griffin-plan-executor";
+import { TestPlanV1Schema } from "@griffin-app/griffin-ts/schema";
+import { Type } from "typebox";
+import { randomUUID } from "crypto";
+import { loadVariables, resolveVariablesInPlan } from "./core/variables.js";
+import { getProjectId } from "./core/state.js";
+const RawTestSchema = Type.Omit(TestPlanV1Schema, [
+    "id",
+    "environment",
+    "project",
+]);
+/**
+ * Runs a TypeScript test file and executes the resulting JSON plan.
+ */
+export async function runTestFile(filePath, envName) {
+    const variables = await loadVariables(envName);
+    const projectId = await getProjectId();
+    const defaultExport = await import(filePath);
+    const rawPlan = defaultExport.default;
+    console.log(`Project ID: ${projectId}`);
+    // Resolve all variable references in the plan
+    const resolvedPlan = resolveVariablesInPlan(rawPlan, variables);
+    const secretRegistry = new SecretProviderRegistry();
+    secretRegistry.register(new EnvSecretProvider());
+    try {
+        const parsedPlan = Value.Parse(RawTestSchema, resolvedPlan);
+        const syntheticPlan = {
+            ...parsedPlan,
+            id: randomUUID(),
+            project: projectId,
+            environment: envName,
+        };
+        const result = await executePlanV1(syntheticPlan, "default-org", {
+            mode: "local",
+            httpClient: new AxiosAdapter(),
+            secretRegistry: secretRegistry,
+        });
+        console.log(JSON.stringify(result, null, 2));
+        return result;
+    }
+    catch (error) {
+        const errors = Value.Errors(RawTestSchema, resolvedPlan);
+        throw new Error(`Invalid plan: ${JSON.stringify([...errors], null, 2)}: ${error}`);
+    }
+}
+//function findWorkspaceRoot(): string {
+//  let current = process.cwd();
+//  while (current !== path.dirname(current)) {
+//    const testCliPath = path.join(current, "griffin-cli");
+//    const testSystemPath = path.join(current, "griffin-ts");
+//    if (fs.existsSync(testCliPath) && fs.existsSync(testSystemPath)) {
+//      return current;
+//    }
+//    current = path.dirname(current);
+//  }
+//  return process.cwd();
+//}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@griffin-app/griffin-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "CLI tool for running and managing griffin API tests",
   "type": "module",
   "main": "dist/index.js",
@@ -23,13 +23,14 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@griffin-app/griffin-hub-sdk": "1.0.1",
+    "@griffin-app/griffin-plan-executor": "0.1.8",
+    "@griffin-app/griffin-ts": "0.1.7",
     "commander": "^12.1.0",
     "glob": "^11.0.0",
-    "griffin": "file:../griffin-ts",
-    "griffin-hub-sdk": "file:../griffin-hub-sdk",
-    "griffin-plan-executor": "file:../griffin-plan-executor",
     "object-hash": "^3.0.0",
-    "typebox": "^1.0.78"
+    "typebox": "^1.0.78",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",