Add submit_indexnow and convert_to_webp tools to blog-mcp

- submit_indexnow: notify IndexNow (Bing and other participating
  engines) that given URLs are new/changed, for faster crawling than
  waiting on discovery or Google's low-quota manual indexing button.
  Host/key are hardcoded to this site's own published IndexNow key
  file; no credentials needed. Verified end-to-end (HTTP 200) against
  a real published post URL.
- convert_to_webp: standalone PNG/JPEG -> optimized WebP conversion,
  reusing the existing sharp-based toWebpBuffer/resolveImageInput
  helpers already used by upload_image, for cases that just need a
  local optimized file with no GitHub repo/upload involved. Verified
  against a real 984KB PNG (97% size reduction, valid WebP output).

Both smoke-tested by spawning the built server and driving the actual
MCP stdio protocol (initialize/tools-list/tools-call), not just tsc.

Author: OCEANOFANYTHING

tools/blog-mcp/README.md

@@ -2,8 +2,9 @@
 
 A local MCP (Model Context Protocol) server that gives an AI agent (Claude Code, or any
 other MCP client) direct tools for running ScriptXeno's blog workflow: reading and writing
-posts, creating the per-post image-hosting repos the site uses, converting/uploading images,
-and generating new images with Gemini's image model ("nano banana").
+posts, creating the per-post image-hosting repos the site uses, converting/uploading/optimizing
+images, generating new images with Gemini's image model ("nano banana"), and notifying
+IndexNow once a post is live.
 
 It runs as a local Node process over stdio — the MCP client (Claude Code) spawns and manages
 it automatically per `.mcp.json` at the repo root. You never start it by hand.
@@ -142,6 +143,18 @@ Provide **either** `localPath` or `imageData` — not neither. Converts to PNG +
 the Claude Code conversation, the agent can pass its bytes straight through as `imageData`
 — no need to save it to disk or know a file path first.
 
+#### `convert_to_webp`
+| Input | Type | Notes |
+|---|---|---|
+| `localPath` | string | optional — absolute path to a source PNG/JPEG/etc. Output defaults to the same path with a `.webp` extension. |
+| `imageData` | string | optional — base64 source bytes. Takes precedence if both are given. Output defaults into `tools/blog-mcp/generated/`. |
+| `outputPath` | string | optional — override the output path entirely |
+| `quality` | number | default `82` |
+
+Standalone WebP conversion via `sharp` — no GitHub repo or upload involved, just a local file
+in, a local file out. Returns `{ outputPath, originalBytes, optimizedBytes, savedPercent }`.
+Use `upload_image` instead when the result also needs hosting on a post's image repo.
+
 #### `generate_image`
 | Input | Type | Notes |
 |---|---|---|
@@ -166,6 +179,20 @@ other pending changes in the working tree are left alone. This pushes straight t
 which triggers `pages-deploy.yml` and goes live. There is no undo tool; revert with
 `git revert <sha>` if needed (the returned `commitSha` is exactly what you'd revert).
 
+#### `submit_indexnow`
+| Input | Type | Notes |
+|---|---|---|
+| `urls` | string[] | required, 1–10,000 full URLs, all on `scriptxeno.github.io` |
+
+Notifies IndexNow (Bing and other participating engines) that the given URLs are new or
+changed, so they get crawled faster than waiting on organic discovery — a workaround for the
+low daily quota on Google's own manual "Request indexing" button (Google itself doesn't
+participate in IndexNow, so this doesn't help Google specifically). Host and key are hardcoded
+in `src/tools/indexnow.ts` to this site's own key file,
+`https://scriptxeno.github.io/8224327bc30e4fd28859be57075c7439.txt` — no credentials needed.
+Call it with the real post URL(s) right after `publish_post` once the page is confirmed live.
+Returns `{ submitted, status, ok }`.
+
 ## Design notes
 
 ### Thumbnail house style
@@ -277,3 +304,4 @@ repo-creation was indistinguishable from failure and got reported as an error.)
 | `generate_image` returns HTTP 429 with `limit: 0` | Free-tier quota for image models is zero regardless of model — billing must be enabled on the Gemini key's Google Cloud project |
 | `generate_image` throws "Could not locate image data" | The Interactions API's response shape has changed — the error includes the raw JSON; update `findImageData()` in `src/tools/generate_image.ts` with the real field path |
 | `publish_post` fails with "nothing to commit" | The post file's content is identical to what's already committed |
+| `submit_indexnow` returns a 422 | The URL doesn't actually resolve on `scriptxeno.github.io` yet — GitHub Pages needs a few seconds after `publish_post` before a brand-new URL is live; confirm with `curl` first, same as before publishing anywhere else |

tools/blog-mcp/src/index.ts

@@ -8,6 +8,7 @@ import { registerImageTools } from "./tools/images.js";
 import { registerGenerateImageTool } from "./tools/generate_image.js";
 import { registerPublishTool } from "./tools/publish.js";
 import { registerThumbnailTool } from "./tools/thumbnail.js";
