@ampless/backend 0.2.0-alpha.9 → 1.0.0-alpha.19

package/dist/functions/mcp-handler.js

@@ -1,15 +1,1040 @@
+import "../chunk-BYXBJQAS.js";
+
 // src/functions/mcp-handler.ts
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
 import { createHash } from "crypto";
+import { decodeAwsJson as decodeAwsJson2 } from "ampless";
+
+// ../mcp-server/dist/chunk-DAR6AHSX.js
+import {
+  decodeAwsJson
+} from "ampless";
+import {
+  encodeAwsJson
+} from "ampless";
+import {
+  encodeAwsJson as encodeAwsJson2
+} from "ampless";
+import {
+  bundlePrefix,
+  mimeTypeFor,
+  pickDefaultEntrypoint,
+  validateBundle
+} from "ampless";
+import { unzipSync, strFromU8 } from "fflate";
+import {
+  validateBundlePath,
+  stripCommonPrefix
+} from "ampless";
+import {
+  encodeAwsJson as encodeAwsJson3
+} from "ampless";
+import {
+  bundlePrefix as bundlePrefix2,
+  findAbsolutePathRefs,
+  mimeTypeFor as mimeTypeFor2,
+  validateBundlePath as validateBundlePath2,
+  TEXT_EXTENSIONS
+} from "ampless";
+import { bundlePrefix as bundlePrefix3, validateBundlePath as validateBundlePath3 } from "ampless";
+import {
+  bundlePrefix as bundlePrefix4,
+  pickDefaultEntrypoint as pickDefaultEntrypoint2
+} from "ampless";
+var POST_FIELDS = (
+  /* GraphQL */
+  `
+  fragment PostFields on Post {
+    postId
+    slug
+    title
+    excerpt
+    format
+    body
+    status
+    publishedAt
+    tags
+    metadata
+  }
+`
+);
+function toCorePost(p) {
+  const metadata = decodeAwsJson(p.metadata);
+  return {
+    postId: p.postId,
+    slug: p.slug,
+    title: p.title,
+    excerpt: p.excerpt ?? void 0,
+    format: p.format ?? "markdown",
+    body: decodeAwsJson(p.body),
+    status: p.status ?? "draft",
+    publishedAt: p.publishedAt ?? void 0,
+    tags: (p.tags ?? []).filter((t) => typeof t === "string"),
+    metadata: metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : void 0
+  };
+}
+var QUERY = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  query ListPosts($filter: ModelPostFilterInput, $limit: Int, $nextToken: String) {
+    listPosts(filter: $filter, limit: $limit, nextToken: $nextToken) {
+      items {
+        ...PostFields
+      }
+      nextToken
+    }
+  }
+`
+);
+var listPostsSchema = {
+  type: "object",
+  properties: {
+    status: {
+      type: "string",
+      enum: ["draft", "published", "all"],
+      description: 'Filter by status (default "all")'
+    },
+    limit: { type: "integer", minimum: 1, maximum: 100, description: "Max results (default 20)" },
+    nextToken: { type: "string", description: "Pagination cursor from a previous call" }
+  }
+};
+async function listPosts(client, args = {}) {
+  const status = args.status ?? "all";
+  const filter = {};
+  if (status !== "all") filter.status = { eq: status };
+  const hasFilter = Object.keys(filter).length > 0;
+  const data = await client.query(QUERY, {
+    filter: hasFilter ? filter : void 0,
+    limit: args.limit ?? 20,
+    nextToken: args.nextToken
+  });
+  return {
+    posts: data.listPosts.items.map(toCorePost),
+    nextToken: data.listPosts.nextToken
+  };
+}
+var GET_BY_ID = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  query GetPost($postId: ID!) {
+    getPost(postId: $postId) {
+      ...PostFields
+    }
+  }
+`
+);
+var LIST_BY_SLUG = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  query GetPostBySlug($filter: ModelPostFilterInput!) {
+    listPosts(filter: $filter, limit: 1) {
+      items {
+        ...PostFields
+      }
+    }
+  }
+`
+);
+var getPostSchema = {
+  type: "object",
+  properties: {
+    slug: { type: "string", description: "Post slug" },
+    postId: { type: "string", description: "Post id (used when slug is omitted)" }
+  }
+};
+async function getPost(client, args) {
+  if (!args.slug && !args.postId) {
+    throw new Error("get_post requires either `slug` or `postId`");
+  }
+  if (args.postId) {
+    const data2 = await client.query(GET_BY_ID, { postId: args.postId });
+    return data2.getPost ? toCorePost(data2.getPost) : null;
+  }
+  const data = await client.query(LIST_BY_SLUG, {
+    filter: { slug: { eq: args.slug } }
+  });
+  const item = data.listPosts.items[0];
+  return item ? toCorePost(item) : null;
+}
+function entries(post) {
+  if (post.status !== "published" || !post.publishedAt || !post.tags?.length) return [];
+  return post.tags.map((tag) => ({
+    tag,
+    publishedAtPostId: `${post.publishedAt}#${post.postId}`
+  }));
+}
+function entryKey(e) {
+  return `${e.tag}|${e.publishedAtPostId}`;
+}
+var CREATE_POST_TAG = (
+  /* GraphQL */
+  `
+  mutation CreatePostTag($input: CreatePostTagInput!) {
+    createPostTag(input: $input) {
+      tag
+      publishedAtPostId
+    }
+  }
+`
+);
+var UPDATE_POST_TAG = (
+  /* GraphQL */
+  `
+  mutation UpdatePostTag($input: UpdatePostTagInput!) {
+    updatePostTag(input: $input) {
+      tag
+      publishedAtPostId
+    }
+  }
+`
+);
+var DELETE_POST_TAG = (
+  /* GraphQL */
+  `
+  mutation DeletePostTag($input: DeletePostTagInput!) {
+    deletePostTag(input: $input) {
+      tag
+      publishedAtPostId
+    }
+  }
+`
+);
+async function syncPostTags(client, post, oldPost) {
+  const oldEntries = oldPost ? entries(oldPost) : [];
+  const newEntries = entries(post);
+  const oldKeys = new Set(oldEntries.map(entryKey));
+  const newKeys = new Set(newEntries.map(entryKey));
+  await Promise.all(
+    oldEntries.filter((e) => !newKeys.has(entryKey(e))).map(
+      (e) => client.query(DELETE_POST_TAG, {
+        input: { tag: e.tag, publishedAtPostId: e.publishedAtPostId }
+      })
+    )
+  );
+  await Promise.all(
+    newEntries.filter((e) => !oldKeys.has(entryKey(e))).map(
+      (e) => client.query(CREATE_POST_TAG, {
+        input: {
+          tag: e.tag,
+          publishedAtPostId: e.publishedAtPostId,
+          postId: post.postId,
+          publishedAt: post.publishedAt,
+          slug: post.slug,
+          title: post.title,
+          excerpt: post.excerpt,
+          tags: post.tags ?? []
+        }
+      })
+    )
+  );
+  await Promise.all(
+    newEntries.filter((e) => oldKeys.has(entryKey(e))).map(
+      (e) => client.query(UPDATE_POST_TAG, {
+        input: {
+          tag: e.tag,
+          publishedAtPostId: e.publishedAtPostId,
+          slug: post.slug,
+          title: post.title,
+          excerpt: post.excerpt,
+          tags: post.tags ?? []
+        }
+      })
+    )
+  );
+}
+var MUTATION = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  mutation CreatePost($input: CreatePostInput!) {
+    createPost(input: $input) {
+      ...PostFields
+    }
+  }
+`
+);
+var createPostSchema = {
+  type: "object",
+  required: ["slug", "title", "format", "body"],
+  properties: {
+    postId: { type: "string", description: "Optional explicit id; auto-generated if omitted" },
+    slug: { type: "string" },
+    title: { type: "string" },
+    format: {
+      type: "string",
+      enum: ["tiptap", "markdown", "html"],
+      description: "tiptap = rich text JSON tree; markdown = source string (GFM extensions enabled); html = raw HTML string (rendered verbatim, no sanitization)."
+    },
+    body: {
+      description: "tiptap JSON (when format=tiptap), markdown source string (format=markdown), or raw HTML string (format=html)."
+    },
+    status: { type: "string", enum: ["draft", "published"], default: "draft" },
+    excerpt: { type: "string" },
+    publishedAt: { type: "string", description: "ISO 8601 timestamp; required when status=published" },
+    tags: { type: "array", items: { type: "string" } },
+    metadata: {
+      type: "object",
+      description: "Free-form per-post metadata. Reserved well-known keys: `no_layout` (boolean) \u2014 when true, the public page is served as bare HTML with no theme chrome (the route redirects to /_/<slug>); meaningful only with format=html. Other keys pass through unchanged for themes/plugins.",
+      properties: {
+        no_layout: {
+          type: "boolean",
+          description: "Serve the post as bare HTML with no theme chrome. Only meaningful when format=html; ignored otherwise."
+        }
+      },
+      additionalProperties: true
+    }
+  }
+};
+async function createPost(client, args) {
+  const postId = args.postId ?? `post-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const status = args.status ?? "draft";
+  const publishedAt = args.publishedAt ?? (status === "published" ? (/* @__PURE__ */ new Date()).toISOString() : void 0);
+  const data = await client.query(MUTATION, {
+    input: {
+      postId,
+      slug: args.slug,
+      title: args.title,
+      excerpt: args.excerpt,
+      format: args.format,
+      body: encodeAwsJson(args.body),
+      status,
+      publishedAt,
+      tags: args.tags,
+      metadata: args.metadata !== void 0 ? encodeAwsJson(args.metadata) : void 0
+    }
+  });
+  const created = toCorePost(data.createPost);
+  await syncPostTags(client, created, null);
+  return created;
+}
+var MUTATION2 = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  mutation UpdatePost($input: UpdatePostInput!) {
+    updatePost(input: $input) {
+      ...PostFields
+    }
+  }
+`
+);
+var updatePostSchema = {
+  type: "object",
+  required: ["postId"],
+  properties: {
+    postId: { type: "string" },
+    slug: { type: "string" },
+    title: { type: "string" },
+    excerpt: { type: "string" },
+    format: {
+      type: "string",
+      enum: ["tiptap", "markdown", "html"],
+      description: "tiptap = rich text JSON tree; markdown = source string; html = raw HTML string (no sanitization)."
+    },
+    body: { description: "tiptap JSON, markdown source, or raw HTML string" },
+    status: { type: "string", enum: ["draft", "published"] },
+    publishedAt: { type: "string", description: "ISO 8601 timestamp" },
+    tags: { type: "array", items: { type: "string" } },
+    metadata: {
+      type: "object",
+      description: "Free-form per-post metadata. Reserved well-known keys: `no_layout` (boolean) \u2014 when true, the public page is served as bare HTML with no theme chrome (the route redirects to /_/<slug>); meaningful only with format=html. Passing metadata replaces the existing metadata object \u2014 read the current post first if you only want to add a key.",
+      properties: {
+        no_layout: {
+          type: "boolean",
+          description: "Serve the post as bare HTML with no theme chrome. Only meaningful when format=html; ignored otherwise."
+        }
+      },
+      additionalProperties: true
+    }
+  }
+};
+async function updatePost(client, args) {
+  const oldPost = await getPost(client, { postId: args.postId });
+  const input = { postId: args.postId };
+  if (args.slug !== void 0) input.slug = args.slug;
+  if (args.title !== void 0) input.title = args.title;
+  if (args.excerpt !== void 0) input.excerpt = args.excerpt;
+  if (args.format !== void 0) input.format = args.format;
+  if (args.body !== void 0) input.body = encodeAwsJson2(args.body);
+  if (args.status !== void 0) input.status = args.status;
+  if (args.publishedAt !== void 0) input.publishedAt = args.publishedAt;
+  if (args.tags !== void 0) input.tags = args.tags;
+  if (args.metadata !== void 0) input.metadata = encodeAwsJson2(args.metadata);
+  const data = await client.query(MUTATION2, { input });
+  const updated = toCorePost(data.updatePost);
+  await syncPostTags(client, updated, oldPost);
+  return updated;
+}
+var MUTATION3 = (
+  /* GraphQL */
+  `
+  mutation DeletePost($input: DeletePostInput!) {
+    deletePost(input: $input) {
+      postId
+    }
+  }
+`
+);
+var deletePostSchema = {
+  type: "object",
+  required: ["postId"],
+  properties: {
+    postId: { type: "string" }
+  }
+};
+async function deletePost(client, args) {
+  const oldPost = await getPost(client, { postId: args.postId });
+  if (oldPost) {
+    await syncPostTags(client, { ...oldPost, status: "draft" }, oldPost);
+  }
+  const data = await client.query(MUTATION3, { input: { postId: args.postId } });
+  return { deleted: data.deletePost };
+}
+function sanitizeName(name) {
+  return name.replace(/[\x00-\x1f\x7f]/g, "").replace(/[\\/:*?"<>|]/g, "_").replace(/\s+/g, "_").replace(/^\.+/, "_").slice(0, 200) || "upload";
+}
+function buildMediaKey(filename, now = /* @__PURE__ */ new Date()) {
+  const safe = sanitizeName(filename);
+  const yyyy = now.getFullYear();
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  return `public/media/${yyyy}/${mm}/${now.getTime()}-${safe}`;
+}
+var MUTATION4 = (
+  /* GraphQL */
+  `
+  mutation CreateMedia($input: CreateMediaInput!) {
+    createMedia(input: $input) {
+      mediaId
+      src
+      mimeType
+      size
+      delivery
+    }
+  }
+`
+);
+var uploadMediaSchema = {
+  type: "object",
+  required: ["filename", "mimeType", "base64Data"],
+  properties: {
+    filename: { type: "string", description: "Original filename; sanitized server-side" },
+    mimeType: {
+      type: "string",
+      description: "IANA media type (e.g. image/webp, image/jpeg). The MCP server does not transcode \u2014 pass the MIME of the bytes you actually send."
+    },
+    base64Data: {
+      type: "string",
+      description: "Base64-encoded file contents. NO data:URL prefix. The MCP server uploads bytes verbatim \u2014 resize/encode client-side first if needed."
+    }
+  }
+};
+async function uploadMedia(graphql, storage, args) {
+  const body = Buffer.from(args.base64Data, "base64");
+  const key = buildMediaKey(args.filename);
+  const url = await storage.putObject(key, body, args.mimeType);
+  const mediaId = `media-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const data = await graphql.query(MUTATION4, {
+    input: {
+      mediaId,
+      src: key,
+      mimeType: args.mimeType,
+      size: body.length,
+      delivery: "nextjs"
+    }
+  });
+  return { media: data.createMedia, url };
+}
+var getSchemaSchema = {
+  type: "object",
+  properties: {}
+};
+function getSchema() {
+  return {
+    contentTypes: [
+      {
+        name: "post",
+        identifier: ["postId"],
+        fields: {
+          postId: { type: "string", required: true, description: "auto-generated if omitted on create" },
+          slug: { type: "string", required: true, description: "URL slug, unique" },
+          title: { type: "string", required: true },
+          excerpt: { type: "string" },
+          format: { type: "enum", values: ["tiptap", "markdown", "html"], required: true },
+          body: {
+            type: "json",
+            description: "tiptap node JSON when format=tiptap; markdown source string when format=markdown; raw HTML string when format=html"
+          },
+          status: { type: "enum", values: ["draft", "published"], default: "draft" },
+          publishedAt: { type: "datetime", description: "ISO 8601" },
+          tags: { type: "string[]" },
+          metadata: {
+            type: "json",
+            description: "Free-form per-post key/value bag. Reserved well-known keys (owned by ampless): `no_layout` (boolean). Other keys pass through unchanged for themes/plugins."
+          }
+        }
+      },
+      {
+        name: "page",
+        identifier: ["pageId"],
+        fields: {
+          pageId: { type: "string", required: true },
+          slug: { type: "string", required: true },
+          title: { type: "string", required: true },
+          format: { type: "enum", values: ["tiptap", "markdown", "html"], required: true },
+          body: { type: "json" },
+          status: { type: "enum", values: ["draft", "published"] },
+          publishedAt: { type: "datetime" }
+        }
+      },
+      {
+        name: "media",
+        identifier: ["mediaId"],
+        fields: {
+          mediaId: { type: "string", required: true },
+          src: { type: "string", required: true, description: "S3 key" },
+          mimeType: { type: "string", required: true },
+          size: { type: "integer" },
+          delivery: { type: "string" }
+        }
+      }
+    ],
+    formats: ["tiptap", "markdown", "html"],
+    notes: {
+      editorTrust: 'editor stores arbitrary HTML/JS verbatim \u2014 same trust shape as WordPress unfiltered_html capability. See docs/architecture/04-access-layer-mcp.md \xA7"editor \u306E\u4FE1\u983C\u30E2\u30C7\u30EB".',
+      tiptapBody: 'When format=tiptap, body is the tiptap document JSON: { type: "doc", content: [...] }. The renderer expects this shape.',
+      noLayout: "metadata.no_layout=true serves the post as bare HTML with no theme chrome \u2014 the public route at /<slug> 308-redirects to /_/<slug>, and that route renders the body verbatim with no wrapping <html>/<head>/layout. Use this for landing pages, embeds, or any post whose body is a full HTML document. Only meaningful with format=html (the other formats need the theme renderer).",
+      staticFormat: "A fourth format value `static` exists on the underlying data model for posts whose body is a JSON manifest pointing to a pre-uploaded HTML/CSS/JS bundle in S3 at public/static/<slug>/. Public URL pattern: /_/<slug>/ for the entrypoint and /_/<slug>/<file> for every bundle file (308 redirect from /<slug> via the post dispatcher). Static posts are created/edited through the dedicated tools `upload_static_bundle` (zip in one shot), `upload_static_file` / `delete_static_file` (incremental per-file ops), and `commit_static_post` (rebuild the manifest from the current S3 prefix). `create_post` / `update_post` intentionally do NOT accept format=static \u2014 the bundle tools are the only supported entry point so the Post manifest stays in sync with the S3 prefix."
+    }
+  };
+}
+var DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+function extractZipFromBuffer(buffer, opts = {}) {
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  const entries2 = unzipSync(buffer);
+  const files = [];
+  const issues = [];
+  let totalBytes = 0;
+  for (const [name, data] of Object.entries(entries2)) {
+    if (name.endsWith("/")) continue;
+    const reason = validateBundlePath(name);
+    if (reason) {
+      const silent = reason === "macOS resource fork" || reason === ".DS_Store junk" || reason === "Thumbs.db junk" || reason === "directory entry";
+      if (!silent) issues.push({ path: name, reason });
+      continue;
+    }
+    totalBytes += data.byteLength;
+    if (totalBytes > maxBytes) {
+      throw new Error(
+        `Bundle too large: uncompressed size exceeds the ${Math.round(maxBytes / 1024 / 1024)} MB ceiling.`
+      );
+    }
+    files.push({ path: name, data });
+  }
+  return { files: stripCommonPrefix(files), issues, totalBytes };
+}
+var CREATE_MUTATION = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  mutation CreatePost($input: CreatePostInput!) {
+    createPost(input: $input) {
+      ...PostFields
+    }
+  }
+`
+);
+var UPDATE_MUTATION = (
+  /* GraphQL */
+  `
+  ${POST_FIELDS}
+  mutation UpdatePost($input: UpdatePostInput!) {
+    updatePost(input: $input) {
+      ...PostFields
+    }
+  }
+`
+);
+async function upsertStaticPost(graphql, slug, body, fields) {
+  const existing = await getPost(graphql, { slug });
+  if (existing) {
+    const input2 = {
+      postId: existing.postId,
+      format: "static",
+      body: encodeAwsJson3(body)
+    };
+    if (fields.title !== void 0) input2.title = fields.title;
+    if (fields.excerpt !== void 0) input2.excerpt = fields.excerpt;
+    if (fields.status !== void 0) input2.status = fields.status;
+    if (fields.publishedAt !== void 0) input2.publishedAt = fields.publishedAt;
+    if (fields.tags !== void 0) input2.tags = fields.tags;
+    if (fields.metadata !== void 0) {
+      input2.metadata = encodeAwsJson3(fields.metadata);
+    }
+    const data2 = await graphql.query(UPDATE_MUTATION, { input: input2 });
+    const updated = toCorePost(data2.updatePost);
+    await syncPostTags(graphql, updated, existing);
+    return { post: updated, created: false };
+  }
+  if (!fields.title) {
+    throw new Error(
+      `commit_static_post: cannot create a new post at slug "${slug}" without a title. Pass \`title\` or commit against an existing post.`
+    );
+  }
+  const status = fields.status ?? "draft";
+  const publishedAt = fields.publishedAt ?? (status === "published" ? (/* @__PURE__ */ new Date()).toISOString() : void 0);
+  const postId = fields.postId ?? `post-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const input = {
+    postId,
+    slug,
+    title: fields.title,
+    format: "static",
+    body: encodeAwsJson3(body),
+    status
+  };
+  if (fields.excerpt !== void 0) input.excerpt = fields.excerpt;
+  if (publishedAt !== void 0) input.publishedAt = publishedAt;
+  if (fields.tags !== void 0) input.tags = fields.tags;
+  if (fields.metadata !== void 0) input.metadata = encodeAwsJson3(fields.metadata);
+  const data = await graphql.query(CREATE_MUTATION, { input });
+  const created = toCorePost(data.createPost);
+  await syncPostTags(graphql, created, null);
+  return { post: created, created: true };
+}
+var uploadStaticBundleSchema = {
+  type: "object",
+  required: ["slug", "title", "zipBase64"],
+  properties: {
+    postId: {
+      type: "string",
+      description: "Optional explicit Post id when creating a new post. Ignored if a post at this slug already exists."
+    },
+    slug: { type: "string", description: "URL slug. Doubles as the S3 bundle path key." },
+    title: { type: "string" },
+    zipBase64: {
+      type: "string",
+      description: "Base64-encoded zip archive. NO `data:` URL prefix. Every entry must reference others by RELATIVE path; absolute paths (`/foo`) and protocol-relative URLs (`//cdn/foo`) inside HTML / CSS / SVG are rejected as the bundle would not be portable across URL prefixes."
+    },
+    entrypoint: {
+      type: "string",
+      description: "Relative path to the file served at the post URL (default `index.html`, or the first `.html` at root if `index.html` is absent)."
+    },
+    status: { type: "string", enum: ["draft", "published"], default: "draft" },
+    excerpt: { type: "string" },
+    publishedAt: { type: "string", description: 'ISO 8601 timestamp; defaults to "now" when status=published.' },
+    tags: { type: "array", items: { type: "string" } },
+    metadata: {
+      type: "object",
+      description: "Free-form per-post metadata. NOTE: `no_layout` is irrelevant for static posts (the bundle is already served raw).",
+      additionalProperties: true
+    }
+  }
+};
+async function uploadStaticBundle(graphql, storage, args) {
+  const slug = args.slug;
+  const zipBytes = Buffer.from(args.zipBase64, "base64");
+  if (zipBytes.length === 0) {
+    throw new Error("upload_static_bundle: zipBase64 decoded to zero bytes.");
+  }
+  const { files, issues } = extractZipFromBuffer(zipBytes);
+  if (issues.length > 0) {
+    throw new Error(
+      `upload_static_bundle: rejected bundle path(s): ${issues.map((i) => `${i.path} (${i.reason})`).join("; ")}`
+    );
+  }
+  if (files.length === 0) {
+    throw new Error("upload_static_bundle: zip contained no files.");
+  }
+  const contentIssues = validateBundle(files);
+  if (contentIssues.length > 0) {
+    throw new Error(
+      `upload_static_bundle: bundle contains absolute / protocol-relative refs: ${contentIssues.map((i) => `${i.path}: ${i.reason}`).join("; ")}`
+    );
+  }
+  const entrypoint = args.entrypoint ?? pickDefaultEntrypoint(files);
+  if (!files.some((f) => f.path === entrypoint)) {
+    throw new Error(
+      `upload_static_bundle: entrypoint "${entrypoint}" is not present in the bundle.`
+    );
+  }
+  const prefix = bundlePrefix(slug);
+  const existing = await storage.listObjects(prefix).catch((err) => {
+    console.error("[upload_static_bundle] listObjects failed (proceeding)", err);
+    return [];
+  });
+  for (const obj of existing) {
+    await storage.deleteObject(obj.key);
+  }
+  let uploadedFiles = 0;
+  for (const f of files) {
+    await storage.putObject(`${prefix}${f.path}`, f.data, mimeTypeFor(f.path));
+    uploadedFiles += 1;
+  }
+  const body = {
+    entrypoint,
+    files: files.map((f) => f.path).sort(),
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const { post } = await upsertStaticPost(graphql, slug, body, {
+    title: args.title,
+    postId: args.postId,
+    status: args.status,
+    publishedAt: args.publishedAt,
+    excerpt: args.excerpt,
+    tags: args.tags,
+    metadata: args.metadata
+  });
+  return { post, bundle: body, uploadedFiles };
+}
+var uploadStaticFileSchema = {
+  type: "object",
+  required: ["slug", "filename", "base64Data"],
+  properties: {
+    slug: { type: "string", description: "Bundle slug. Files land at public/static/<slug>/<filename>." },
+    filename: {
+      type: "string",
+      description: "Relative path inside the bundle. Must NOT start with `/`, contain `..`, or include null bytes. macOS / Windows zip junk (`.DS_Store`, `__MACOSX/*`, `Thumbs.db`) is also rejected."
+    },
+    contentType: {
+      type: "string",
+      description: "IANA media type. Omit to derive from the filename extension (text/html, text/css, application/javascript, image/* \u2026; falls back to application/octet-stream)."
+    },
+    base64Data: {
+      type: "string",
+      description: "Base64-encoded file bytes. NO `data:` URL prefix. Text files (HTML/CSS/SVG) are linted for absolute / protocol-relative URL refs \u2014 failures throw."
+    }
+  }
+};
+async function uploadStaticFile(storage, args) {
+  const filename = args.filename;
+  const reason = validateBundlePath2(filename);
+  if (reason) {
+    throw new Error(`upload_static_file: invalid filename "${filename}" (${reason})`);
+  }
+  const body = Buffer.from(args.base64Data, "base64");
+  if (body.length === 0) {
+    throw new Error("upload_static_file: base64Data decoded to zero bytes.");
+  }
+  const ext = filename.toLowerCase().slice(filename.lastIndexOf("."));
+  if (TEXT_EXTENSIONS.has(ext)) {
+    const text = body.toString("utf8");
+    const issues = findAbsolutePathRefs(filename, text);
+    if (issues.length > 0) {
+      throw new Error(
+        `upload_static_file: ${filename} contains absolute / protocol-relative refs: ${issues.map((i) => i.reason).join("; ")}`
+      );
+    }
+  }
+  const contentType = args.contentType ?? mimeTypeFor2(filename);
+  const key = `${bundlePrefix2(args.slug)}${filename}`;
+  const url = await storage.putObject(key, body, contentType);
+  return { key, url, size: body.length };
+}
+var deleteStaticFileSchema = {
+  type: "object",
+  required: ["slug", "filename"],
+  properties: {
+    slug: { type: "string" },
+    filename: {
+      type: "string",
+      description: "Relative path inside the bundle to delete. Same path rules as `upload_static_file` apply (no `..`, no absolute paths, no null bytes)."
+    }
+  }
+};
+async function deleteStaticFile(storage, args) {
+  const reason = validateBundlePath3(args.filename);
+  if (reason) {
+    throw new Error(`delete_static_file: invalid filename "${args.filename}" (${reason})`);
+  }
+  const prefix = bundlePrefix3(args.slug);
+  const key = `${prefix}${args.filename}`;
+  const existing = await storage.listObjects(key);
+  const found = existing.some((o) => o.key === key);
+  if (!found) {
+    return { key, deleted: false };
+  }
+  await storage.deleteObject(key);
+  return { key, deleted: true };
+}
+var commitStaticPostSchema = {
+  type: "object",
+  required: ["slug"],
+  properties: {
+    slug: { type: "string" },
+    title: {
+      type: "string",
+      description: "Required when this is a brand-new post (no existing row at the slug). On update, falls back to the current title."
+    },
+    entrypoint: {
+      type: "string",
+      description: "Relative path of the entry file (defaults to `index.html`, or the first `.html` at root if absent). Must exist under the current S3 prefix."
+    },
+    postId: {
+      type: "string",
+      description: "Optional explicit Post id when creating a new post. Ignored if a row at this slug already exists."
+    },
+    status: { type: "string", enum: ["draft", "published"] },
+    publishedAt: { type: "string", description: "ISO 8601 timestamp." },
+    excerpt: { type: "string" },
+    tags: { type: "array", items: { type: "string" } },
+    metadata: {
+      type: "object",
+      description: "Free-form per-post metadata. Passing this REPLACES the existing object on update.",
+      additionalProperties: true
+    }
+  }
+};
+async function commitStaticPost(graphql, storage, args) {
+  const slug = args.slug;
+  const prefix = bundlePrefix4(slug);
+  const objects = await storage.listObjects(prefix);
+  if (objects.length === 0) {
+    throw new Error(
+      `commit_static_post: no files found under "${prefix}". Upload at least one file via upload_static_file or upload_static_bundle before committing.`
+    );
+  }
+  const relPaths = objects.map((o) => o.key.slice(prefix.length)).filter((p) => p !== "").sort();
+  const entrypoint = args.entrypoint ?? pickDefaultEntrypoint2(relPaths.map((p) => ({ path: p })));
+  if (!relPaths.includes(entrypoint)) {
+    throw new Error(
+      `commit_static_post: entrypoint "${entrypoint}" is not present under "${prefix}".`
+    );
+  }
+  const body = {
+    entrypoint,
+    files: relPaths,
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const { post, created } = await upsertStaticPost(graphql, slug, body, {
+    title: args.title,
+    postId: args.postId,
+    excerpt: args.excerpt,
+    status: args.status,
+    publishedAt: args.publishedAt,
+    tags: args.tags,
+    metadata: args.metadata
+  });
+  return { post, bundle: body, created };
+}
+var tools = [
+  {
+    name: "list_posts",
+    description: "List posts in the CMS with optional filters by status. Returns up to `limit` posts (default 20) plus a `nextToken` cursor for pagination.",
+    inputSchema: listPostsSchema,
+    handler: (args, ctx) => listPosts(ctx.graphql, args)
+  },
+  {
+    name: "get_post",
+    description: "Fetch a single post by slug or postId. Returns null if not found.",
+    inputSchema: getPostSchema,
+    handler: (args, ctx) => getPost(ctx.graphql, args)
+  },
+  {
+    name: "create_post",
+    description: "Create a new post. Title and slug are required. Body shape depends on format: tiptap=JSON node tree, markdown=source string, html=raw HTML string. Defaults to status=draft. Pass `metadata: { no_layout: true }` alongside format=html to publish the body as a bare HTML page with no theme chrome (the public route redirects to /_/<slug>).",
+    inputSchema: createPostSchema,
+    handler: (args, ctx) => createPost(ctx.graphql, args)
+  },
+  {
+    name: "update_post",
+    description: "Update an existing post by postId. Only the fields you pass are changed. Tag list / publishedAt changes also update the PostTag denormalized index. Passing `metadata` REPLACES the existing object \u2014 call get_post first if you only want to add or change one key.",
+    inputSchema: updatePostSchema,
+    handler: (args, ctx) => updatePost(ctx.graphql, args)
+  },
+  {
+    name: "delete_post",
+    description: "Delete a post by postId. Also drops associated PostTag index entries.",
+    inputSchema: deletePostSchema,
+    handler: (args, ctx) => deletePost(ctx.graphql, args)
+  },
+  {
+    name: "upload_media",
+    description: "Upload a file to the site's media S3 bucket. Pass base64-encoded bytes; the server stores them verbatim under public/media/YYYY/MM/. Returns the public URL and Media record. The server does not transcode \u2014 pre-process (e.g. resize/webp) on the client.",
+    inputSchema: uploadMediaSchema,
+    handler: (args, ctx) => uploadMedia(ctx.graphql, ctx.storage(), args)
+  },
+  {
+    name: "get_schema",
+    description: "Returns the CMS content schema (Post/Page/Media field shapes, format enum, notes). Useful as the first call to understand what fields are available.",
+    inputSchema: getSchemaSchema,
+    handler: async () => getSchema()
+  },
+  {
+    name: "upload_static_bundle",
+    description: "Create or replace a `format: 'static'` post in one shot. Pass a base64-encoded zip; the server unpacks it, validates every path + lints HTML/CSS/SVG for absolute path refs (bundles must be self-contained via relative paths), wipes the existing S3 prefix at public/static/<slug>/, uploads every file, and upserts the Post row with a manifest pointing at the entrypoint. Use this when you have the whole bundle to submit at once. For incremental edits use upload_static_file / delete_static_file followed by commit_static_post.",
+    inputSchema: uploadStaticBundleSchema,
+    handler: (args, ctx) => uploadStaticBundle(
+      ctx.graphql,
+      ctx.storage(),
+      args
+    )
+  },
+  {
+    name: "upload_static_file",
+    description: "Upload a single file into an existing static bundle's S3 prefix. The Post row is NOT modified \u2014 its `body` manifest will be out of sync with the prefix until you call `commit_static_post`. Use this for incremental edits (one CSS swap, single image change) where rebuilding the entire zip would be overkill. Text files (HTML/CSS/SVG) are linted for absolute / protocol-relative URL refs the same as the zip flow.",
+    inputSchema: uploadStaticFileSchema,
+    handler: (args, ctx) => uploadStaticFile(
+      ctx.storage(),
+      args
+    )
+  },
+  {
+    name: "delete_static_file",
+    description: "Delete a single file from a static bundle's S3 prefix. The Post row is NOT modified \u2014 its `body` manifest will list the deleted file until you call `commit_static_post`. Idempotent: returns `{ deleted: false }` instead of throwing if the file isn't there.",
+    inputSchema: deleteStaticFileSchema,
+    handler: (args, ctx) => deleteStaticFile(
+      ctx.storage(),
+      args
+    )
+  },
+  {
+    name: "commit_static_post",
+    description: 'Rebuild a static post\'s Post row from whatever is currently in its S3 prefix. Scans `public/static/<slug>/`, picks the entrypoint (default `index.html` or override), and upserts the Post with a fresh manifest (sorted file list + uploadedAt timestamp). Use this as the "save" step after a series of `upload_static_file` / `delete_static_file` calls. `title` is required when creating a brand-new post; on update, existing fields are preserved unless explicitly overridden.',
+    inputSchema: commitStaticPostSchema,
+    handler: (args, ctx) => commitStaticPost(
+      ctx.graphql,
+      ctx.storage(),
+      args
+    )
+  }
+];
+async function dispatchToolCall(name, args, ctx) {
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) return null;
+  return tool.handler(args, ctx);
+}
+
+// src/functions/mcp-graphql-client.ts
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { HttpRequest } from "@smithy/protocol-http";
+import { SignatureV4 } from "@smithy/signature-v4";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+function createMcpGraphqlClient(opts) {
+  const url = new URL(opts.endpoint);
+  const signer = new SignatureV4({
+    service: "appsync",
+    region: opts.region,
+    credentials: defaultProvider(),
+    sha256: Sha256
+  });
+  return {
+    async query(operation, variables = {}) {
+      const body = JSON.stringify({ query: operation, variables });
+      const request = new HttpRequest({
+        method: "POST",
+        protocol: url.protocol,
+        hostname: url.hostname,
+        path: url.pathname,
+        headers: {
+          // `host` is required for SigV4 canonicalisation.
+          host: url.hostname,
+          "content-type": "application/json"
+        },
+        body
+      });
+      const signed = await signer.sign(request);
+      const response = await fetch(opts.endpoint, {
+        method: "POST",
+        headers: signed.headers,
+        body
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        console.error("[mcp-graphql-client] AppSync HTTP error", {
+          status: response.status,
+          body: text.slice(0, 1e3)
+        });
+        throw new Error(`AppSync ${response.status}: ${text || response.statusText}`);
+      }
+      const json = await response.json();
+      if (json.errors && json.errors.length > 0) {
+        const msg = json.errors.map((e) => e.message).join("; ");
+        console.error("[mcp-graphql-client] AppSync GraphQL errors", { errors: json.errors });
+        throw new Error(`AppSync GraphQL error: ${msg}`);
+      }
+      if (!json.data) {
+        throw new Error("AppSync returned an empty response");
+      }
+      return json.data;
+    }
+  };
+}
+
+// src/functions/mcp-storage-client.ts
+import {
+  S3Client,
+  PutObjectCommand,
+  DeleteObjectCommand,
+  ListObjectsV2Command
+} from "@aws-sdk/client-s3";
+import { formatPublicAssetUrl } from "ampless";
+function createMcpStorageClient(opts) {
+  const client = new S3Client({ region: opts.region });
+  return {
+    async putObject(key, body, contentType) {
+      await client.send(
+        new PutObjectCommand({
+          Bucket: opts.bucket,
+          Key: key,
+          Body: body,
+          ContentType: contentType
+        })
+      );
+      return formatPublicAssetUrl(opts.bucket, opts.region, key);
+    },
+    async deleteObject(key) {
+      await client.send(
+        new DeleteObjectCommand({ Bucket: opts.bucket, Key: key })
+      );
+    },
+    async listObjects(prefix) {
+      const out = [];
+      let token;
+      do {
+        const res = await client.send(
+          new ListObjectsV2Command({
+            Bucket: opts.bucket,
+            Prefix: prefix,
+            ContinuationToken: token
+          })
+        );
+        for (const obj of res.Contents ?? []) {
+          if (!obj.Key) continue;
+          out.push({
+            key: obj.Key,
+            size: obj.Size ?? 0,
+            lastModified: obj.LastModified?.toISOString()
+          });
+        }
+        token = res.IsTruncated ? res.NextContinuationToken : void 0;
+      } while (token);
+      return out;
+    }
+  };
+}
+
+// src/functions/mcp-handler.ts
 var TOKENS_PK = "mcp-tokens";
+var JSON_RPC_PARSE_ERROR = -32700;
+var JSON_RPC_INVALID_REQUEST = -32600;
+var JSON_RPC_METHOD_NOT_FOUND = -32601;
+var JSON_RPC_INVALID_PARAMS = -32602;
+var JSON_RPC_INTERNAL_ERROR = -32603;
+var MCP_PROTOCOL_VERSION = "2024-11-05";
 function requireEnv(name) {
   const v = process.env[name];
   if (!v) throw new Error(`[mcp-handler] missing required env var ${name}`);
   return v;
 }
 var KV_TABLE = requireEnv("AMPLESS_KV_TABLE");
+var APPSYNC_URL = requireEnv("AMPLESS_APPSYNC_URL");
+var BUCKET_NAME = requireEnv("AMPLESS_BUCKET_NAME");
+var AWS_REGION = process.env["AWS_REGION"] ?? "us-east-1";
 var ddb = DynamoDBDocumentClient.from(new DynamoDBClient({}));
+var HTTP_TOOLS = tools;
 function hashToken(plain) {
   return createHash("sha256").update(plain).digest("hex");
 }
@@ -20,6 +1045,14 @@ function jsonResponse(statusCode, body) {
     body: JSON.stringify(body)
   };
 }
+function jsonRpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function jsonRpcError(id, code, message, data) {
+  const error = { code, message };
+  if (data !== void 0) error.data = data;
+  return { jsonrpc: "2.0", id, error };
+}
 async function validateBearer(plaintext) {
   const hash = hashToken(plaintext);
   const res = await ddb.send(
@@ -30,17 +1063,85 @@ async function validateBearer(plaintext) {
   );
   const row = res.Item;
   if (!row?.value) return null;
-  let meta;
-  try {
-    meta = JSON.parse(row.value);
-  } catch {
-    console.error("[mcp-handler] could not parse token row", { hash });
+  const meta = decodeTokenMeta(row.value);
+  if (!meta) {
+    console.error("[mcp-handler] could not decode token row", { hash, valueType: typeof row.value });
     return null;
   }
   if (meta.revokedAt) return null;
   if (meta.expiresAt && new Date(meta.expiresAt).getTime() <= Date.now()) return null;
   return meta;
 }
+function decodeTokenMeta(value) {
+  const parsed = decodeAwsJson2(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  return parsed;
+}
+var cachedCtx = null;
+function makeContext() {
+  if (cachedCtx) return cachedCtx;
+  let storageClient = null;
+  const ctx = {
+    graphql: createMcpGraphqlClient({ endpoint: APPSYNC_URL, region: AWS_REGION }),
+    storage: () => {
+      if (!storageClient) {
+        storageClient = createMcpStorageClient({ bucket: BUCKET_NAME, region: AWS_REGION });
+      }
+      return storageClient;
+    }
+  };
+  cachedCtx = ctx;
+  return ctx;
+}
+async function dispatchJsonRpc(req) {
+  switch (req.method) {
+    case "initialize":
+      return jsonRpcResult(req.id, {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: "ampless-mcp", version: "0.2" }
+      });
+    case "notifications/initialized":
+      return jsonRpcResult(req.id, null);
+    case "tools/list":
+      return jsonRpcResult(req.id, {
+        tools: HTTP_TOOLS.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      });
+    case "tools/call": {
+      const params = req.params;
+      if (!params?.name || typeof params.name !== "string") {
+        return jsonRpcError(req.id, JSON_RPC_INVALID_PARAMS, "tools/call requires a `name` parameter");
+      }
+      const tool = HTTP_TOOLS.find((t) => t.name === params.name);
+      if (!tool) {
+        return jsonRpcError(req.id, JSON_RPC_METHOD_NOT_FOUND, `unknown tool: ${params.name}`);
+      }
+      const ctx = makeContext();
+      try {
+        const result = await dispatchToolCall(params.name, params.arguments ?? {}, ctx);
+        return jsonRpcResult(req.id, {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error("[mcp-handler] tool dispatch failed", {
+          tool: params.name,
+          message
+        });
+        return jsonRpcResult(req.id, {
+          isError: true,
+          content: [{ type: "text", text: message }]
+        });
+      }
+    }
+    default:
+      return jsonRpcError(req.id, JSON_RPC_METHOD_NOT_FOUND, `Method not found: ${req.method}`);
+  }
+}
 var handler = async (event) => {
   if (event.requestContext?.http?.method === "OPTIONS") {
     return { statusCode: 204, body: "" };
@@ -58,12 +1159,33 @@ var handler = async (event) => {
   if (!meta) {
     return jsonResponse(401, { error: "invalid_token" });
   }
-  return jsonResponse(200, {
-    ok: true,
-    tokenPrefix: meta.prefix,
-    scope: meta.scope,
-    note: "Phase 3 stub. JSON-RPC tool dispatch lands in Phase 4."
-  });
+  let req;
+  try {
+    const body = event.isBase64Encoded ? Buffer.from(event.body ?? "", "base64").toString("utf8") : event.body ?? "";
+    if (!body) {
+      return jsonResponse(400, jsonRpcError(null, JSON_RPC_INVALID_REQUEST, "Empty body"));
+    }
+    req = JSON.parse(body);
+  } catch {
+    return jsonResponse(400, jsonRpcError(null, JSON_RPC_PARSE_ERROR, "Parse error"));
+  }
+  if (req.jsonrpc !== "2.0" || typeof req.method !== "string") {
+    return jsonResponse(
+      400,
+      jsonRpcError(req?.id ?? null, JSON_RPC_INVALID_REQUEST, "Invalid Request")
+    );
+  }
+  try {
+    const response = await dispatchJsonRpc(req);
+    return jsonResponse(200, response);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("[mcp-handler] dispatch threw", { method: req.method, message });
+    return jsonResponse(
+      500,
+      jsonRpcError(req.id ?? null, JSON_RPC_INTERNAL_ERROR, message)
+    );
+  }
 };
 export {
   handler