@zuplo/cli 7.10.0 → 7.11.1

package/dist/__tests__/integration/test-utils.js

@@ -1,82 +0,0 @@
-import nock from "nock";
-import settings from "../../common/settings.js";
-export const TEST_AUTH_TOKEN = "test-auth-token-123";
-export const TEST_ACCOUNT_NAME = "test-account";
-export const TEST_PROJECT_NAME = "test-project";
-export const TEST_BRANCH_NAME = "main";
-export const TEST_DEPLOYMENT_NAME = "test-deployment";
-export const TEST_API_BASE = settings.ZUPLO_DEVELOPER_API_ENDPOINT;
-export function setupAuthenticatedNock(scope) {
-    return scope.matchHeader("authorization", `Bearer ${TEST_AUTH_TOKEN}`);
-}
-export function setupTestEnvironment() {
-    process.env.ZUPLO_DEVELOPER_API_ENDPOINT =
-        settings.ZUPLO_DEVELOPER_API_ENDPOINT;
-    process.env.ZUPLO_API_KEY = TEST_AUTH_TOKEN;
-    setupAuthenticatedNock(nock(TEST_API_BASE))
-        .get("/v1/who-am-i")
-        .reply(200, { user: "test-user@example.com" })
-        .persist();
-}
-export function cleanupTest() {
-    nock.cleanAll();
-    delete process.env.ZUPLO_DEVELOPER_API_ENDPOINT;
-    delete process.env.ZUPLO_API_KEY;
-}
-export class RequestCapture {
-    requests = [];
-    capture(req, _interceptor, body) {
-        const captured = {
-            method: req.method || "GET",
-            path: req.path || "",
-            headers: this.normalizeHeaders(req.headers || {}),
-        };
-        if (body) {
-            if (typeof body === "string") {
-                try {
-                    captured.body = JSON.parse(body);
-                }
-                catch {
-                    captured.body = "[FormData or non-JSON body]";
-                }
-            }
-            else {
-                captured.body = body;
-            }
-        }
-        this.requests.push(captured);
-    }
-    getRequests() {
-        return [...this.requests];
-    }
-    clear() {
-        this.requests = [];
-    }
-    normalizeHeaders(headers) {
-        const normalized = {};
-        for (const [key, value] of Object.entries(headers)) {
-            const normalizedKey = key.toLowerCase();
-            if (normalizedKey === "authorization") {
-                normalized[normalizedKey] = "[REDACTED]";
-            }
-            else if (normalizedKey === "user-agent") {
-                normalized[normalizedKey] = "[USER_AGENT]";
-            }
-            else if (normalizedKey === "content-length") {
-                normalized[normalizedKey] = "[CONTENT_LENGTH]";
-            }
-            else if (normalizedKey === "host") {
-                normalized[normalizedKey] = "[HOST]";
-            }
-            else if (normalizedKey === "content-type" &&
-                String(value).startsWith("multipart/form-data")) {
-                normalized[normalizedKey] = "multipart/form-data; boundary=[BOUNDARY]";
-            }
-            else {
-                normalized[normalizedKey] = String(value);
-            }
-        }
-        return normalized;
-    }
-}
-//# sourceMappingURL=test-utils.js.map

