@devmotion/cli 0.7.0 → 0.8.0

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

@@ -1,722 +0,0 @@
-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