alpic 0.0.0-staging.2ab71bc → 0.0.0-staging.2ba052d

package/dist/__tests__/mock-server.js

@@ -1,10 +1,23 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
 import * as https from "node:https";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { contract } from "@alpic-ai/api";
 import { OpenAPIHandler } from "@orpc/openapi/node";
-import { ORPCError, implement } from "@orpc/server";
+import { implement, ORPCError } from "@orpc/server";
 import express, {} from "express";
-import { randomUUID } from "node:crypto";
-import selfsigned from "selfsigned";
-import { contract } from "@alpic-ai/api";
+import { inc as semverInc } from "semver";
+const __testDirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_CERT_PATH = join(__testDirname, "fixtures", "certs", "localhost-cert.pem");
+const FIXTURE_KEY_PATH = join(__testDirname, "fixtures", "certs", "localhost-key.pem");
+function getTlsAssets() {
+    return {
+        key: readFileSync(FIXTURE_KEY_PATH, "utf8"),
+        cert: readFileSync(FIXTURE_CERT_PATH, "utf8"),
+        certPath: FIXTURE_CERT_PATH,
+    };
+}
 export class MockApiServer {
     server = null;
     app;
@@ -14,9 +27,19 @@ export class MockApiServer {
     constructor() {
         this.app = express();
         this.mockData = {
+            teams: null,
             projects: new Map(),
             environments: new Map(),
             deployments: new Map(),
+            environmentVariables: new Map(),
+            runtimeLogs: new Map(),
+            runtimeLogPages: new Map(),
+            deploymentLogPages: new Map(),
+            deploymentLogCallCounts: new Map(),
+            publishedServers: new Map(),
+            beaconGetResponses: [],
+            beaconGetCallCount: 0,
+            playgrounds: new Map(),
         };
     }
     async start() {
@@ -24,8 +47,9 @@ export class MockApiServer {
             throw new Error("Server is already running");
         }
         this.configureServer();
-        const pems = await selfsigned.generate();
-        const httpsOptions = { key: pems.private, cert: pems.cert };
+        const tlsAssets = getTlsAssets();
+        process.env.NODE_EXTRA_CA_CERTS = tlsAssets.certPath;
+        const httpsOptions = { key: tlsAssets.key, cert: tlsAssets.cert };
         return new Promise((resolve) => {
             this.server = https.createServer(httpsOptions, this.app).listen(0, "127.0.0.1", () => {
                 if (!this.server) {
@@ -88,16 +112,29 @@ export class MockApiServer {
             });
         });
         const router = implement(contract).router({
+            tunnels: {
+                getTicket: {
+                    v1: implement(contract.tunnels.getTicket.v1).handler(async () => {
+                        return {
+                            subdomain: "cool-mongoose-123",
+                            ticket: "mock-ticket",
+                            tunnelHost: "tunnel.alpic.dev",
+                        };
+                    }),
+                },
+            },
             teams: {
                 list: {
                     v1: implement(contract.teams.list.v1).handler(async () => {
+                        if (this.mockData.teams) {
+                            return this.mockData.teams;
+                        }
                         return [
                             {
                                 id: "mock-team-id",
                                 name: "Mock Team",
                                 createdAt: new Date(),
                                 hasStripeAccount: false,
-                                hasActiveSubscription: false,
                             },
                         ];
                     }),
@@ -108,7 +145,9 @@ export class MockApiServer {
                     v1: implement(contract.analytics.get.v1).handler(async ({ input }) => {
                         const project = this.mockData.projects.get(input.projectId);
                         if (!project) {
-                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
                         }
                         const emptyTimeSeries = {
                             sessions_count: [],
@@ -134,8 +173,12 @@ export class MockApiServer {
             },
             projects: {
                 list: {
-                    v1: implement(contract.projects.list.v1).handler(async () => {
-                        return Array.from(this.mockData.projects.values()).map((project) => ({
+                    v1: implement(contract.projects.list.v1).handler(async ({ input }) => {
+                        let projects = Array.from(this.mockData.projects.values());
+                        if (input?.teamId) {
+                            projects = projects.filter((project) => project.teamId === input.teamId);
+                        }
+                        return projects.map((project) => ({
                             id: project.id,
                             name: project.name,
                             teamId: project.teamId,
@@ -157,7 +200,9 @@ export class MockApiServer {
                     v1: implement(contract.projects.get.v1).handler(async ({ input }) => {
                         const project = this.mockData.projects.get(input.projectId);
                         if (!project) {
-                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
                         }
                         return project;
                     }),
@@ -165,7 +210,7 @@ export class MockApiServer {
                 create: {
                     v1: implement(contract.projects.create.v1).handler(async ({ input }) => {
                         const projectId = randomUUID();
-                        const teamId = "mock-team-id";
+                        const teamId = input.teamId ?? "mock-team-id";
                         const productionEnvId = randomUUID();
                         const productionEnvName = "production";
                         const project = {
@@ -203,6 +248,7 @@ export class MockApiServer {
                                 id: productionEnvId,
                                 name: productionEnvName,
                                 mcpServerUrl: `https://mcp-${projectId}.alpic.ai`,
+                                domains: [],
                                 latestDeployment: null,
                             },
                             environments: [
@@ -225,7 +271,9 @@ export class MockApiServer {
                     v1: implement(contract.projects.update.v1).handler(async ({ input }) => {
                         const project = this.mockData.projects.get(input.projectId);
                         if (!project) {
-                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
                         }
                         if (input.sourceRepository !== undefined) {
                             project.sourceRepository = input.sourceRepository;
@@ -238,7 +286,9 @@ export class MockApiServer {
                     v1: implement(contract.projects.delete.v1).handler(async ({ input }) => {
                         const project = this.mockData.projects.get(input.projectId);
                         if (!project) {
-                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
                         }
                         this.mockData.projects.delete(input.projectId);
                         return { success: true };
@@ -250,7 +300,9 @@ export class MockApiServer {
                     v1: implement(contract.environments.create.v1).handler(async ({ input }) => {
                         const project = this.mockData.projects.get(input.projectId);
                         if (!project) {
-                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
                         }
                         const environmentId = randomUUID();
                         const mcpServerUrl = `https://mcp-${environmentId}.alpic.ai`;
@@ -294,21 +346,50 @@ export class MockApiServer {
                     v1: implement(contract.environments.get.v1).handler(async ({ input }) => {
                         const environment = this.mockData.environments.get(input.environmentId);
                         if (!environment) {
-                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Environment not found",
+                            });
                         }
                         return environment;
                     }),
                 },
+                getLogs: {
+                    v1: implement(contract.environments.getLogs.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Environment not found",
+                            });
+                        }
+                        const pagedLogs = this.mockData.runtimeLogPages.get(input.environmentId);
+                        const pageIndex = input.nextToken === undefined ? 0 : Number.parseInt(input.nextToken, 10);
+                        const allLogs = pagedLogs === undefined
+                            ? (this.mockData.runtimeLogs.get(input.environmentId) ?? [])
+                            : (pagedLogs[pageIndex] ?? []);
+                        let logs = allLogs;
+                        if (input.level !== undefined) {
+                            const levels = input.level;
+                            logs = allLogs.filter((log) => levels.includes(log.type));
+                        }
+                        const nextToken = pagedLogs === undefined || pageIndex + 1 >= pagedLogs.length ? null : String(pageIndex + 1);
+                        return { logs, nextToken };
+                    }),
+                },
                 deploy: {
                     v1: implement(contract.environments.deploy.v1).handler(async ({ input }) => {
                         const environment = this.mockData.environments.get(input.environmentId);
                         if (!environment) {
-                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Environment not found",
+                            });
                         }
                         const deploymentId = randomUUID();
                         const deployment = {
                             id: deploymentId,
                             status: "ongoing",
+                            environmentId: environment.id,
+                            environmentName: environment.name,
+                            isCurrent: false,
                             sourceRef: environment.sourceBranch,
                             sourceCommitId: randomUUID().slice(0, 7),
                             sourceCommitMessage: "Mock deployment",
@@ -323,17 +404,225 @@ export class MockApiServer {
                     }),
                 },
             },
+            environmentVariables: {
+                list: {
+                    v1: implement(contract.environmentVariables.list.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Environment not found",
+                            });
+                        }
+                        return this.mockData.environmentVariables.get(input.environmentId) ?? [];
+                    }),
+                },
+                create: {
+                    v1: implement(contract.environmentVariables.create.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Environment not found",
+                            });
+                        }
+                        const existing = this.mockData.environmentVariables.get(input.environmentId) ?? [];
+                        const newVars = input.environmentVariables.map((variable) => ({
+                            id: randomUUID(),
+                            key: variable.key,
+                            value: variable.value,
+                            isSecret: variable.isSecret,
+                            createdAt: new Date(),
+                        }));
+                        for (const newVar of newVars) {
+                            if (existing.some((existingVar) => existingVar.key === newVar.key)) {
+                                throw new ORPCError("BAD_REQUEST", {
+                                    message: `Environment variable "${newVar.key}" already exists`,
+                                });
+                            }
+                        }
+                        this.mockData.environmentVariables.set(input.environmentId, [...existing, ...newVars]);
+                        return { success: true };
+                    }),
+                },
+                update: {
+                    v1: implement(contract.environmentVariables.update.v1).handler(async ({ input }) => {
+                        for (const [environmentId, variables] of this.mockData.environmentVariables.entries()) {
+                            const index = variables.findIndex((variable) => variable.id === input.environmentVariableId);
+                            if (index !== -1) {
+                                const updated = variables.map((variable, i) => i === index
+                                    ? {
+                                        ...variable,
+                                        key: input.key,
+                                        value: input.value ?? variable.value,
+                                        isSecret: input.isSecret,
+                                    }
+                                    : variable);
+                                this.mockData.environmentVariables.set(environmentId, updated);
+                                return { success: true };
+                            }
+                        }
+                        throw new ORPCError("NOT_FOUND", {
+                            message: "Environment variable not found",
+                        });
+                    }),
+                },
+                delete: {
+                    v1: implement(contract.environmentVariables.delete.v1).handler(async ({ input }) => {
+                        for (const [environmentId, variables] of this.mockData.environmentVariables.entries()) {
+                            const index = variables.findIndex((variable) => variable.id === input.environmentVariableId);
+                            if (index !== -1) {
+                                this.mockData.environmentVariables.set(environmentId, variables.filter((_, i) => i !== index));
+                                return { success: true };
+                            }
+                        }
+                        throw new ORPCError("NOT_FOUND", {
+                            message: "Environment variable not found",
+                        });
+                    }),
+                },
+            },
+            playground: {
+                get: {
+                    v1: implement(contract.playground.get.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        return (this.mockData.playgrounds.get(input.environmentId) ?? { isPlaygroundEnabled: true, serverMetadata: null });
+                    }),
+                },
+                upsert: {
+                    v1: implement(contract.playground.upsert.v1).handler(async ({ input }) => {
+                        const environment = this.mockData.environments.get(input.environmentId);
+                        if (!environment) {
+                            throw new ORPCError("NOT_FOUND", { message: "Environment not found" });
+                        }
+                        const current = this.mockData.playgrounds.get(input.environmentId) ?? {
+                            isPlaygroundEnabled: true,
+                            serverMetadata: null,
+                        };
+                        const hasMetadataFields = input.name !== undefined ||
+                            input.description !== undefined ||
+                            input.headers !== undefined ||
+                            input.examplePrompts !== undefined;
+                        const updated = {
+                            isPlaygroundEnabled: input.isPlaygroundEnabled ?? current.isPlaygroundEnabled,
+                            serverMetadata: hasMetadataFields
+                                ? {
+                                    name: input.name ?? current.serverMetadata?.name ?? "",
+                                    description: input.description ?? current.serverMetadata?.description ?? "",
+                                    headers: (input.headers ?? current.serverMetadata?.headers ?? []).map((header) => ({
+                                        name: header.name,
+                                        description: header.description,
+                                        isRequired: header.isRequired ?? false,
+                                        isSecret: header.isSecret ?? false,
+                                    })),
+                                    examplePrompts: input.examplePrompts ?? current.serverMetadata?.examplePrompts ?? [],
+                                }
+                                : current.serverMetadata,
+                        };
+                        this.mockData.playgrounds.set(input.environmentId, updated);
+                        return updated;
+                    }),
+                },
+            },
+            distribution: {
+                get: {
+                    v1: implement(contract.distribution.get.v1).handler(async ({ input }) => {
+                        const existing = this.mockData.publishedServers.get(`${input.projectId}:${input.domain}`);
+                        return {
+                            serverFields: existing ?? {
+                                $schema: "https://registry.modelcontextprotocol.io/schemas/1.0/server.json",
+                                name: "",
+                                description: "",
+                            },
+                        };
+                    }),
+                },
+                publish: {
+                    v1: implement(contract.distribution.publish.v1).handler(async ({ input }) => {
+                        const project = this.mockData.projects.get(input.projectId);
+                        if (!project) {
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
+                        }
+                        const key = `${input.projectId}:${input.domain}`;
+                        const existing = this.mockData.publishedServers.get(key);
+                        const version = existing?.version ? (semverInc(existing.version, "patch") ?? "0.0.1") : "0.0.1";
+                        const serverFields = {
+                            $schema: "https://registry.modelcontextprotocol.io/schemas/1.0/server.json",
+                            name: input.domain,
+                            description: input.description,
+                            title: input.title,
+                            version,
+                            ...(input.websiteUrl ? { websiteUrl: input.websiteUrl } : {}),
+                            ...(input.iconSrc ? { icons: [{ src: input.iconSrc }] } : {}),
+                        };
+                        if (!input.dryRun) {
+                            this.mockData.publishedServers.set(key, serverFields);
+                        }
+                        return { serverFields };
+                    }),
+                },
+            },
+            beacon: {
+                create: {
+                    v1: implement(contract.beacon.create.v1).handler(async () => {
+                        return { id: "mock-analysis-id" };
+                    }),
+                },
+                get: {
+                    v1: implement(contract.beacon.get.v1).handler(async () => {
+                        if (this.mockData.beaconGetResponses.length > 0) {
+                            const index = Math.min(this.mockData.beaconGetCallCount, this.mockData.beaconGetResponses.length - 1);
+                            this.mockData.beaconGetCallCount++;
+                            const response = this.mockData.beaconGetResponses[index];
+                            if (!response) {
+                                throw new Error("Missing mocked beacon.get response");
+                            }
+                            return response;
+                        }
+                        return {
+                            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 },
+                            },
+                        };
+                    }),
+                },
+            },
             deployments: {
                 list: {
                     v1: implement(contract.deployments.list.v1).handler(async ({ input }) => {
                         const project = this.mockData.projects.get(input.projectId);
                         if (!project) {
-                            throw new ORPCError("NOT_FOUND", { message: "Project not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Project not found",
+                            });
+                        }
+                        let deployments = Array.from(this.mockData.deployments.values());
+                        if (input.environmentId) {
+                            deployments = deployments.filter((deployment) => deployment.environmentId === input.environmentId);
                         }
-                        return Array.from(this.mockData.deployments.values()).map((deployment) => ({
+                        if (input.status?.length) {
+                            deployments = deployments.filter((deployment) => input.status.includes(deployment.status));
+                        }
+                        return deployments.map((deployment) => ({
                             ...deployment,
                             isCurrent: deployment.status === "deployed",
-                            environmentId: project.productionEnvironment?.id ?? "",
                         }));
                     }),
                 },
@@ -341,7 +630,9 @@ export class MockApiServer {
                     v1: implement(contract.deployments.get.v1).handler(async ({ input }) => {
                         const deployment = this.mockData.deployments.get(input.deploymentId);
                         if (!deployment) {
-                            throw new ORPCError("NOT_FOUND", { message: "Deployment not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Deployment not found",
+                            });
                         }
                         if (deployment.status === "ongoing") {
                             const updatedDeployment = {
@@ -360,7 +651,16 @@ export class MockApiServer {
                     v1: implement(contract.deployments.getLogs.v1).handler(async ({ input }) => {
                         const deployment = this.mockData.deployments.get(input.deploymentId);
                         if (!deployment) {
-                            throw new ORPCError("NOT_FOUND", { message: "Deployment not found" });
+                            throw new ORPCError("NOT_FOUND", {
+                                message: "Deployment not found",
+                            });
+                        }
+                        const pages = this.mockData.deploymentLogPages.get(input.deploymentId);
+                        if (pages !== undefined) {
+                            const callCount = this.mockData.deploymentLogCallCounts.get(input.deploymentId) ?? 0;
+                            const pageIndex = Math.min(callCount, pages.length - 1);
+                            this.mockData.deploymentLogCallCounts.set(input.deploymentId, callCount + 1);
+                            return pages[pageIndex] ?? { logs: [], hasMoreLogs: false };
                         }
                         return {
                             logs: [{ timestamp: new Date(), content: "Mock log entry" }],
@@ -389,7 +689,12 @@ export class MockApiServer {
                 path: req.path,
                 timestamp: new Date(),
             };
-            if (req.body) {
+            if (req.method === "GET") {
+                if (Object.keys(req.query).length > 0) {
+                    apiCall.input = req.query;
+                }
+            }
+            else if (req.body) {
                 apiCall.input = req.body;
             }
             const result = await handler.handle(req, res, {
@@ -405,6 +710,24 @@ export class MockApiServer {
             this.callHistory.push(apiCall);
         });
     }
+    reset() {
+        this.callHistory = [];
+        this.mockData = {
+            teams: null,
+            projects: new Map(),
+            environments: new Map(),
+            deployments: new Map(),
+            environmentVariables: new Map(),
+            runtimeLogs: new Map(),
+            runtimeLogPages: new Map(),
+            deploymentLogPages: new Map(),
+            deploymentLogCallCounts: new Map(),
+            publishedServers: new Map(),
+            beaconGetResponses: [],
+            beaconGetCallCount: 0,
+            playgrounds: new Map(),
+        };
+    }
     async stop() {
         return new Promise((resolve, reject) => {
             if (!this.server) {
@@ -461,6 +784,46 @@ export class MockApiServer {
         }
         return undefined;
     }
+    setTeams(teams) {
+        this.mockData.teams = teams.map((team) => ({
+            ...team,
+            createdAt: new Date("2024-01-01T00:00:00.000Z"),
+            hasStripeAccount: false,
+        }));
+    }
+    addEnvironmentVariables(environmentId, variables) {
+        this.mockData.environmentVariables.set(environmentId, variables);
+    }
+    setRuntimeLogs(environmentId, logs) {
+        this.mockData.runtimeLogs.set(environmentId, logs);
+        this.mockData.runtimeLogPages.delete(environmentId);
+    }
+    setRuntimeLogPages(environmentId, pages) {
+        this.mockData.runtimeLogPages.set(environmentId, pages);
+        this.mockData.runtimeLogs.delete(environmentId);
+    }
+    setPublishedServer(projectId, domain, server) {
+        this.mockData.publishedServers.set(`${projectId}:${domain}`, server);
+    }
+    addDeployments(deployments) {
+        for (const deployment of deployments) {
+            this.mockData.deployments.set(deployment.id, {
+                ...deployment,
+                deploymentPageUrl: null,
+            });
+        }
+    }
+    setDeploymentLogPages(deploymentId, pages) {
+        this.mockData.deploymentLogPages.set(deploymentId, pages);
+        this.mockData.deploymentLogCallCounts.set(deploymentId, 0);
+    }
+    setBeaconGetResponses(responses) {
+        this.mockData.beaconGetResponses = responses;
+        this.mockData.beaconGetCallCount = 0;
+    }
+    setPlayground(environmentId, playground) {
+        this.mockData.playgrounds.set(environmentId, playground);
+    }
     addProject(project) {
         this.mockData.projects.set(project.id, project);
         if (project.productionEnvironment) {