package/dist/__tests__/integration/test-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../../../src/__tests__/integration/test-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Test utilities for CLI integration tests with nock interceptors\n */\nimport nock from \"nock\";\nimport settings from \"../../common/settings.js\";\n\n// Constants for testing\nexport const TEST_AUTH_TOKEN = \"test-auth-token-123\";\nexport const TEST_ACCOUNT_NAME = \"test-account\";\nexport const TEST_PROJECT_NAME = \"test-project\";\nexport const TEST_BRANCH_NAME = \"main\";\nexport const TEST_DEPLOYMENT_NAME = \"test-deployment\";\n\n// Base API endpoint for tests\nexport const TEST_API_BASE = settings.ZUPLO_DEVELOPER_API_ENDPOINT;\n\n/**\n * Common nock setup for authenticated requests\n */\nexport function setupAuthenticatedNock(scope: nock.Scope): nock.Scope {\n  return scope.matchHeader(\"authorization\", `Bearer ${TEST_AUTH_TOKEN}`);\n}\n\n/**\n * Setup common environment variables for tests\n */\nexport function setupTestEnvironment() {\n  process.env.ZUPLO_DEVELOPER_API_ENDPOINT =\n    settings.ZUPLO_DEVELOPER_API_ENDPOINT;\n\n  process.env.ZUPLO_API_KEY = TEST_AUTH_TOKEN;\n\n  // Add a catch-all for any authentication validation calls\n  setupAuthenticatedNock(nock(TEST_API_BASE))\n    .get(\"/v1/who-am-i\")\n    .reply(200, { user: \"test-user@example.com\" })\n    .persist();\n}\n\n/**\n * Clean up environment and nock after tests\n */\nexport function cleanupTest() {\n  nock.cleanAll();\n\n  delete process.env.ZUPLO_DEVELOPER_API_ENDPOINT;\n\n  delete process.env.ZUPLO_API_KEY;\n}\n\n/**\n * Helper to capture and normalize nock requests for snapshots\n */\nexport interface CapturedRequest {\n  method: string;\n  path: string;\n  headers: Record<string, string>;\n  body?: unknown;\n}\n\ninterface NockRequest {\n  method?: string;\n  path?: string;\n  headers?: Record<string, unknown>;\n}\n\nexport class RequestCapture {\n  private requests: CapturedRequest[] = [];\n\n  capture(req: NockRequest, _interceptor?: unknown, body?: unknown): void {\n    const captured: CapturedRequest = {\n      method: req.method || \"GET\",\n      path: req.path || \"\",\n      headers: this.normalizeHeaders(req.headers || {}),\n    };\n\n    if (body) {\n      if (typeof body === \"string\") {\n        try {\n          captured.body = JSON.parse(body);\n        } catch {\n          // If JSON parsing fails, store as string (e.g., FormData)\n          captured.body = \"[FormData or non-JSON body]\";\n        }\n      } else {\n        captured.body = body;\n      }\n    }\n\n    this.requests.push(captured);\n  }\n\n  getRequests(): CapturedRequest[] {\n    return [...this.requests];\n  }\n\n  clear(): void {\n    this.requests = [];\n  }\n\n  private normalizeHeaders(\n    headers: Record<string, unknown>\n  ): Record<string, string> {\n    const normalized: Record<string, string> = {};\n\n    for (const [key, value] of Object.entries(headers)) {\n      // Normalize header names to lowercase and exclude dynamic values\n      const normalizedKey = key.toLowerCase();\n\n      if (normalizedKey === \"authorization\") {\n        normalized[normalizedKey] = \"[REDACTED]\";\n      } else if (normalizedKey === \"user-agent\") {\n        normalized[normalizedKey] = \"[USER_AGENT]\";\n      } else if (normalizedKey === \"content-length\") {\n        normalized[normalizedKey] = \"[CONTENT_LENGTH]\";\n      } else if (normalizedKey === \"host\") {\n        normalized[normalizedKey] = \"[HOST]\";\n      } else if (\n        normalizedKey === \"content-type\" &&\n        String(value).startsWith(\"multipart/form-data\")\n      ) {\n        normalized[normalizedKey] = \"multipart/form-data; boundary=[BOUNDARY]\";\n      } else {\n        normalized[normalizedKey] = String(value);\n      }\n    }\n\n    return normalized;\n  }\n}\n"]}

package/dist/__tests__/integration/tunnel.integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tunnel.integration.test.d.ts.map

package/dist/__tests__/integration/tunnel.integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tunnel.integration.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/integration/tunnel.integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/integration/tunnel.integration.test.js

