@griffin-app/griffin-cli 1.0.4 → 1.0.6

package/dist/core/apply.js

@@ -1,11 +1,10 @@
-import { loadVariables } from "./variables.js";
-import { resolvePlan } from "../resolve.js";
 import { terminal } from "../utils/terminal.js";
+import { withSDKErrorHandling } from "../utils/sdk-error.js";
 /**
  * Apply diff actions to the hub.
  * CLI injects both project and environment into plan payloads.
  */
-export async function applyDiff(diff, sdk, projectId, environment, options) {
+export async function applyDiff(diff, sdk, options) {
     const applied = [];
     const errors = [];
     // Filter out noop actions
@@ -22,10 +21,10 @@ export async function applyDiff(diff, sdk, projectId, environment, options) {
             }
             switch (action.type) {
                 case "create":
-                    await applyCreate(action, sdk, projectId, environment, applied);
+                    await applyCreate(action, sdk, applied);
                     break;
                 case "update":
-                    await applyUpdate(action, sdk, projectId, environment, applied);
+                    await applyUpdate(action, sdk, applied);
                     break;
                 case "delete":
                     await applyDelete(action, sdk, applied);
@@ -55,10 +54,10 @@ export async function applyDiff(diff, sdk, projectId, environment, options) {
 /**
  * Apply a create action
  */
-async function applyCreate(action, sdk, projectId, environment, applied) {
-    const plan = action.plan;
-    const variables = await loadVariables(environment);
-    const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
+async function applyCreate(action, sdk, applied) {
+    const resolvedPlan = action.plan;
+    //const variables = await loadVariables(environment);
+    //const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
     const { data: createdPlan } = await sdk.postPlan({
         body: resolvedPlan,
     });
@@ -72,35 +71,35 @@ async function applyCreate(action, sdk, projectId, environment, applied) {
 /**
  * Apply an update action
  */
-async function applyUpdate(action, sdk, projectId, environment, applied) {
-    const plan = action.plan;
-    const remotePlan = action.remotePlan;
-    const variables = await loadVariables(environment);
-    const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
+async function applyUpdate(action, sdk, applied) {
+    const resolvedPlan = action.plan;
+    //const remotePlan = action.remotePlan!;
+    //const variables = await loadVariables(environment);
+    //const resolvedPlan = resolvePlan(plan, projectId, environment, variables);
     // Use the remote plan's ID for the update
     await sdk.putPlanById({
         path: {
-            id: remotePlan.id,
+            id: action.remotePlan.id,
         },
         body: resolvedPlan,
     });
     applied.push({
         type: "update",
-        planName: plan.name,
+        planName: action.remotePlan.name,
         success: true,
     });
-    terminal.success(`Updated: ${terminal.colors.cyan(plan.name)}`);
+    terminal.success(`Updated: ${terminal.colors.cyan(action.remotePlan.name)}`);
 }
 /**
  * Apply a delete action
  */
 async function applyDelete(action, sdk, applied) {
     const remotePlan = action.remotePlan;
-    await sdk.deletePlanById({
+    await withSDKErrorHandling(() => sdk.deletePlanById({
         path: {
             id: remotePlan.id,
         },
-    });
+    }), `Failed to delete plan "${remotePlan.name}"`);
     applied.push({
         type: "delete",
         planName: remotePlan.name,

package/dist/core/apply.test.js

@@ -20,7 +20,7 @@ describe("applyDiff", () => {
             summary: { creates: 0, updates: 0, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {};
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "test");
+        const result = await applyDiff(diff, mockPlanApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(0);
         expect(result.errors).toHaveLength(0);
@@ -39,7 +39,7 @@ describe("applyDiff", () => {
             summary: { creates: 0, updates: 0, deletes: 0, noops: 1 },
         };
         const mockPlanApi = {};
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "test");
+        const result = await applyDiff(diff, mockPlanApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(0);
     });
@@ -57,11 +57,11 @@ describe("applyDiff", () => {
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {
-            planPost: vi.fn().mockResolvedValue({
+            postPlan: vi.fn().mockResolvedValue({
                 data: { data: { ...plan, id: "created-id" } },
             }),
         };
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "staging");
+        const result = await applyDiff(diff, mockPlanApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(1);
         expect(result.applied[0].type).toBe("create");
@@ -69,9 +69,11 @@ describe("applyDiff", () => {
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with injected project and environment
         expect(mockPlanApi.postPlan).toHaveBeenCalledWith(expect.objectContaining({
-            name: "new-plan",
-            project: "project-id",
-            environment: "staging",
+            body: expect.objectContaining({
+                name: "new-plan",
+                project: "test-project",
+                environment: "test",
+            }),
         }));
     });
     it("should apply update action", async () => {
@@ -93,17 +95,22 @@ describe("applyDiff", () => {
                 data: { data: remotePlan },
             }),
         };
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "production");
+        const result = await applyDiff(diff, mockPlanApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(1);
         expect(result.applied[0].type).toBe("update");
         expect(result.applied[0].planName).toBe("existing-plan");
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with the remote plan's ID
-        expect(mockPlanApi.putPlanById).toHaveBeenCalledWith("remote-id", expect.objectContaining({
-            name: "existing-plan",
-            project: "project-id",
-            environment: "production",
+        expect(mockPlanApi.putPlanById).toHaveBeenCalledWith(expect.objectContaining({
+            body: expect.objectContaining({
+                name: "existing-plan",
+                project: "test-project",
+                environment: "test",
+            }),
+            path: {
+                id: "remote-id",
+            },
         }));
     });
     it("should apply delete action", async () => {
@@ -115,14 +122,18 @@ describe("applyDiff", () => {
         const mockPlanApi = {
             deletePlanById: vi.fn().mockResolvedValue({}),
         };
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "test");
+        const result = await applyDiff(diff, mockPlanApi);
         expect(result.success).toBe(true);
         expect(result.applied).toHaveLength(1);
         expect(result.applied[0].type).toBe("delete");
         expect(result.applied[0].planName).toBe("old-plan");
         expect(result.applied[0].success).toBe(true);
         // Verify the API was called with the remote plan's ID
-        expect(mockPlanApi.deletePlanById).toHaveBeenCalledWith(remotePlan.id);
+        expect(mockPlanApi.deletePlanById).toHaveBeenCalledWith({
+            path: {
+                id: remotePlan.id,
+            },
+        });
     });
     it("should handle errors gracefully", async () => {
         const plan = createPlan("failing-plan");
@@ -140,7 +151,7 @@ describe("applyDiff", () => {
         const mockPlanApi = {
             postPlan: vi.fn().mockRejectedValue(new Error("API Error")),
         };
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "test");
+        const result = await applyDiff(diff, mockPlanApi);
         expect(result.success).toBe(false);
         expect(result.errors).toHaveLength(1);
         expect(result.applied).toHaveLength(1);
@@ -161,9 +172,9 @@ describe("applyDiff", () => {
             summary: { creates: 1, updates: 0, deletes: 0, noops: 0 },
         };
         const mockPlanApi = {
-            planPost: vi.fn(),
+            postPlan: vi.fn(),
         };
-        const result = await applyDiff(diff, mockPlanApi, "project-id", "test", {
+        const result = await applyDiff(diff, mockPlanApi, {
             dryRun: true,
         });
         expect(result.success).toBe(true);

package/dist/core/credentials.d.ts

@@ -0,0 +1,36 @@
+import { type CredentialsFile, HubCredentials } from "../schemas/credentials.js";
+export declare const CREDENTIALS_DIR = ".griffin";
+export declare const CREDENTIALS_FILE = "credentials.json";
+/**
+ * Get the user-level credentials directory path (~/.griffin)
+ */
+export declare function getCredentialsDirPath(): string;
+/**
+ * Get the credentials file path
+ */
+export declare function getCredentialsFilePath(): string;
+/**
+ * Check if credentials file exists
+ */
+export declare function credentialsExist(): Promise<boolean>;
+/**
+ * Load credentials file from disk
+ * Returns empty credentials if file doesn't exist
+ */
+export declare function loadCredentials(): Promise<CredentialsFile>;
+/**
+ * Save credentials file to disk with restricted permissions
+ */
+export declare function saveCredentials(credentials: CredentialsFile): Promise<void>;
+/**
+ * Save hub credentials (token from login or API key from connect)
+ */
+export declare function saveHubCredentials(token: string): Promise<void>;
+/**
+ * Get credentials for a specific hub URL
+ */
+export declare function getHubCredentials(): Promise<HubCredentials | undefined>;
+/**
+ * Remove credentials for a specific hub URL
+ */
+export declare function removeHubCredentials(): Promise<void>;

package/dist/core/credentials.js

@@ -0,0 +1,98 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { Value } from "typebox/value";
+import { CredentialsFileSchema, createEmptyCredentials, } from "../schemas/credentials.js";
+export const CREDENTIALS_DIR = ".griffin";
+export const CREDENTIALS_FILE = "credentials.json";
+/**
+ * Get the user-level credentials directory path (~/.griffin)
+ */
+export function getCredentialsDirPath() {
+    return path.join(os.homedir(), CREDENTIALS_DIR);
+}
+/**
+ * Get the credentials file path
+ */
+export function getCredentialsFilePath() {
+    return path.join(getCredentialsDirPath(), CREDENTIALS_FILE);
+}
+/**
+ * Check if credentials file exists
+ */
+export async function credentialsExist() {
+    try {
+        await fs.access(getCredentialsFilePath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load credentials file from disk
+ * Returns empty credentials if file doesn't exist
+ */
+export async function loadCredentials() {
+    const credentialsFilePath = getCredentialsFilePath();
+    try {
+        const content = await fs.readFile(credentialsFilePath, "utf-8");
+        const data = JSON.parse(content);
+        // Validate schema
+        if (Value.Check(CredentialsFileSchema, data)) {
+            return data;
+        }
+        // Invalid schema
+        const errors = [...Value.Errors(CredentialsFileSchema, data)];
+        throw new Error(`Invalid credentials file schema:\n${errors.map((e) => `  - ${e.path || "unknown"}: ${e.message}`).join("\n")}`);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            // File doesn't exist, return empty credentials
+            return createEmptyCredentials();
+        }
+        throw error;
+    }
+}
+/**
+ * Save credentials file to disk with restricted permissions
+ */
+export async function saveCredentials(credentials) {
+    const credentialsDirPath = getCredentialsDirPath();
+    const credentialsFilePath = getCredentialsFilePath();
+    // Ensure directory exists
+    await fs.mkdir(credentialsDirPath, { recursive: true });
+    // Validate before saving
+    if (!Value.Check(CredentialsFileSchema, credentials)) {
+        const errors = [...Value.Errors(CredentialsFileSchema, credentials)];
+        throw new Error(`Invalid credentials data:\n${errors.map((e) => `  - ${e.path || "unknown"}: ${e.message}`).join("\n")}`);
+    }
+    // Write with pretty formatting and restricted permissions (0600 - read/write for owner only)
+    await fs.writeFile(credentialsFilePath, JSON.stringify(credentials, null, 2), { encoding: "utf-8", mode: 0o600 });
+}
+/**
+ * Save hub credentials (token from login or API key from connect)
+ */
+export async function saveHubCredentials(token) {
+    const credentials = await loadCredentials();
+    credentials.hub = {
+        token,
+        updatedAt: new Date().toISOString(),
+    };
+    await saveCredentials(credentials);
+}
+/**
+ * Get credentials for a specific hub URL
+ */
+export async function getHubCredentials() {
+    const credentials = await loadCredentials();
+    return credentials.hub;
+}
+/**
+ * Remove credentials for a specific hub URL
+ */
+export async function removeHubCredentials() {
+    const credentials = await loadCredentials();
+    delete credentials.hub;
+    await saveCredentials(credentials);
+}

package/dist/core/credentials.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/credentials.test.js

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { loadCredentials, saveCredentials, saveHubCredentials, getHubCredentials, removeHubCredentials, } from "./credentials.js";
+import { createEmptyCredentials } from "../schemas/credentials.js";
+const TEST_DIR = path.join(os.tmpdir(), `griffin-test-${Date.now()}`);
+const TEST_CREDS_FILE = path.join(TEST_DIR, "credentials.json");
+// Mock the credentials directory to use test directory
+const originalHomedir = os.homedir;
+describe("Credentials Management", () => {
+    beforeEach(async () => {
+        // Create test directory
+        await fs.mkdir(TEST_DIR, { recursive: true });
+        // Mock homedir to point to test directory
+        os.homedir = () => TEST_DIR;
+    });
+    afterEach(async () => {
+        // Restore original homedir
+        os.homedir = originalHomedir;
+        // Clean up test directory
+        await fs.rm(TEST_DIR, { recursive: true, force: true });
+    });
+    describe("createEmptyCredentials", () => {
+        it("should create empty credentials structure", () => {
+            const creds = createEmptyCredentials();
+            expect(creds).toEqual({
+                version: 1,
+            });
+        });
+    });
+    describe("loadCredentials", () => {
+        it("should return empty credentials if file doesn't exist", async () => {
+            const creds = await loadCredentials();
+            expect(creds).toEqual(createEmptyCredentials());
+        });
+        it("should load existing credentials from file", async () => {
+            const testCreds = createEmptyCredentials();
+            testCreds.hub = {
+                token: "test-token",
+                updatedAt: new Date().toISOString(),
+            };
+            await saveCredentials(testCreds);
+            const loaded = await loadCredentials();
+            expect(loaded).toEqual(testCreds);
+        });
+        it("should throw error for invalid schema", async () => {
+            const invalidCreds = { invalid: "data" };
+            await fs.mkdir(path.join(TEST_DIR, ".griffin"), { recursive: true });
+            await fs.writeFile(path.join(TEST_DIR, ".griffin", "credentials.json"), JSON.stringify(invalidCreds));
+            await expect(loadCredentials()).rejects.toThrow("Invalid credentials file schema");
+        });
+    });
+    describe("saveHubCredentials", () => {
+        it("should save credentials for a hub", async () => {
+            const token = "test-token-123";
+            await saveHubCredentials(token);
+            const creds = await loadCredentials();
+            expect(creds.hub).toBeDefined();
+            expect(creds.hub.token).toBe(token);
+            expect(creds.hub.updatedAt).toBeDefined();
+        });
+        it("should normalize hub URL by removing trailing slash", async () => {
+            const token = "test-token";
+            await saveHubCredentials(token);
+            const creds = await loadCredentials();
+            expect(creds.hub).toBeDefined();
+            expect(creds.hub.token).toBe(token);
+        });
+        it("should update existing hub credentials", async () => {
+            const token1 = "token-1";
+            const token2 = "token-2";
+            await saveHubCredentials(token1);
+            const creds1 = await loadCredentials();
+            const updatedAt1 = creds1.hub.updatedAt;
+            // Wait a bit to ensure different timestamp
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            await saveHubCredentials(token2);
+            const creds2 = await loadCredentials();
+            const updatedAt2 = creds2.hub.updatedAt;
+            expect(creds2.hub.token).toBe(token2);
+            expect(updatedAt2).not.toBe(updatedAt1);
+        });
+    });
+    describe("getHubCredentials", () => {
+        it("should return undefined for non-existent hub", async () => {
+            const creds = await getHubCredentials();
+            expect(creds).toBeUndefined();
+        });
+        it("should return credentials for existing hub", async () => {
+            const token = "test-token";
+            await saveHubCredentials(token);
+            const creds = await getHubCredentials();
+            expect(creds).toBeDefined();
+            expect(creds.token).toBe(token);
+        });
+        it("should normalize hub URL when retrieving", async () => {
+            await saveHubCredentials("test-token");
+            const creds = await getHubCredentials();
+            expect(creds).toBeDefined();
+        });
+    });
+    describe("removeHubCredentials", () => {
+        it("should remove credentials for a hub", async () => {
+            const hubUrl = "https://hub.test.com";
+            await saveHubCredentials("test-token");
+            await removeHubCredentials();
+            const creds = await loadCredentials();
+            expect(creds.hub).toBeUndefined();
+        });
+        it("should not affect other hub credentials", async () => {
+            await saveHubCredentials("token1");
+            await saveHubCredentials("token2");
+            await removeHubCredentials();
+            const creds = await loadCredentials();
+            expect(creds.hub).toBeUndefined();
+        });
+    });
+    describe("listHubUrls", () => {
+        it("should return empty array for no hubs", async () => {
+            const creds = await getHubCredentials();
+            expect(creds).toBeUndefined();
+        });
+    });
+    describe("file permissions", () => {
+        it("should create credentials file with 0600 permissions", async () => {
+            const token = "test-token";
+            await saveHubCredentials(token);
+            const credsPath = path.join(TEST_DIR, ".griffin", "credentials.json");
+            const stats = await fs.stat(credsPath);
+            // Check permissions (0600 = owner read/write only)
+            // Note: permissions are platform-dependent, so we check that it's at least restrictive
+            const mode = stats.mode & 0o777;
+            expect(mode).toBe(0o600);
+        });
+    });
+});

package/dist/core/diff.d.ts

@@ -1,10 +1,10 @@
 import type { PlanV1 } from "@griffin-app/griffin-hub-sdk";
-import type { PlanDSL } from "@griffin-app/griffin-ts/types";
 import { type PlanChanges } from "./plan-diff.js";
 export type DiffActionType = "create" | "update" | "delete" | "noop";
+export type ResolvedPlan = Omit<PlanV1, "id">;
 export interface DiffAction {
     type: DiffActionType;
-    plan: PlanDSL | null;
+    plan: ResolvedPlan | null;
     remotePlan: PlanV1 | null;
     reason: string;
     changes?: PlanChanges;
@@ -23,7 +23,8 @@ export interface DiffOptions {
 }
 /**
  * Compute diff between local plans and remote plans (hub is source of truth).
- * Plans are matched by name. The CLI injects environment at apply time.
+ * Local plans should be resolved (variables replaced with actual values) before calling this.
+ * Plans are matched by name.
  *
  * Rules:
  * - CREATE: Plan exists locally but not on hub
@@ -31,7 +32,7 @@ export interface DiffOptions {
  * - DELETE: Plan exists on hub but not locally (only if includeDeletions is true)
  * - NOOP: Plan exists in both with same content
  */
-export declare function computeDiff(localPlans: PlanDSL[], remotePlans: PlanV1[], options: DiffOptions): DiffResult;
+export declare function computeDiff(localPlans: ResolvedPlan[], remotePlans: PlanV1[], options: DiffOptions): DiffResult;
 /**
  * Format diff result as human-readable text with granular changes
  */

package/dist/core/diff.js

@@ -1,7 +1,8 @@
 import { comparePlans } from "./plan-diff.js";
 /**
  * Compute diff between local plans and remote plans (hub is source of truth).
- * Plans are matched by name. The CLI injects environment at apply time.
+ * Local plans should be resolved (variables replaced with actual values) before calling this.
+ * Plans are matched by name.
  *
  * Rules:
  * - CREATE: Plan exists locally but not on hub

package/dist/core/diff.test.js

@@ -14,10 +14,23 @@ function createPlan(name, overrides) {
         ...overrides,
     };
 }
+// Helper to create a resolved plan (without id)
+function createResolvedPlan(name, overrides) {
+    return {
+        name,
+        project: "test-project",
+        environment: "test",
+        version: "1.0",
+        frequency: { every: 5, unit: "MINUTE" },
+        nodes: [],
+        edges: [],
+        ...overrides,
+    };
+}
 describe("computeDiff", () => {
     describe("CREATE actions", () => {
         it("should create action when plan exists locally but not remotely", () => {
-            const local = [createPlan("health-check")];
+            const local = [createResolvedPlan("health-check")];
             const remote = [];
             const result = computeDiff(local, remote, {
                 includeDeletions: false,
@@ -34,7 +47,7 @@ describe("computeDiff", () => {
     describe("UPDATE actions", () => {
         it("should create update action when plan content differs", () => {
             const local = [
-                createPlan("health-check", {
+                createResolvedPlan("health-check", {
                     frequency: { every: 10, unit: "MINUTE" },
                 }),
             ];
@@ -57,9 +70,10 @@ describe("computeDiff", () => {
     });
     describe("NOOP actions", () => {
         it("should create noop action when plan content matches", () => {
-            const plan = createPlan("health-check");
-            const local = [plan];
-            const remote = [{ ...plan }];
+            const resolvedPlan = createResolvedPlan("health-check");
+            const remotePlan = createPlan("health-check");
+            const local = [resolvedPlan];
+            const remote = [remotePlan];
             const result = computeDiff(local, remote, {
                 includeDeletions: false,
             });
@@ -93,11 +107,11 @@ describe("computeDiff", () => {
     describe("Mixed scenarios", () => {
         it("should handle multiple plans with different actions", () => {
             const local = [
-                createPlan("new-plan"),
-                createPlan("updated-plan", {
+                createResolvedPlan("new-plan"),
+                createResolvedPlan("updated-plan", {
                     frequency: { every: 10, unit: "MINUTE" },
                 }),
-                createPlan("unchanged-plan"),
+                createResolvedPlan("unchanged-plan"),
             ];
             const remote = [
                 createPlan("updated-plan", {
@@ -118,7 +132,8 @@ describe("computeDiff", () => {
     });
     describe("Matching by name", () => {
         it("should match plans by name, not by ID", () => {
-            const local = [createPlan("health-check", { id: "local-id-123" })];
+            // Local plans don't have IDs after resolution
+            const local = [createResolvedPlan("health-check")];
             const remote = [createPlan("health-check", { id: "remote-id-456" })];
             const result = computeDiff(local, remote, {
                 includeDeletions: false,

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

@@ -1,6 +1,4 @@
-import type { PlanDSL } from "@griffin-app/griffin-ts/types";
 import { PlanV1 } from "@griffin-app/griffin-hub-sdk";
-import { NodeType } from "@griffin-app/griffin-ts/schema";
 /**
  * Represents a change to a single field
  */
@@ -15,7 +13,7 @@ export interface FieldChange {
 export interface NodeChange {
     type: "add" | "remove" | "modify";
     nodeId: string;
-    nodeType: NodeType.ASSERTION | NodeType.ENDPOINT | NodeType.WAIT;
+    nodeType: "ASSERTION" | "HTTP_REQUEST" | "WAIT";
     summary: string;
     fieldChanges: FieldChange[];
 }
@@ -37,6 +35,7 @@ export interface PlanChanges {
     topLevel: FieldChange[];
 }
 /**
- * Compare two test plans and return granular changes
+ * Compare two test plans and return granular changes.
+ * Local plan should be resolved (variables replaced with actual values).
  */
-export declare function comparePlans(local: PlanDSL, remote: PlanV1): PlanChanges;
+export declare function comparePlans(local: PlanV1, remote: PlanV1): PlanChanges;

package/dist/core/plan-diff.js

@@ -1,7 +1,8 @@
 import objectHash from "object-hash";
 import { NodeType } from "@griffin-app/griffin-ts/schema";
 /**
- * Compare two test plans and return granular changes
+ * Compare two test plans and return granular changes.
+ * Local plan should be resolved (variables replaced with actual values).
  */
 export function comparePlans(local, remote) {
     const nodeChanges = compareNodes(local.nodes, remote.nodes);
@@ -77,14 +78,12 @@ function compareNodes(localNodes, remoteNodes) {
  */
 function getNodeSummary(node) {
     switch (node.type) {
-        case "ENDPOINT":
+        case "HTTP_REQUEST":
             return `${node.method} ${formatValue(node.path)}`;
         case "WAIT":
             return `wait ${node.duration_ms}ms`;
         case "ASSERTION":
             return `${node.assertions.length} assertion(s)`;
-        default:
-            return node.type;
     }
 }
 /**
@@ -117,8 +116,8 @@ function compareNodeFields(local, remote) {
         return changes;
     }
     switch (local.type) {
-        case NodeType.ENDPOINT:
-            compareEndpointFields(local, remote, changes);
+        case NodeType.HTTP_REQUEST:
+            compareHttpRequestFields(local, remote, changes);
             break;
         case NodeType.WAIT:
             compareWaitFields(local, remote, changes);
@@ -130,9 +129,9 @@ function compareNodeFields(local, remote) {
     return changes;
 }
 /**
- * Compare fields specific to Endpoint nodes
+ * Compare fields specific to HttpRequest nodes
  */
-function compareEndpointFields(local, remote, changes) {
+function compareHttpRequestFields(local, remote, changes) {
     const fields = [
         "method",
         "path",