+import { registerIndexNowTool } from "./tools/indexnow.js";
 
 dotenv.config({ path: path.join(repoRoot, "tools", "blog-mcp", ".env") });
 
@@ -18,6 +19,7 @@ registerImageTools(server);
 registerGenerateImageTool(server);
 registerPublishTool(server);
 registerThumbnailTool(server);
+registerIndexNowTool(server);
 
 const transport = new StdioServerTransport();
 await server.connect(transport);

tools/blog-mcp/src/tools/images.ts

@@ -1,9 +1,11 @@
 import fs from "node:fs";
+import path from "node:path";
 import { z } from "zod";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { createRepo, enablePages, getRepo, putFileContents } from "../lib/github.js";
 import { toPngBuffer, toTinyPlaceholderBuffer, toWebpBuffer } from "../lib/images.js";
 import { STATIC_LQIP } from "../lib/frontmatter.js";
+import { generatedDir } from "../lib/paths.js";
 
 function textResult(value: unknown) {
   return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
@@ -119,4 +121,44 @@ export function registerImageTools(server: McpServer) {
       });
     }
   );
+
+  server.registerTool(
+    "convert_to_webp",
+    {
+      title: "Convert image to WebP",
+      description:
+        "Convert a local PNG/JPEG (or other sharp-supported format) to an optimized WebP file. Provide `localPath` (output defaults to the same file with a .webp extension) or `imageData` (base64 bytes — output goes to the generated/ staging folder). Returns the output path plus original/optimized byte sizes.",
+      inputSchema: {
+        localPath: z.string().optional().describe("Absolute local path to the source image."),
+        imageData: z.string().optional().describe("Base64-encoded source image bytes. Takes precedence over localPath if both are given."),
+        outputPath: z.string().optional().describe("Absolute path for the .webp output. Defaults next to localPath, or into generated/ for imageData."),
+        quality: z.number().int().min(1).max(100).default(82),
+      },
+    },
+    async ({ localPath, imageData, outputPath, quality }) => {
+      const resolved = resolveImageInput({ localPath, imageData });
+      if (!Buffer.isBuffer(resolved)) return errorResult(resolved.error);
+      const input = resolved;
+
+      let outPath = outputPath;
+      if (!outPath) {
+        if (localPath) {
+          outPath = localPath.replace(/\.[^./\\]+$/, "") + ".webp";
+        } else {
+          fs.mkdirSync(generatedDir, { recursive: true });
+          outPath = path.join(generatedDir, `${Date.now()}.webp`);
+        }
+      }
+
+      const webpBuffer = await toWebpBuffer(input, quality);
+      fs.writeFileSync(outPath, webpBuffer);
+
+      return textResult({
+        outputPath: outPath,
+        originalBytes: input.length,
+        optimizedBytes: webpBuffer.length,
+        savedPercent: Math.round((1 - webpBuffer.length / input.length) * 100),
+      });
+    }
+  );
 }

tools/blog-mcp/src/tools/indexnow.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+const HOST = "scriptxeno.github.io";
+const KEY = "8224327bc30e4fd28859be57075c7439";
+const KEY_LOCATION = `https://${HOST}/${KEY}.txt`;
+
+function textResult(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+function errorResult(message: string) {
+  return { content: [{ type: "text" as const, text: message }], isError: true };
+}
+
+export function registerIndexNowTool(server: McpServer) {
+  server.registerTool(
+    "submit_indexnow",
+    {
+      title: "Submit URLs to IndexNow",
+      description:
+        "Notify IndexNow (Bing, and other participating search engines) that one or more scriptxeno.github.io URLs are new or updated, so they get crawled faster than waiting on discovery. Pass full URLs (e.g. from publish_post's result).",
+      inputSchema: {
+        urls: z.array(z.string().url()).min(1).max(10000),
+      },
+    },
+    async ({ urls }) => {
+      const offHost = urls.filter((u) => new URL(u).host !== HOST);
+      if (offHost.length > 0) {
+        return errorResult(`All URLs must be on ${HOST}. Off-host: ${offHost.join(", ")}`);
+      }
+
+      try {
+        const res = await fetch("https://api.indexnow.org/indexnow", {
+          method: "POST",
+          headers: { "Content-Type": "application/json; charset=utf-8" },
+          body: JSON.stringify({ host: HOST, key: KEY, keyLocation: KEY_LOCATION, urlList: urls }),
+        });
+        // IndexNow returns 200/202 on success with an empty body -- text() rather than
+        // json() since a non-2xx error body isn't guaranteed to be valid JSON either.
+        const body = await res.text();
+        return textResult({ submitted: urls.length, status: res.status, ok: res.ok, body: body || undefined });
+      } catch (err) {
+        return errorResult(err instanceof Error ? err.message : String(err));
+      }
+    }
+  );
+}