alpic 0.0.0-dev.f2f58a6 → 0.0.0-dev.f330b89

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;
@@ -10,12 +25,17 @@ export class MockApiServer {
     mockData;
     callHistory = [];
     constructor() {
-        this.port;
         this.app = express();
         this.mockData = {
             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(),
         };
     }
     async start() {
@@ -23,11 +43,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);
             });
         });
@@ -45,7 +71,99 @@ export class MockApiServer {
             res.status(200).end();
         });
         this.app.use(express.json());
-        const router = {
+        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 () => {
+                        return [
+                            {
+                                id: "mock-team-id",
+                                name: "Mock Team",
+                                createdAt: new Date(),
+                                hasStripeAccount: false,
+                            },
+                        ];
+                    }),
+                },
+            },
+            analytics: {
+                get: {
+                    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",
+                            });
+                        }
+                        const emptyTimeSeries = {
+                            sessions_count: [],
+                            requests_count: [],
+                            requests_latency_mean: [],
+                            tool_errors: [],
+                            mcp_errors: [],
+                            output_token_mean: [],
+                            task_count: [],
+                        };
+                        return {
+                            metadata: {
+                                startTimestamp: input.startTimestamp,
+                                endTimestamp: input.endTimestamp,
+                                timeZone: input.timeZone,
+                                startDate: new Date(input.startTimestamp),
+                                interval: "1h",
+                            },
+                            timeSeries: emptyTimeSeries,
+                        };
+                    }),
+                },
+            },
             projects: {
                 list: {
                     v1: implement(contract.projects.list.v1).handler(async () => {
@@ -71,7 +189,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;
                     }),
@@ -117,6 +237,7 @@ export class MockApiServer {
                                 id: productionEnvId,
                                 name: productionEnvName,
                                 mcpServerUrl: `https://mcp-${projectId}.alpic.ai`,
+                                domains: [],
                                 latestDeployment: null,
                             },
                             environments: [
@@ -135,27 +256,129 @@ export class MockApiServer {
                         return project;
                     }),
                 },
+                update: {
+                    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",
+                            });
+                        }
+                        if (input.sourceRepository !== undefined) {
+                            project.sourceRepository = input.sourceRepository;
+                        }
+                        this.mockData.projects.set(input.projectId, project);
+                        return project;
+                    }),
+                },
+                delete: {
+                    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",
+                            });
+                        }
+                        this.mockData.projects.delete(input.projectId);
+                        return { success: true };
+                    }),
+                },
             },
             environments: {
+                create: {
+                    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",
+                            });
+                        }
+                        const environmentId = randomUUID();
+                        const mcpServerUrl = `https://mcp-${environmentId}.alpic.ai`;
+                        const createdAt = new Date();
+                        const environment = {
+                            id: environmentId,
+                            name: input.name,
+                            sourceBranch: input.sourceBranch,
+                            mcpServerUrl,
+                            domains: [mcpServerUrl],
+                            createdAt,
+                            projectId: input.projectId,
+                        };
+                        this.mockData.environments.set(environmentId, environment);
+                        this.mockData.projects.set(input.projectId, {
+                            ...project,
+                            environments: [
+                                ...project.environments,
+                                {
+                                    id: environmentId,
+                                    name: input.name,
+                                    sourceBranch: input.sourceBranch,
+                                    mcpServerUrl,
+                                    createdAt,
+                                    projectId: input.projectId,
+                                    latestDeployment: null,
+                                },
+                            ],
+                        });
+                        return {
+                            id: environmentId,
+                            name: input.name,
+                            sourceBranch: input.sourceBranch,
+                            createdAt,
+                            projectId: input.projectId,
+                            urls: [mcpServerUrl],
+                        };
+                    }),
+                },
                 get: {
                     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",
@@ -163,38 +386,197 @@ 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: {
+                info: {
+                    v1: implement(contract.distribution.info.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 };
+                    }),
+                },
+            },
             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",
+                            });
+                        }
+                        let deployments = Array.from(this.mockData.deployments.values());
+                        if (input.environmentId) {
+                            deployments = deployments.filter((deployment) => deployment.environmentId === input.environmentId);
+                        }
+                        if (input.status?.length) {
+                            deployments = deployments.filter((deployment) => input.status.includes(deployment.status));
+                        }
+                        return deployments.map((deployment) => ({
+                            ...deployment,
+                            isCurrent: deployment.status === "deployed",
+                        }));
+                    }),
+                },
                 get: {
                     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" && deployment.startedAt) {
-                            const elapsed = Date.now() - deployment.startedAt.getTime();
-                            if (elapsed > 2000) {
-                                const updatedDeployment = {
-                                    ...deployment,
-                                    status: "deployed",
-                                    completedAt: new Date(),
-                                };
-                                this.mockData.deployments.set(input.deploymentId, updatedDeployment);
-                                return updatedDeployment;
-                            }
+                        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;
                         }
                         return deployment;
                     }),
                 },
+                getLogs: {
+                    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",
+                            });
+                        }
+                        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" }],
+                            hasMoreLogs: false,
+                        };
+                    }),
+                },
                 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,
@@ -204,7 +586,7 @@ export class MockApiServer {
                     }),
                 },
             },
-        };
+        });
         const handler = new OpenAPIHandler(router);
         this.app.use(async (req, res) => {
             const apiCall = {
@@ -212,7 +594,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, {
@@ -266,6 +653,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) {
@@ -282,6 +671,32 @@ export class MockApiServer {
         }
         return undefined;
     }
+    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);
+    }
     addProject(project) {
         this.mockData.projects.set(project.id, project);
         if (project.productionEnvironment) {