@devmotion/cli 0.6.3 → 0.7.0

package/studio/server/chunks/_server.ts-BsgeMvN0.js

@@ -0,0 +1,722 @@
+import { z } from 'zod';
+import { createMcpHandler } from '@vercel/mcp-adapter';
+import './root-DjEsp22s.js';
+import { g as getRequestEvent } from './event-DmhHnWT5.js';
+import './index-Dp2_pJiZ.js';
+import './query-D9bdUhU3.js';
+import { eq, count, and, gte } from 'drizzle-orm';
+import { nanoid } from 'nanoid';
+import { b as buildDesignGuide, U as UngroupLayersInputSchema, G as GroupLayersInputSchema, C as ConfigureProjectInputSchema, R as RemoveLayerInputSchema, a as UpsertLayerInputSchema } from './design-knowledge-D2NUeAAo.js';
+import { m as mutateConfigureProject, a as mutateUngroupLayers, b as mutateGroupLayers, c as mutateRemoveLayer, d as mutateUpsertLayer } from './mutations-CkUdOAoa.js';
+import { a as actionRegistry } from './registry-z2-pQ1Jw.js';
+import { r as runRegisteredAction } from './find-stock-image-DDfrK_rA.js';
+import { a as applyActionResultToData } from './apply-result-DUy8ya08.js';
+import { w as withMcpAuth, a as auth } from './auth-mx1dhuCn.js';
+import './logger-D_UIR1hE.js';
+import './error-codes-JV0gWPqv.js';
+import './index5-DnQzr4da.js';
+import './update-user-B9qlbev8.js';
+import { getPlan } from './plans-BAwNKt6H.js';
+import { c as user, u as userSubscription, B as apiUsageLog, p as project } from './api-Do--xZ9M.js';
+import { i as createFromSchema } from './animation-sOd5R1cE.js';
+import { a as isLocalPreviewMode } from './desktop-mode-Bkebx7Vx.js';
+import { g as getDefaultProject } from './default-project-DZyH--y0.js';
+import './presets-CU-ej2J9.js';
+import { f as fsProjectToProjectData, m as mapBackgroundToFs, a as projectDataToFsLayers } from './html-parser-t3Ydy25K.js';
+import './base-qepI6vHK.js';
+import { a as absoluteUrl } from './urls-CS2EGAfR.js';
+import { r as resolve } from './server2-vs5lBcGY.js';
+import { c as canCreateProject } from './subscription-limits-kr9leRdz.js';
+import { l as loadFsProject } from './fs-project-BxA38YDy.js';
+import { e as editSceneHtml, w as writeSceneHtml } from './html-writer-D8dOWi0D.js';
+import { writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import './index9-D9BBZH26.js';
+import './async-lVJA8xJZ.js';
+import './shared-hgBL35K7.js';
+import './project-layer-yZ50OnjM.js';
+import './branding-5rLT-BvK.js';
+import './media-v9Bq2kuR.js';
+import './index7-BQ6smzme.js';
+import './string-D-2CmEwz.js';
+import './index14-BI5hUdfO.js';
+import '@better-auth/drizzle-adapter';
+import './svelte-kit-CtyY9yok.js';
+import './env-AoZ3P0fg.js';
+import './shared-server-hNytdPP9.js';
+import './onboarding-email-BvuCl7dz.js';
+import 'resend';
+import 'pg-boss';
+import 'mjml';
+import 'html-to-text';
+import 'drizzle-orm/pg-core';
+import './subscription-BC4gCTG6.js';
+import './client2-DNrSxzuu.js';
+import 'drizzle-orm/postgres-js';
+import 'drizzle-orm/pglite';
+import 'postgres';
+import '@electric-sql/pglite';
+import './index8-Dt6GB1aJ.js';
+import 'drizzle-orm/pglite/migrator';
+import 'path';
+import './optional-services-BGRY7tmz.js';
+import './attribute-protocol-DQ-1julf.js';
+import './routing-Up9X2RDi.js';
+
+const mutationTools = {
+  upsert_layer: {
+    description: "Create a layer (omit layerId) or patch-edit an existing one (pass layerId; layer.type must match). Sizes/positions in % of project width. Provide only the fields to set/change.",
+    inputSchema: UpsertLayerInputSchema
+  },
+  remove_layer: {
+    description: "Delete a layer by ID or name.",
+    inputSchema: RemoveLayerInputSchema
+  },
+  configure_project: {
+    description: "Set project name, dimensions, duration, or background.",
+    inputSchema: ConfigureProjectInputSchema
+  },
+  group_layers: {
+    description: "Group multiple layers into a folder.",
+    inputSchema: GroupLayersInputSchema
+  },
+  ungroup_layers: {
+    description: "Dissolve a group; children become top-level.",
+    inputSchema: UngroupLayersInputSchema
+  }
+};
+const err = (text) => ({ isError: true, content: [{ type: "text", text }] });
+const ok = (text) => ({ content: [{ type: "text", text }] });
+function isErr(x) {
+  return "isError" in x;
+}
+function registerDevmotionTools(server, deps) {
+  server.registerTool(
+    "get_design_guide",
+    {
+      description: "DevMotion design guide: motion design playbook, scene archetypes, the full animation preset catalog, and asset rules. Read this BEFORE composing scenes — it is what separates a polished video from a flat one.",
+      inputSchema: z.object({})
+    },
+    () => ok(buildDesignGuide())
+  );
+  server.registerTool(
+    "create_project",
+    {
+      description: "Create a new animation project. In local mode, initialises the open project folder. Tip: call get_design_guide before composing scenes.",
+      inputSchema: z.object({
+        name: z.string().default("Untitled Project"),
+        width: z.number().default(720),
+        height: z.number().default(1280)
+      })
+    },
+    async (input) => {
+      const { name, width, height } = input;
+      const adapter = await deps.resolveAdapter("create_project");
+      if (isErr(adapter)) return adapter;
+      try {
+        const { id } = await adapter.createProject(name, width, height);
+        return ok(
+          `Project created!
+ID: ${id}
+Preview: ${adapter.previewUrl(id)}
+
+Use the project ID in subsequent tool calls.`
+        );
+      } catch (e) {
+        return err(String(e));
+      }
+    }
+  );
+  server.registerTool(
+    "get_project",
+    {
+      description: "Retrieve project state: layers, animations, dimensions, duration.",
+      inputSchema: z.object({
+        projectId: z.string().describe('Project ID from create_project. Use "local" in local mode.')
+      })
+    },
+    async (input) => {
+      const { projectId } = input;
+      const adapter = await deps.resolveAdapter("get_project");
+      if (isErr(adapter)) return adapter;
+      const project2 = await adapter.getProject(projectId);
+      if (!project2) return err(`Project not found: ${projectId}`);
+      const summary = [
+        `Project: ${project2.name}`,
+        `ID: ${projectId}`,
+        `Dimensions: ${project2.width}x${project2.height}`,
+        `Duration: ${project2.duration}s at ${project2.fps} FPS`,
+        `Layers: ${project2.layers.length}`,
+        `Preview: ${adapter.previewUrl(projectId)}`,
+        "",
+        "Layers:"
+      ];
+      project2.layers.forEach((layer, i) => {
+        summary.push(
+          `  ${i + 1}. ${layer.name} (${layer.type}) - ID: ${layer.id} - ${layer.keyframes.length} keyframes`
+        );
+      });
+      return ok(summary.join("\n") + "\n\n" + JSON.stringify(project2, null, 2));
+    }
+  );
+  for (const [name, toolDef] of Object.entries(mutationTools)) {
+    const extendedSchema = toolDef.inputSchema.extend({
+      projectId: z.string().describe('Project ID. Use "local" in local mode.')
+    });
+    server.registerTool(
+      name,
+      { description: toolDef.description, inputSchema: extendedSchema },
+      async (input) => {
+        const adapter = await deps.resolveAdapter(name);
+        if (isErr(adapter)) return adapter;
+        const { projectId, ...toolInput } = input;
+        const project2 = await adapter.getProject(projectId);
+        if (!project2) return err(`Project not found: ${projectId}`);
+        const ctx = { project: project2 };
+        let result;
+        switch (name) {
+          case "upsert_layer":
+            result = mutateUpsertLayer(ctx, toolInput);
+            break;
+          case "remove_layer":
+            result = mutateRemoveLayer(ctx, toolInput);
+            break;
+          case "group_layers":
+            result = mutateGroupLayers(ctx, toolInput);
+            break;
+          case "ungroup_layers":
+            result = mutateUngroupLayers(ctx, toolInput);
+            break;
+          case "configure_project":
+            result = mutateConfigureProject(ctx, toolInput);
+            break;
+          default:
+            return err(`Unknown tool: ${name}`);
+        }
+        if (!(result.success ?? false)) {
+          return err(result.error || result.message || "Operation failed");
+        }
+        await adapter.saveProject(projectId, project2);
+        return ok(JSON.stringify(result, null, 2));
+      }
+    );
+  }
+  if (deps.includeSaasTools && deps.registerSaasTools) {
+    deps.registerSaasTools(server, deps);
+  }
+}
+class FilesystemAdapter {
+  requiresAuth = false;
+  /** The local project has a single implicit ID. */
+  static LOCAL_ID = "local";
+  get projectDir() {
+    const dir = process.env.PUBLIC_LOCAL_PROJECT_DIR;
+    if (!dir) throw new Error("LOCAL_PROJECT_DIR not set");
+    return dir;
+  }
+  async getProject(id) {
+    if (id !== FilesystemAdapter.LOCAL_ID) return null;
+    try {
+      return fsProjectToProjectData(loadFsProject(this.projectDir));
+    } catch {
+      return null;
+    }
+  }
+  async saveProject(_id, data) {
+    const fsProject = loadFsProject(this.projectDir);
+    const config = {
+      version: 1,
+      name: data.name,
+      width: data.width,
+      height: data.height,
+      fps: data.fps,
+      duration: data.duration,
+      background: mapBackgroundToFs(data.background),
+      scenes: fsProject.scenes.map((s) => ({
+        id: s.id,
+        file: s.file,
+        start: s.start,
+        // Single-scene projects: keep the scene duration in sync with the
+        // project duration (so configure_project's duration drives render).
+        duration: fsProject.scenes.length === 1 ? data.duration : s.duration
+      }))
+    };
+    writeFileSync(join(this.projectDir, "devmotion.json"), JSON.stringify(config, null, 2) + "\n");
+    const fsLayers = projectDataToFsLayers(data, fsProject);
+    for (const scene of fsProject.scenes) {
+      const sceneLayers = fsLayers.filter((l) => l.sceneId === scene.id);
+      const scenePath = join(this.projectDir, scene.file);
+      const html = existsSync(scenePath) ? editSceneHtml(readFileSync(scenePath, "utf-8"), sceneLayers, { duration: scene.duration }) : writeSceneHtml(sceneLayers, { duration: scene.duration });
+      writeFileSync(scenePath, html);
+    }
+  }
+  async createProject(name, width, height) {
+    const data = { ...getDefaultProject(), name, width, height };
+    await this.saveProject(FilesystemAdapter.LOCAL_ID, data);
+    return { id: FilesystemAdapter.LOCAL_ID, data };
+  }
+  previewUrl(_id) {
+    return "http://localhost:5173/editor/local";
+  }
+}
+class PostgresAdapter {
+  constructor(db, userId) {
+    this.db = db;
+    this.userId = userId;
+  }
+  requiresAuth = true;
+  async getProject(id) {
+    const row = await this.db.query.project.findFirst({
+      where: and(eq(project.id, id), eq(project.userId, this.userId))
+    });
+    return row ? row.data : null;
+  }
+  async saveProject(id, data) {
+    await this.db.update(project).set({ data, updatedAt: /* @__PURE__ */ new Date() }).where(eq(project.id, id));
+  }
+  async createProject(name, width, height) {
+    const limitCheck = await canCreateProject(this.userId, this.db);
+    if (!limitCheck.allowed) throw new Error(limitCheck.reason ?? "Project limit reached");
+    const id = nanoid();
+    const data = { ...getDefaultProject(), name, width, height };
+    await this.db.insert(project).values({
+      id,
+      name,
+      isPublic: true,
+      isMcp: true,
+      userId: this.userId,
+      data,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return { id, data };
+  }
+  previewUrl(id) {
+    return absoluteUrl(resolve("/(app)/editor/p/[id]", { id }));
+  }
+}
+function getAdapter(locals) {
+  if (isLocalPreviewMode()) {
+    return new FilesystemAdapter();
+  }
+  const userId = locals.user?.id;
+  if (!userId) {
+    return { isError: true, content: [{ type: "text", text: "User not authenticated" }] };
+  }
+  return new PostgresAdapter(locals.db, userId);
+}
+async function enforceMcpLimits(userId, db, endpoint) {
+  const sub = await db.select({ tier: userSubscription.tier }).from(userSubscription).where(eq(userSubscription.userId, userId)).limit(1);
+  const tier = sub[0]?.tier ?? "free";
+  const plan = getPlan(tier);
+  if (!plan.limits.mcpAccess) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: "MCP access is not available on your current plan. Please log in or upgrade at https://devmotion.app/#pricing"
+        }
+      ]
+    };
+  }
+  const maxPerMinute = plan.limits.apiRateLimit;
+  if (maxPerMinute > 0) {
+    const oneMinuteAgo = new Date(Date.now() - 6e4);
+    const [{ count: c }] = await db.select({ count: count() }).from(apiUsageLog).where(and(eq(apiUsageLog.userId, userId), gte(apiUsageLog.createdAt, oneMinuteAgo)));
+    if (c >= maxPerMinute) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Rate limit exceeded. Your plan allows ${maxPerMinute} requests/min. Try again shortly.`
+          }
+        ]
+      };
+    }
+  }
+  db.insert(apiUsageLog).values({
+    id: nanoid(),
+    userId,
+    endpoint: `MCP ${endpoint}`,
+    statusCode: 200,
+    responseTimeMs: null,
+    ipAddress: null
+  }).catch(() => {
+  });
+  return { tier };
+}
+const handler = createMcpHandler(
+  (server) => {
+    registerDevmotionTools(server, {
+      includeSaasTools: false,
+      async resolveAdapter(toolName) {
+        const { locals } = getRequestEvent();
+        const adapter = getAdapter(locals);
+        if ("isError" in adapter) return adapter;
+        if (!isLocalPreviewMode()) {
+          const limitsResult = await enforceMcpLimits(locals.user.id, locals.db, toolName);
+          if ("isError" in limitsResult) return limitsResult;
+        }
+        return adapter;
+      }
+    });
+    for (const [actionId, action] of Object.entries(actionRegistry)) {
+      const toolName = `action_${actionId.replace(/-/g, "_")}`;
+      const needsSourceLayer = action.sourceLayerTypes.length > 0;
+      const actionInputSchema = needsSourceLayer ? action.inputSchema.extend({
+        projectId: z.string().describe("The Project ID containing the source layer."),
+        layerId: z.string().describe("The ID of the source layer to run the action on.")
+      }) : action.inputSchema.extend({
+        projectId: z.string().describe("The Project ID to run the action on.")
+      });
+      server.registerTool(
+        toolName,
+        { description: action.description, inputSchema: actionInputSchema },
+        async (input) => {
+          const { locals } = getRequestEvent();
+          if (isLocalPreviewMode()) {
+            return {
+              isError: true,
+              content: [
+                { type: "text", text: "AI actions are not available in local preview mode." }
+              ]
+            };
+          }
+          const adapter = getAdapter(locals);
+          if ("isError" in adapter) return adapter;
+          const limitsResult = await enforceMcpLimits(locals.user.id, locals.db, toolName);
+          if ("isError" in limitsResult) return limitsResult;
+          const { projectId, layerId, ...actionInput } = input;
+          const projectData = await adapter.getProject(projectId);
+          if (!projectData) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: `Project not found: ${projectId}` }]
+            };
+          }
+          let sourceLayer;
+          if (needsSourceLayer) {
+            if (!layerId)
+              return {
+                isError: true,
+                content: [{ type: "text", text: "layerId is required for this action" }]
+              };
+            sourceLayer = projectData.layers.find((l) => l.id === layerId);
+            if (!sourceLayer)
+              return {
+                isError: true,
+                content: [{ type: "text", text: `Layer not found: ${layerId}` }]
+              };
+          }
+          try {
+            const result = await runRegisteredAction({
+              action,
+              input: createFromSchema(action.inputSchema, actionInput),
+              sourceLayer,
+              project: projectData
+            });
+            applyActionResultToData(projectData, result);
+            await adapter.saveProject(projectId, projectData);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Action "${action.label}" completed.
+Layers added: ${result.layersToAdd?.length ?? 0}
+Layers updated: ${result.layersToUpdate?.length ?? 0}`
+                }
+              ]
+            };
+          } catch (e) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: `Action failed: ${String(e)}` }]
+            };
+          }
+        }
+      );
+    }
+    server.registerTool(
+      "list_tts_voices",
+      {
+        description: "List available text-to-speech voices (name, voiceId, traits). Call before action_generate_speech to pick a voiceId. SaaS only.",
+        inputSchema: z.object({})
+      },
+      async () => {
+        const { locals } = getRequestEvent();
+        if (isLocalPreviewMode())
+          return {
+            isError: true,
+            content: [{ type: "text", text: "TTS is not available in local mode." }]
+          };
+        const adapter = getAdapter(locals);
+        if ("isError" in adapter) return adapter;
+        const limitsResult = await enforceMcpLimits(locals.user.id, locals.db, "list_tts_voices");
+        if ("isError" in limitsResult) return limitsResult;
+        try {
+          const { env } = await import('./env-AoZ3P0fg.js');
+          const apiKey = env.ELEVENLABS_API_KEY;
+          if (!apiKey) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: "TTS service not configured." }]
+            };
+          }
+          const { getTtsVoices } = await import('./tts-voices-B9J2ZzGy.js');
+          const { voiceCatalogSection } = await import('./design-knowledge-D2NUeAAo.js').then((n) => n.f);
+          const voices = await getTtsVoices(apiKey);
+          return { content: [{ type: "text", text: voiceCatalogSection(voices, 50) }] };
+        } catch (e) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to list voices: ${String(e)}` }]
+          };
+        }
+      }
+    );
+    server.registerTool(
+      "upload_media",
+      {
+        description: "Get a presigned S3 URL for direct media upload. SaaS only.",
+        inputSchema: z.object({
+          projectId: z.string(),
+          file_name: z.string(),
+          mime_type: z.string(),
+          file_size: z.number().int().positive(),
+          media_type: z.enum(["image", "video", "audio"]).optional()
+        })
+      },
+      async ({ projectId: _projectId, file_name, mime_type, file_size, media_type }) => {
+        const { locals } = getRequestEvent();
+        if (isLocalPreviewMode())
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "upload_media is not available in local mode. Copy files to assets/ instead."
+              }
+            ]
+          };
+        const adapter = getAdapter(locals);
+        if ("isError" in adapter) return adapter;
+        const limitsResult = await enforceMcpLimits(locals.user.id, locals.db, "upload_media");
+        if ("isError" in limitsResult) return limitsResult;
+        try {
+          const { generatePresignedUpload } = await import('./upload-service-Boi3a_IC.js');
+          const result = await generatePresignedUpload(
+            {
+              fileName: file_name,
+              mimeType: mime_type,
+              size: file_size,
+              mediaTypeHint: media_type
+            },
+            locals.user.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    upload_url: result.uploadUrl,
+                    key: result.key,
+                    file_url: result.fileUrl,
+                    asset_id: result.assetId,
+                    original_name: result.originalName,
+                    media_type: result.mediaType,
+                    instructions: `PUT the file binary to upload_url with Content-Type: ${mime_type}, then call confirm_media_upload with the key and asset_id.`
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        } catch (e) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Upload request failed: ${String(e)}` }]
+          };
+        }
+      }
+    );
+    server.registerTool(
+      "confirm_media_upload",
+      {
+        description: "Confirm a completed presigned upload. SaaS only.",
+        inputSchema: z.object({
+          projectId: z.string(),
+          asset_id: z.string(),
+          key: z.string(),
+          file_url: z.string(),
+          original_name: z.string(),
+          mime_type: z.string(),
+          media_type: z.enum(["image", "video", "audio"]),
+          duration: z.number().nullable().optional()
+        })
+      },
+      async ({
+        projectId: _projectId,
+        asset_id,
+        key,
+        file_url,
+        original_name,
+        mime_type,
+        media_type,
+        duration
+      }) => {
+        const { locals } = getRequestEvent();
+        if (isLocalPreviewMode())
+          return {
+            isError: true,
+            content: [
+              { type: "text", text: "confirm_media_upload is not available in local mode." }
+            ]
+          };
+        const adapter = getAdapter(locals);
+        if ("isError" in adapter) return adapter;
+        const limitsResult = await enforceMcpLimits(
+          locals.user.id,
+          locals.db,
+          "confirm_media_upload"
+        );
+        if ("isError" in limitsResult) return limitsResult;
+        try {
+          const { confirmUpload } = await import('./upload-service-Boi3a_IC.js');
+          const asset = await confirmUpload(
+            {
+              assetId: asset_id,
+              key,
+              fileUrl: file_url,
+              originalName: original_name,
+              mimeType: mime_type,
+              mediaType: media_type,
+              duration
+            },
+            locals.user.id,
+            locals.db
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Asset confirmed!
+${JSON.stringify({ id: asset.id, url: asset.url, key: asset.storageKey, media_type: asset.mediaType, size: asset.size, duration: asset.duration }, null, 2)}
+
+Use asset.url as the src when creating a video/audio/image layer.`
+              }
+            ]
+          };
+        } catch (e) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Confirm failed: ${String(e)}` }]
+          };
+        }
+      }
+    );
+    server.registerTool(
+      "import_media",
+      {
+        description: "Import media from a public URL. SaaS only.",
+        inputSchema: z.object({
+          projectId: z.string(),
+          url: z.string().url(),
+          media_type: z.enum(["image", "video", "audio"]),
+          file_name: z.string().optional()
+        })
+      },
+      async ({ projectId, url, media_type, file_name }) => {
+        const { locals } = getRequestEvent();
+        if (isLocalPreviewMode())
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "import_media is not available in local mode. Copy files to assets/ instead."
+              }
+            ]
+          };
+        const adapter = getAdapter(locals);
+        if ("isError" in adapter) return adapter;
+        const limitsResult = await enforceMcpLimits(locals.user.id, locals.db, "import_media");
+        if ("isError" in limitsResult) return limitsResult;
+        const fileName = file_name ?? url.split("/").pop()?.split("?")[0] ?? `import.${media_type}`;
+        try {
+          const { importFromUrl } = await import('./upload-service-Boi3a_IC.js');
+          const asset = await importFromUrl(
+            { url, fileName, mediaType: media_type, projectId },
+            locals.user.id,
+            locals.db
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Media imported!
+${JSON.stringify({ id: asset.id, url: asset.url, key: asset.storageKey, media_type: asset.mediaType, size: asset.size, duration: asset.duration }, null, 2)}
+
+Use asset.url as the src when creating a video/audio/image layer.`
+              }
+            ]
+          };
+        } catch (e) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Import failed: ${String(e)}` }]
+          };
+        }
+      }
+    );
+  },
+  {},
+  { maxDuration: 60, streamableHttpEndpoint: "/mcp", verboseLogs: true }
+);
+async function mcpRoute({ request }) {
+  try {
+    if (isLocalPreviewMode()) {
+      const res2 = await handler(request);
+      if (!res2) return new Response(null, { status: 200 });
+      const body2 = await res2.arrayBuffer();
+      return new Response(body2, {
+        status: res2.status,
+        headers: res2.headers
+      });
+    }
+    const authenticatedHandler = withMcpAuth(auth, async (req, session) => {
+      const { locals } = getRequestEvent();
+      const [userRow] = await locals.db.select().from(user).where(eq(user.id, session.userId)).limit(1);
+      if (userRow) {
+        const [sub] = await locals.db.select({ tier: userSubscription.tier }).from(userSubscription).where(eq(userSubscription.userId, session.userId)).limit(1);
+        locals.user = {
+          ...userRow,
+          subscriptionTier: sub?.tier ?? "free"
+        };
+      }
+      const response = await handler(req);
+      return response ?? new Response(null, { status: 200 });
+    });
+    const res = await authenticatedHandler(request);
+    if (!res) return new Response(null, { status: 200 });
+    const body = await res.arrayBuffer();
+    return new Response(body, {
+      status: res.status,
+      headers: res.headers
+    });
+  } catch (e) {
+    console.error("[mcp] error:", e);
+    return new Response(JSON.stringify({ error: String(e) }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}
+const GET = mcpRoute;
+const POST = mcpRoute;
+const DELETE = mcpRoute;
+
+export { DELETE, GET, POST };
+//# sourceMappingURL=_server.ts-BsgeMvN0.js.map