alpic 0.0.0-dev.f19a8ca → 0.0.0-dev.f1adf05

package/dist/__tests__/mock-server.js

@@ -1,8 +1,23 @@
-import { OpenAPIHandler } from "@orpc/openapi/node";
-import { ORPCError, implement } from "@orpc/server";
-import express, {} from "express";
 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 { implement, ORPCError } from "@orpc/server";
+import express, {} from "express";
+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;
@@ -12,9 +27,18 @@ 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,
         };
     }
     async start() {
@@ -22,11 +46,17 @@ export class MockApiServer {
             throw new Error("Server is already running");
         }
         this.configureServer();
+        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 = this.app.listen(0, "127.0.0.1", () => {
+            this.server = https.createServer(httpsOptions, this.app).listen(0, "127.0.0.1", () => {
+                if (!this.server) {
+                    throw new Error("Server is not running");
+                }
                 const address = this.server.address();
                 this.port = address.port;
-                const url = `http://127.0.0.1:${this.port}`;
+                const url = `https://127.0.0.1:${this.port}`;
                 resolve(url);
             });
         });
@@ -44,17 +74,66 @@ export class MockApiServer {
             res.status(200).end();
         });
         this.app.use(express.json());
+        this.app.get("/.well-known/oauth-protected-resource", (_req, res) => {
+            const base = `https://127.0.0.1:${this.port}`;
+            res.status(200).json({
+                resource: "https://api.alpic.ai",
+                authorization_servers: [base],
+                bearer_methods_supported: ["header"],
+                scopes_supported: ["openid", "email", "profile"],
+                resource_documentation: "https://docs.alpic.ai",
+            });
+        });
+        this.app.get("/.well-known/openid-configuration", (_req, res) => {
+            const base = `https://127.0.0.1:${this.port}`;
+            res.status(200).json({
+                issuer: base,
+                userinfo_endpoint: `${base}/oauth2/userInfo`,
+                authorization_endpoint: `${base}/oauth2/authorize`,
+                token_endpoint: `${base}/oauth2/token`,
+                jwks_uri: `${base}/.well-known/jwks.json`,
+            });
+        });
+        this.app.get("/oauth2/userInfo", (req, res) => {
+            const auth = req.headers.authorization;
+            if (!auth?.startsWith("Bearer ")) {
+                res.status(401).json({ error: "Missing or invalid Authorization" });
+                return;
+            }
+            res.status(200).json({
+                sub: "test-sub",
+                email_verified: "true",
+                identities: [],
+                name: "Test User",
+                email: "test@example.com",
+                picture: "",
+                username: "testuser",
+            });
+        });
         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,
                             },
                         ];
                     }),
@@ -65,7 +144,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: [],
@@ -114,7 +195,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;
                     }),
@@ -122,7 +205,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 = {
@@ -160,6 +243,7 @@ export class MockApiServer {
                                 id: productionEnvId,
                                 name: productionEnvName,
                                 mcpServerUrl: `https://mcp-${projectId}.alpic.ai`,
+                                domains: [],
                                 latestDeployment: null,
                             },
                             environments: [
@@ -182,7 +266,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;
@@ -195,7 +281,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 };
@@ -207,7 +295,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`;
@@ -251,21 +341,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",
@@ -273,23 +392,187 @@ export class MockApiServer {
                             authorAvatarUrl: null,
                             startedAt: new Date(),
                             completedAt: null,
+                            deploymentPageUrl: "https://app.alpic.ai/deployments/mock",
                         };
                         this.mockData.deployments.set(deploymentId, deployment);
                         return deployment;
                     }),
                 },
             },
+            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",
+                        });
+                    }),
+                },
+            },
+            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 ?? "",
                         }));
                     }),
                 },
@@ -297,13 +580,16 @@ 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 = {
                                 ...deployment,
                                 status: "deployed",
                                 completedAt: new Date(),
+                                deploymentPageUrl: deployment.deploymentPageUrl ?? null,
                             };
                             this.mockData.deployments.set(input.deploymentId, updatedDeployment);
                             return updatedDeployment;
@@ -315,7 +601,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" }],
@@ -326,7 +621,7 @@ export class MockApiServer {
                 uploadArtifact: {
                     v1: implement(contract.deployments.uploadArtifact.v1).handler(async () => {
                         const token = randomUUID();
-                        const baseUrl = `http://127.0.0.1:${this.port}`;
+                        const baseUrl = `https://127.0.0.1:${this.port}`;
                         const uploadUrl = `${baseUrl}/__mock__upload/${token}`;
                         return {
                             uploadUrl,
@@ -344,7 +639,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, {
@@ -360,6 +660,23 @@ 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,
+        };
+    }
     async stop() {
         return new Promise((resolve, reject) => {
             if (!this.server) {
@@ -398,6 +715,8 @@ export class MockApiServer {
     getLastCall(method, pathPattern) {
         for (let i = this.callHistory.length - 1; i >= 0; i--) {
             const call = this.callHistory[i];
+            if (!call)
+                continue;
             if (method && call.method !== method)
                 continue;
             if (pathPattern) {
@@ -414,6 +733,43 @@ export class MockApiServer {
         }
         return undefined;
     }
+    setTeams(teams) {
+        this.mockData.teams = teams.map((team) => ({
+            ...team,
+            createdAt: new Date(),
+            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;
+    }
     addProject(project) {
         this.mockData.projects.set(project.id, project);
         if (project.productionEnvironment) {