@@ -1,486 +0,0 @@
-import nock from "nock";
-import tmp from "tmp";
-import yargs from "yargs/yargs";
-import tunnelCommand from "../../cmds/tunnel/index.js";
-import { cleanupTest, RequestCapture, setupAuthenticatedNock, setupTestEnvironment, TEST_ACCOUNT_NAME, TEST_API_BASE, TEST_AUTH_TOKEN, } from "./test-utils.js";
-async function executeTunnelCommand(subcommand, args) {
-    const yargsInstance = yargs([])
-        .command(tunnelCommand)
-        .help(false)
-        .version(false)
-        .exitProcess(false);
-    const commandArgs = ["tunnel", subcommand];
-    if (args.account) {
-        commandArgs.push("--account", args.account);
-    }
-    if (args["api-key"]) {
-        commandArgs.push("--api-key", args["api-key"]);
-    }
-    if (args["tunnel-name"]) {
-        commandArgs.push("--tunnel-name", args["tunnel-name"]);
-    }
-    if (args["tunnel-id"]) {
-        commandArgs.push("--tunnel-id", args["tunnel-id"]);
-    }
-    return await yargsInstance.parse(commandArgs);
-}
-async function executeTunnelServicesCommand(subcommand, args) {
-    const yargsInstance = yargs([])
-        .command(tunnelCommand)
-        .help(false)
-        .version(false)
-        .exitProcess(false);
-    const commandArgs = ["tunnel", "services", subcommand];
-    if (args.account) {
-        commandArgs.push("--account", args.account);
-    }
-    if (args["api-key"]) {
-        commandArgs.push("--api-key", args["api-key"]);
-    }
-    if (args["tunnel-id"]) {
-        commandArgs.push("--tunnel-id", args["tunnel-id"]);
-    }
-    if (args["configuration-file"]) {
-        commandArgs.push("--configuration-file", args["configuration-file"]);
-    }
-    return await yargsInstance.parse(commandArgs);
-}
-const mockPrintResult = jest.mocked(require("../../common/output.js").printResultToConsoleAndExitGracefully);
-const mockPrintTable = jest.mocked(require("../../common/output.js").printTableToConsoleAndExitGracefully);
-const mockPrintDiagnostics = jest.mocked(require("../../common/output.js").printDiagnosticsToConsole);
-describe("Tunnel Command Integration Tests", () => {
-    let requestCapture;
-    beforeEach(() => {
-        setupTestEnvironment();
-        requestCapture = new RequestCapture();
-        nock.disableNetConnect();
-        jest.clearAllMocks();
-    });
-    afterEach(() => {
-        cleanupTest();
-        requestCapture.clear();
-    });
-    describe("Tunnel Create Command", () => {
-        it("should intercept POST request to create tunnel", async () => {
-            const testTunnelName = "my-test-tunnel";
-            const mockResponse = {
-                id: "tunnel-123",
-                name: testTunnelName,
-                token: "tunnel-token-abc123",
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .reply(201, mockResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("create", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-name": testTunnelName,
-            });
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintTable).toHaveBeenCalledWith(mockResponse);
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-create-requests");
-            const request = capturedRequests[0];
-            expect(request.method).toBe("POST");
-            expect(request.body).toEqual({
-                name: testTunnelName,
-            });
-        });
-        it("should handle tunnel creation error", async () => {
-            const testTunnelName = "invalid-tunnel";
-            const errorResponse = {
-                error: "Bad Request",
-                message: "Tunnel name already exists",
-                statusCode: 400,
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .reply(400, errorResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await expect(executeTunnelCommand("create", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-name": testTunnelName,
-            })).rejects.toThrow("Failed to create tunnel for account");
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintDiagnostics).toHaveBeenCalled();
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-create-error-requests");
-        });
-    });
-    describe("Tunnel List Command", () => {
-        it("should intercept GET request to list tunnels", async () => {
-            const mockResponse = {
-                data: [
-                    { id: "tunnel-123", name: "tunnel-1" },
-                    { id: "tunnel-456", name: "tunnel-2" },
-                ],
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .reply(200, mockResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("list", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-            });
-            expect(scope.isDone()).toBe(true);
-            const expectedTable = [
-                { "tunnel-id": "tunnel-123", name: "tunnel-1" },
-                { "tunnel-id": "tunnel-456", name: "tunnel-2" },
-            ];
-            expect(mockPrintTable).toHaveBeenCalledWith(expectedTable);
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-list-requests");
-        });
-        it("should handle empty tunnels list", async () => {
-            const mockResponse = { data: [] };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .reply(200, mockResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("list", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-            });
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintResult).toHaveBeenCalledWith("No tunnels found");
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-list-empty-requests");
-        });
-        it("should handle API error responses", async () => {
-            const errorResponse = {
-                error: "Forbidden",
-                message: "Access denied",
-                statusCode: 403,
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .reply(403, errorResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await expect(executeTunnelCommand("list", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-            })).rejects.toThrow("Failed to list tunnels for account");
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintDiagnostics).toHaveBeenCalled();
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-list-error-requests");
-        });
-    });
-    describe("Tunnel Delete Command", () => {
-        it("should intercept DELETE request to delete tunnel", async () => {
-            const tunnelId = "test-tunnel-123";
-            const mockTeardownResponse = {
-                id: "teardown-op-456",
-                status: "in-progress",
-            };
-            const mockCompletedTeardown = {
-                id: "teardown-op-456",
-                status: "success",
-                message: "Tunnel deleted successfully",
-            };
-            const deleteScope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .delete(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
-                .reply(200, mockTeardownResponse);
-            const pollScope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/teardown-operations/teardown-op-456`)
-                .reply(200, mockCompletedTeardown);
-            deleteScope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            pollScope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("delete", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            });
-            expect(deleteScope.isDone()).toBe(true);
-            expect(pollScope.isDone()).toBe(true);
-            expect(mockPrintResult).toHaveBeenCalledWith("Tunnel test-tunnel-123 deleted successfully.");
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-delete-requests");
-        });
-        it("should handle tunnel deletion error", async () => {
-            const tunnelId = "nonexistent-tunnel";
-            const errorResponse = {
-                error: "Not Found",
-                message: "Tunnel not found",
-                statusCode: 404,
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .delete(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
-                .reply(404, errorResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await expect(executeTunnelCommand("delete", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            })).rejects.toThrow("Failed to delete tunnel for account");
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintDiagnostics).toHaveBeenCalled();
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-delete-error-requests");
-        });
-    });
-    describe("Tunnel Describe Command", () => {
-        it("should intercept GET request to describe tunnel", async () => {
-            const tunnelId = "test-tunnel-123";
-            const mockTunnelDetails = {
-                id: tunnelId,
-                name: "Test Tunnel",
-                status: "active",
-                endpoint: "https://test-tunnel.zuplo.dev",
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
-                .reply(200, mockTunnelDetails);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("describe", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            });
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintTable).toHaveBeenCalledWith(mockTunnelDetails);
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-describe-requests");
-        });
-        it("should handle tunnel describe error", async () => {
-            const tunnelId = "nonexistent-tunnel";
-            const errorResponse = {
-                error: "Not Found",
-                message: "Tunnel not found",
-                statusCode: 404,
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}`)
-                .reply(404, errorResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await expect(executeTunnelCommand("describe", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            })).rejects.toThrow("Failed to describe tunnel for account");
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintDiagnostics).toHaveBeenCalled();
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-describe-error-requests");
-        });
-    });
-    describe("Tunnel Rotate Token Command", () => {
-        it("should intercept POST request to rotate tunnel token", async () => {
-            const tunnelId = "test-tunnel-123";
-            const mockTokenResponse = {
-                tunnelId: tunnelId,
-                newToken: "new-token-abc123",
-                message: "Token rotated successfully",
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/$rotate-token`)
-                .reply(200, mockTokenResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("rotate-token", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            });
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintTable).toHaveBeenCalledWith(mockTokenResponse);
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-rotate-token-requests");
-        });
-        it("should handle token rotation error", async () => {
-            const tunnelId = "nonexistent-tunnel";
-            const errorResponse = {
-                error: "Forbidden",
-                message: "Access denied",
-                statusCode: 403,
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/$rotate-token`)
-                .reply(403, errorResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await expect(executeTunnelCommand("rotate-token", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            })).rejects.toThrow("Failed to rotate token for tunnel");
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintDiagnostics).toHaveBeenCalled();
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-rotate-token-error-requests");
-        });
-    });
-    describe("Tunnel Services Describe Command", () => {
-        it("should intercept GET request to describe tunnel services", async () => {
-            const tunnelId = "test-tunnel-123";
-            const mockServicesResponse = {
-                tunnelId: tunnelId,
-                services: [
-                    { name: "api-service", port: 3000, status: "running" },
-                    { name: "web-service", port: 8080, status: "running" },
-                ],
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/services-configuration`)
-                .reply(200, mockServicesResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelServicesCommand("describe", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            });
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintResult).toHaveBeenCalledWith(JSON.stringify(mockServicesResponse, null, 2));
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-services-describe-requests");
-        });
-        it("should handle services describe error", async () => {
-            const tunnelId = "nonexistent-tunnel";
-            const errorResponse = {
-                error: "Not Found",
-                message: "Tunnel not found",
-                statusCode: 404,
-            };
-            const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/services-configuration`)
-                .reply(404, errorResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await expect(executeTunnelServicesCommand("describe", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-            })).rejects.toThrow("Failed to describe services for tunnel");
-            expect(scope.isDone()).toBe(true);
-            expect(mockPrintDiagnostics).toHaveBeenCalled();
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-services-describe-error-requests");
-        });
-    });
-    describe("Tunnel Services Update Command", () => {
-        it("should handle services update error due to file not found", async () => {
-            const tunnelId = "test-tunnel-123";
-            const configFile = "/nonexistent/config.json";
-            await expect(executeTunnelServicesCommand("update", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-id": tunnelId,
-                "configuration-file": configFile,
-            })).rejects.toThrow("--configuration-file: File not found:");
-        });
-        it("should handle services update API error", async () => {
-            const tunnelId = "test-tunnel-123";
-            const fs = require("node:fs");
-            const tmpFile = tmp.fileSync({ postfix: ".json" });
-            fs.writeFileSync(tmpFile.fd, '{"services": []}');
-            const tempConfigFile = tmpFile.name;
-            try {
-                const errorResponse = {
-                    error: "Bad Request",
-                    message: "Invalid configuration file",
-                    statusCode: 400,
-                };
-                const scope = setupAuthenticatedNock(nock(TEST_API_BASE))
-                    .put(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels/${tunnelId}/services-configuration`)
-                    .reply(400, errorResponse);
-                scope.on("request", (req, interceptor, body) => {
-                    requestCapture.capture(req, interceptor, body);
-                });
-                await expect(executeTunnelServicesCommand("update", {
-                    account: TEST_ACCOUNT_NAME,
-                    "api-key": TEST_AUTH_TOKEN,
-                    "tunnel-id": tunnelId,
-                    "configuration-file": tempConfigFile,
-                })).rejects.toThrow("Failed to update tunnel for account");
-                expect(scope.isDone()).toBe(true);
-                expect(mockPrintDiagnostics).toHaveBeenCalled();
-                const capturedRequests = requestCapture.getRequests();
-                expect(capturedRequests).toMatchSnapshot("tunnel-services-update-error-requests");
-            }
-            finally {
-                try {
-                    if (tmpFile && typeof tmpFile.removeCallback === "function") {
-                        tmpFile.removeCallback();
-                    }
-                }
-                catch {
-                }
-            }
-        });
-    });
-    describe("Request validation", () => {
-        it("should include correct headers for create request", async () => {
-            const testTunnelName = "test-tunnel";
-            const mockResponse = {
-                id: "tunnel-123",
-                name: testTunnelName,
-                token: "tunnel-token-abc123",
-            };
-            const scope = nock(TEST_API_BASE)
-                .post(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .matchHeader("authorization", `Bearer ${TEST_AUTH_TOKEN}`)
-                .matchHeader("content-type", "application/json")
-                .reply(201, mockResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("create", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-                "tunnel-name": testTunnelName,
-            });
-            expect(scope.isDone()).toBe(true);
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-create-headers-validation");
-        });
-        it("should include correct headers for list request", async () => {
-            const mockResponse = { data: [{ id: "tunnel-123", name: "tunnel-1" }] };
-            const scope = nock(TEST_API_BASE)
-                .get(`/v1/accounts/${TEST_ACCOUNT_NAME}/tunnels`)
-                .matchHeader("authorization", `Bearer ${TEST_AUTH_TOKEN}`)
-                .reply(200, mockResponse);
-            scope.on("request", (req, interceptor, body) => {
-                requestCapture.capture(req, interceptor, body);
-            });
-            await executeTunnelCommand("list", {
-                account: TEST_ACCOUNT_NAME,
-                "api-key": TEST_AUTH_TOKEN,
-            });
-            expect(scope.isDone()).toBe(true);
-            const capturedRequests = requestCapture.getRequests();
-            expect(capturedRequests).toMatchSnapshot("tunnel-list-headers-validation");
-            const request = capturedRequests[0];
-            expect(request.method).toBe("GET");
-            expect(request.body).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=tunnel.integration.test.js.map