alpic 0.0.0-staging.dfd352e → 0.0.0-staging.e15eef5

package/dist/__tests__/audit.e2e.test.js

@@ -0,0 +1,744 @@
+import { rmSync } from "node:fs";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { MockApiServer } from "./mock-server.js";
+import { buildMockProject, cliSession, createConfigFile, expectSuccessfulApiCall, setupTestDirectory, } from "./utils.js";
+const TEAM_ID = "mock-team-id";
+const PROJECT_ID = "mock-project-id";
+const ENV_ID = "mock-env-id";
+const STAGING_ENV_ID = "staging-env-id";
+const DEPLOYED_DEPLOYMENT = {
+    id: "mock-deployment-id",
+    status: "deployed",
+    sourceCommitId: "abc1234",
+    sourceCommitMessage: "initial deploy",
+    completedAt: new Date(),
+};
+describe("alpic audit (E2E)", () => {
+    let mockServer;
+    let serverUrl;
+    let cwd;
+    let binPath;
+    beforeAll(async () => {
+        mockServer = new MockApiServer();
+        serverUrl = await mockServer.start();
+    });
+    afterAll(async () => {
+        await mockServer.stop();
+    });
+    beforeEach(async () => {
+        mockServer.reset();
+        const setup = await setupTestDirectory();
+        cwd = setup.cwd;
+        binPath = setup.binPath;
+        mockServer.addProject(buildMockProject({
+            projectId: PROJECT_ID,
+            teamId: TEAM_ID,
+            projectName: "my-project",
+            environmentId: ENV_ID,
+            environmentName: "production",
+            latestDeployment: DEPLOYED_DEPLOYMENT,
+        }));
+    });
+    afterEach(() => {
+        if (cwd) {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    describe("standalone mode (--url)", () => {
+        it("runs audit with --url and no project association", async () => {
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            const createCall = mockServer.getLastCall("POST", "/v1/beacon/audits");
+            expectSuccessfulApiCall(createCall, (call) => {
+                expect(call.input).toMatchObject({ targetUrl: "https://example.com/mcp", excludeCategories: ["e2e"] });
+                expect(call.input.projectId).toBeUndefined();
+            });
+        });
+        it("errors when --url and --project-id are both provided", async () => {
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp", "--project-id", PROJECT_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("--url and --project-id cannot be used together");
+            });
+            expect(exitCode).toBe(1);
+        });
+        it("errors when --team-id is used without --url", async () => {
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--team-id", TEAM_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("--team-id can only be used with --url");
+            });
+            expect(exitCode).toBe(1);
+        });
+    });
+    describe("project mode", () => {
+        it("uses linked project config after confirmation", async () => {
+            createConfigFile(cwd, PROJECT_ID, TEAM_ID, "my-project", ENV_ID, "production", "Mock Team");
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Using project config from .alpic");
+                await cli.expect('Run audit for project "my-project"?');
+                await cli.send("");
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            const createCall = mockServer.getLastCall("POST", "/v1/beacon/audits");
+            expectSuccessfulApiCall(createCall, (call) => {
+                expect(call.input).toMatchObject({
+                    teamId: TEAM_ID,
+                    projectId: PROJECT_ID,
+                });
+            });
+        });
+        it("uses linked project config without prompt in --non-interactive mode", async () => {
+            createConfigFile(cwd, PROJECT_ID, TEAM_ID, "my-project", ENV_ID, "production", "Mock Team");
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--non-interactive"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            expect(output).not.toContain("Run audit for project");
+        });
+        it("uses explicit --project-id flag", async () => {
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--project-id", PROJECT_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            expect(output).not.toContain("Using project config from .alpic");
+            const createCall = mockServer.getLastCall("POST", "/v1/beacon/audits");
+            expectSuccessfulApiCall(createCall, (call) => {
+                expect(call.input).toMatchObject({
+                    projectId: PROJECT_ID,
+                    teamId: TEAM_ID,
+                });
+            });
+        });
+        it("prompts for team and project selection in interactive mode without config", async () => {
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Using team");
+                await cli.expect("Choose a project");
+                await cli.send("");
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+        });
+        it("uses --environment-id to audit a specific environment", async () => {
+            const multiEnvProject = {
+                ...buildMockProject({
+                    projectId: PROJECT_ID,
+                    teamId: TEAM_ID,
+                    projectName: "my-project",
+                    environmentId: ENV_ID,
+                    environmentName: "production",
+                    latestDeployment: DEPLOYED_DEPLOYMENT,
+                }),
+                environments: [
+                    {
+                        id: ENV_ID,
+                        name: "production",
+                        sourceBranch: null,
+                        mcpServerUrl: "https://mcp-production.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: DEPLOYED_DEPLOYMENT,
+                    },
+                    {
+                        id: STAGING_ENV_ID,
+                        name: "staging",
+                        sourceBranch: "develop",
+                        mcpServerUrl: "https://mcp-staging.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: null,
+                    },
+                ],
+            };
+            mockServer.addProject(multiEnvProject);
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--project-id", PROJECT_ID, "--environment-id", STAGING_ENV_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            const createCall = mockServer.getLastCall("POST", "/v1/beacon/audits");
+            expectSuccessfulApiCall(createCall, (call) => {
+                expect(call.input).toMatchObject({
+                    targetUrl: "https://mcp-staging.alpic.ai",
+                    projectId: PROJECT_ID,
+                });
+            });
+        });
+        it("errors when --environment-id is used with --url", async () => {
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp", "--environment-id", ENV_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("--environment-id cannot be used with --url");
+            });
+            expect(exitCode).toBe(1);
+        });
+        it("hides projects without successful deployments in interactive selection", async () => {
+            mockServer.reset();
+            mockServer.addProject(buildMockProject({
+                projectId: "deployed-project",
+                teamId: TEAM_ID,
+                projectName: "deployed-project",
+                environmentId: "deployed-env",
+                environmentName: "production",
+                latestDeployment: DEPLOYED_DEPLOYMENT,
+            }));
+            mockServer.addProject(buildMockProject({
+                projectId: "undeployed-project",
+                teamId: TEAM_ID,
+                projectName: "undeployed-project",
+                environmentId: "undeployed-env",
+                environmentName: "production",
+            }));
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Choose a project");
+                await cli.send("");
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            expect(output).toContain("deployed-project");
+            expect(output).not.toContain("undeployed-project");
+        });
+        it("errors when no projects have successful deployments in interactive mode", async () => {
+            mockServer.reset();
+            mockServer.addProject(buildMockProject({
+                projectId: "failed-project",
+                teamId: TEAM_ID,
+                projectName: "failed-project",
+                environmentId: "failed-env",
+                environmentName: "production",
+            }));
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("No projects with a successful deployment found");
+            });
+            expect(exitCode).toBe(1);
+        });
+        it("only shows deployed environments when selecting interactively", async () => {
+            mockServer.reset();
+            const multiEnvProject = {
+                ...buildMockProject({
+                    projectId: PROJECT_ID,
+                    teamId: TEAM_ID,
+                    projectName: "my-project",
+                    environmentId: ENV_ID,
+                    environmentName: "production",
+                    latestDeployment: DEPLOYED_DEPLOYMENT,
+                }),
+                environments: [
+                    {
+                        id: ENV_ID,
+                        name: "production",
+                        sourceBranch: null,
+                        mcpServerUrl: "https://mcp-production.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: DEPLOYED_DEPLOYMENT,
+                    },
+                    {
+                        id: STAGING_ENV_ID,
+                        name: "staging",
+                        sourceBranch: "develop",
+                        mcpServerUrl: "https://mcp-staging.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: null,
+                    },
+                ],
+            };
+            mockServer.addProject(multiEnvProject);
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--project-id", PROJECT_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect('Using environment "production"');
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            expect(output).not.toContain("staging");
+        });
+        it("errors in --non-interactive mode when production environment is not deployed but others are", async () => {
+            mockServer.reset();
+            const multiEnvProject = {
+                ...buildMockProject({
+                    projectId: PROJECT_ID,
+                    teamId: TEAM_ID,
+                    projectName: "my-project",
+                    environmentId: ENV_ID,
+                    environmentName: "production",
+                }),
+                environments: [
+                    {
+                        id: ENV_ID,
+                        name: "production",
+                        sourceBranch: null,
+                        mcpServerUrl: "https://mcp-production.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: null,
+                    },
+                    {
+                        id: STAGING_ENV_ID,
+                        name: "staging",
+                        sourceBranch: "develop",
+                        mcpServerUrl: "https://mcp-staging.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: DEPLOYED_DEPLOYMENT,
+                    },
+                    {
+                        id: "feature-env-id",
+                        name: "feature-x",
+                        sourceBranch: "feature-x",
+                        mcpServerUrl: "https://mcp-feature.alpic.ai",
+                        createdAt: new Date(),
+                        projectId: PROJECT_ID,
+                        latestDeployment: DEPLOYED_DEPLOYMENT,
+                    },
+                ],
+            };
+            mockServer.addProject(multiEnvProject);
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--project-id", PROJECT_ID, "--non-interactive"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Multiple environments found. Use --environment-id to specify which one to audit.");
+            });
+            expect(exitCode).toBe(1);
+        });
+        it("--environment-id bypasses deployment filter and audits an undeployed environment", async () => {
+            mockServer.reset();
+            mockServer.addProject(buildMockProject({
+                projectId: PROJECT_ID,
+                teamId: TEAM_ID,
+                projectName: "my-project",
+                environmentId: ENV_ID,
+                environmentName: "production",
+            }));
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--project-id", PROJECT_ID, "--environment-id", ENV_ID], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            const createCall = mockServer.getLastCall("POST", "/v1/beacon/audits");
+            expectSuccessfulApiCall(createCall, (call) => {
+                expect(call.input).toMatchObject({ projectId: PROJECT_ID });
+            });
+        });
+        it("errors in --non-interactive mode without flags or config", async () => {
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--non-interactive"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Either --url or --project-id is required");
+            });
+            expect(exitCode).toBe(1);
+        });
+    });
+    describe("audit lifecycle", () => {
+        it("polls until audit completes", async () => {
+            const pendingResponse = {
+                id: "mock-analysis-id",
+                targetUrl: "https://example.com/mcp",
+                status: "pending",
+                durationMs: null,
+                createdAt: new Date(),
+                report: null,
+            };
+            const completedResponse = {
+                id: "mock-analysis-id",
+                targetUrl: "https://example.com/mcp",
+                status: "completed",
+                durationMs: 1234,
+                createdAt: new Date(),
+                report: {
+                    schemaVersion: "v20260224",
+                    auditId: "mock-analysis-id",
+                    targetUrl: "https://example.com/mcp",
+                    startedAt: new Date().toISOString(),
+                    completedAt: new Date().toISOString(),
+                    durationMs: 1234,
+                    results: [],
+                    requiresAuth: false,
+                    hasViewSupport: false,
+                    isReadyForPlatform: { chatgpt: true, claudeai: true },
+                },
+            };
+            mockServer.setBeaconGetResponses([pendingResponse, pendingResponse, completedResponse]);
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            const getCalls = mockServer.getCalls("GET", "/v1/beacon/audits");
+            expect(getCalls.length).toBeGreaterThanOrEqual(3);
+        }, 15_000);
+        it("handles failed audit", async () => {
+            mockServer.setBeaconGetResponses([
+                {
+                    id: "mock-analysis-id",
+                    targetUrl: "https://example.com/mcp",
+                    status: "failed",
+                    durationMs: null,
+                    createdAt: new Date(),
+                    report: null,
+                },
+            ]);
+            const { exitCode } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("The audit failed");
+            });
+            expect(exitCode).toBe(1);
+        });
+    });
+    describe("report rendering", () => {
+        it("renders errors and warnings from check results", async () => {
+            mockServer.setBeaconGetResponses([
+                {
+                    id: "mock-analysis-id",
+                    targetUrl: "https://example.com/mcp",
+                    status: "completed",
+                    durationMs: 2000,
+                    createdAt: new Date(),
+                    report: {
+                        schemaVersion: "v20260224",
+                        auditId: "mock-analysis-id",
+                        targetUrl: "https://example.com/mcp",
+                        startedAt: new Date().toISOString(),
+                        completedAt: new Date().toISOString(),
+                        durationMs: 2000,
+                        results: [
+                            {
+                                checkId: "check-pass",
+                                status: "pass",
+                                message: "Server is reachable",
+                                severity: "error",
+                                category: "connectivity",
+                                scope: "server",
+                                durationMs: 100,
+                            },
+                            {
+                                checkId: "check-error",
+                                status: "fail",
+                                message: "Missing tool description",
+                                severity: "error",
+                                category: "tool-metadata",
+                                scope: "server",
+                                durationMs: 50,
+                                hint: { text: "Add a description to your tool" },
+                            },
+                            {
+                                checkId: "check-warning",
+                                status: "fail",
+                                message: "Slow response time",
+                                severity: "warning",
+                                category: "performance",
+                                scope: "server",
+                                durationMs: 200,
+                            },
+                        ],
+                        requiresAuth: false,
+                        hasViewSupport: false,
+                        isReadyForPlatform: { chatgpt: false, claudeai: true },
+                    },
+                },
+            ]);
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(1);
+            expect(output).toContain("1/3");
+            expect(output).toContain("Missing tool description");
+            expect(output).toContain("Add a description to your tool");
+            expect(output).toContain("Slow response time");
+            expect(output).toContain("1 error");
+            expect(output).toContain("1 warning");
+        });
+        it("shows auth required message and skips report when server requires authentication", async () => {
+            mockServer.setBeaconGetResponses([
+                {
+                    id: "mock-analysis-id",
+                    targetUrl: "https://example.com/mcp",
+                    status: "completed",
+                    durationMs: 500,
+                    createdAt: new Date(),
+                    report: {
+                        schemaVersion: "v20260224",
+                        auditId: "mock-analysis-id",
+                        targetUrl: "https://example.com/mcp",
+                        startedAt: new Date().toISOString(),
+                        completedAt: new Date().toISOString(),
+                        durationMs: 500,
+                        results: [
+                            {
+                                checkId: "server-responds",
+                                status: "skip",
+                                message: "Server requires authentication",
+                                skipReason: "The server returned HTTP 401",
+                                severity: "error",
+                                category: "connectivity",
+                                scope: "server",
+                                durationMs: 100,
+                            },
+                        ],
+                        requiresAuth: true,
+                        hasViewSupport: false,
+                        isReadyForPlatform: { chatgpt: false, claudeai: false },
+                    },
+                },
+            ]);
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("requires credentials");
+            });
+            expect(exitCode).toBe(0);
+            expect(output).toContain("requires credentials to connect");
+            expect(output).toContain("all checks have been skipped");
+            expect(output).not.toContain("Beacon Report");
+        });
+    });
+    describe("report snapshot", () => {
+        it("matches snapshot for a report with errors, warnings, and skipped checks", async () => {
+            mockServer.setBeaconGetResponses([
+                {
+                    id: "mock-analysis-id",
+                    targetUrl: "https://example.com/mcp",
+                    status: "completed",
+                    durationMs: 2000,
+                    createdAt: new Date(),
+                    report: {
+                        schemaVersion: "v20260224",
+                        auditId: "mock-analysis-id",
+                        targetUrl: "https://example.com/mcp",
+                        startedAt: "2026-03-01T00:00:00.000Z",
+                        completedAt: "2026-03-01T00:00:02.000Z",
+                        durationMs: 2000,
+                        results: [
+                            {
+                                checkId: "connectivity-check",
+                                status: "pass",
+                                message: "Server is reachable",
+                                severity: "error",
+                                category: "connectivity",
+                                scope: "server",
+                                durationMs: 100,
+                            },
+                            {
+                                checkId: "tool-description-check",
+                                status: "fail",
+                                message: "Missing tool description",
+                                severity: "error",
+                                category: "tool-metadata",
+                                scope: "server",
+                                durationMs: 50,
+                                hint: { text: "Add a description to your tool" },
+                            },
+                            {
+                                checkId: "response-time-check",
+                                status: "fail",
+                                message: "Slow response time",
+                                severity: "warning",
+                                category: "performance",
+                                scope: "server",
+                                durationMs: 200,
+                            },
+                            {
+                                checkId: "view-check",
+                                status: "skip",
+                                message: "View support check",
+                                skipReason: "No view resources found",
+                                severity: "info",
+                                category: "resource-metadata",
+                                scope: "view",
+                                durationMs: 0,
+                            },
+                        ],
+                        requiresAuth: false,
+                        hasViewSupport: false,
+                        isReadyForPlatform: { chatgpt: false, claudeai: true },
+                    },
+                },
+            ]);
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(1);
+            const startIdx = output.indexOf("Beacon Report");
+            expect(startIdx).toBeGreaterThanOrEqual(0);
+            expect(output.slice(startIdx)).toMatchSnapshot();
+        });
+        it("matches snapshot for a clean report with all checks passed", async () => {
+            mockServer.setBeaconGetResponses([
+                {
+                    id: "mock-analysis-id",
+                    targetUrl: "https://example.com/mcp",
+                    status: "completed",
+                    durationMs: 500,
+                    createdAt: new Date(),
+                    report: {
+                        schemaVersion: "v20260224",
+                        auditId: "mock-analysis-id",
+                        targetUrl: "https://example.com/mcp",
+                        startedAt: "2026-03-01T00:00:00.000Z",
+                        completedAt: "2026-03-01T00:00:00.500Z",
+                        durationMs: 500,
+                        results: [
+                            {
+                                checkId: "connectivity-check",
+                                status: "pass",
+                                message: "Server is reachable",
+                                severity: "error",
+                                category: "connectivity",
+                                scope: "server",
+                                durationMs: 100,
+                            },
+                            {
+                                checkId: "tool-description-check",
+                                status: "pass",
+                                message: "Tool descriptions are present",
+                                severity: "error",
+                                category: "tool-metadata",
+                                scope: "server",
+                                durationMs: 50,
+                            },
+                        ],
+                        requiresAuth: false,
+                        hasViewSupport: false,
+                        isReadyForPlatform: { chatgpt: true, claudeai: true },
+                    },
+                },
+            ]);
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("Beacon Report");
+            });
+            expect(exitCode).toBe(0);
+            const startIdx = output.indexOf("Beacon Report");
+            expect(startIdx).toBeGreaterThanOrEqual(0);
+            expect(output.slice(startIdx)).toMatchSnapshot();
+        });
+    });
+    describe("output", () => {
+        it("outputs JSON with --json flag", async () => {
+            const { exitCode, output } = await cliSession(process.execPath, [binPath, "audit", "--url", "https://example.com/mcp", "--json"], {
+                cwd,
+                env: {
+                    ALPIC_API_BASE_URL: serverUrl,
+                    ALPIC_API_KEY: "test-api-key",
+                },
+            }, async (cli) => {
+                await cli.expect("schemaVersion");
+            });
+            expect(exitCode).toBe(0);
+            expect(output).toContain('"schemaVersion"');
+            expect(output).not.toContain("Beacon Report");
+        });
+    });
+});
+//# sourceMappingURL=audit.e2e.test.js.map