genshin-persona 4.0.0 → 4.1.0

package/.mcp.json

@@ -0,0 +1 @@
+{ "mcpServers": { "genshin-persona": { "command": "node", "args": ["${CLAUDE_PLUGIN_ROOT}/scripts/channel.mjs"] } } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genshin-persona",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "A Claude Code plugin that speaks as the Genshin Impact character whose birthday is nearest: an answer opens with one spoken line in the character's voice and the rest is plain, a joke or a hello is spoken whole, and every line is read aloud in the character's own cloned voice as the reply is written.",
   "keywords": [
     "claude-code",
@@ -24,6 +24,7 @@
   },
   "files": [
     ".claude-plugin",
+    ".mcp.json",
     "hooks",
     "output-styles",
     "runtime",
@@ -54,6 +55,7 @@
     "typecheck": "tsc"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
     "@typesafe-ai/sdk": "^0.6.0",
     "@wasm-audio-decoders/ogg-vorbis": "^0.1.20",
     "citty": "^0.2.2",
@@ -61,7 +63,7 @@
     "tsx": "^4.23.15"
   },
   "engines": {
-    "node": ">=26.10.0"
+    "node": ">=26.11.1"
   },
-  "gitHead": "7667bc8c9a2b4e9dcacd6b845ee8cc9951250ae7"
+  "gitHead": "68de4c22fa7591bf6f6cc0fab2c9a906d8c4d71a"
 }

package/scripts/channel.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/channel");

package/scripts/channel.ts

@@ -0,0 +1,98 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { AddressInfo } from "node:net";
+
+import { checkIsChannelRequestAllowed } from "#src/services/checkIsChannelRequestAllowed";
+import { createChannelPage } from "#src/services/createChannelPage";
+import { readChannelLine } from "#src/services/readChannelLine";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+
+// The chat window's MCP server, started with the session over stdio. It serves the page on the loopback under a token
+// Printed once to the terminal, takes typed lines into the session as channel events, and offers the reply tool that
+// Sends the plain half of an answer back to the page. The character's spoken lines need no forwarding: the message
+// Display hook already reads them to the viewer
+const token = randomBytes(16).toString("hex");
+const replyStreams = new Set<ServerResponse>();
+
+// The low-level Server keeps the raw request handlers and the channel notification, which McpServer's tool API does not expose
+// oxlint-disable-next-line typescript/no-deprecated -- see the comment above
+const mcp = new Server(
+  { name: "genshin-persona", version: "4.0.0" },
+  {
+    capabilities: { experimental: { "claude/channel": {} }, tools: {} },
+    instructions:
+      'Lines typed at the desk arrive as <channel source="genshin-persona" sender="desk">. The character\'s spoken lines already reach the viewer, so do not forward them. When a desk line asks something, also call the reply tool with the plain half of the answer; the desk reads it on the chat page.',
+  },
+);
+
+mcp.setRequestHandler(ListToolsRequestSchema, () => ({
+  tools: [
+    {
+      description: "Show the plain half of an answer to a line typed at the desk on the chat page",
+      inputSchema: { properties: { text: { type: "string" } }, required: ["text"], type: "object" },
+      name: "reply",
+    },
+  ],
+}));
+
+mcp.setRequestHandler(CallToolRequestSchema, (request) => {
+  // oxlint-disable-next-line error-handling/no-bare-error -- an unlisted tool name is the SDK's own error to report to the caller
+  if (request.params.name !== "reply") throw new Error(`Unknown tool ${request.params.name}`);
+
+  // oxlint-disable-next-line typescript/no-base-to-string -- the arguments are the caller's own JSON, and its text is the reply as sent
+  const text = String(request.params.arguments?.text ?? "");
+  for (const stream of replyStreams) stream.write(`event: reply\ndata: ${JSON.stringify({ text })}\n\n`);
+  return { content: [{ text: "sent", type: "text" }] };
+});
+
+const writeEnded = (response: ServerResponse, statusCode: number) => {
+  response.writeHead(statusCode).end();
+};
+
+const handleSay = (request: IncomingMessage, response: ServerResponse) => {
+  // Decoded as the stream arrives, so a character split across two chunks is joined rather than read as two bad bytes
+  request.setEncoding("utf8");
+  let body = "";
+  request.on("data", (chunk: string) => {
+    body += chunk;
+  });
+  request.on("end", () => {
+    const line = readChannelLine(body);
+    if (line === undefined) return writeEnded(response, 400);
+
+    mcp.notification({ method: "notifications/claude/channel", params: { content: line, meta: { sender: "desk" } } });
+    writeEnded(response, 204);
+  });
+};
+
+const handleEvents = (request: IncomingMessage, response: ServerResponse) => {
+  response.writeHead(200, { "cache-control": "no-cache", "content-type": "text/event-stream" });
+  response.write(": open\n\n");
+  replyStreams.add(response);
+  request.on("close", () => replyStreams.delete(response));
+};
+
+const http = createServer((request, response) => {
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  const [, presentedToken = "", route = ""] = url.pathname.split("/");
+  if (!checkIsChannelRequestAllowed(request.socket.remoteAddress, presentedToken, token))
+    return writeEnded(response, 404);
+
+  if (route === "" && request.method === "GET") {
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(createChannelPage());
+    return;
+  }
+  if (route === "events" && request.method === "GET") return handleEvents(request, response);
+  if (route === "say" && request.method === "POST") return handleSay(request, response);
+  writeEnded(response, 404);
+});
+
+http.listen(0, "127.0.0.1", () => {
+  const { port } = http.address() as AddressInfo;
+  console.error(`Chat into the session: http://127.0.0.1:${port}/${token}/`);
+});
+
+await mcp.connect(new StdioServerTransport());

package/scripts/pick.ts

@@ -3,13 +3,12 @@ import { formatLoreChart } from "#src/services/formatLoreChart";
 import { formatUpcomingBirthdays } from "#src/services/formatUpcomingBirthdays";
 import { getCard } from "#src/services/getCard";
 import { getSessionStartOutput } from "#src/services/getSessionStartOutput";
-import { parseHookInput } from "#src/services/parseHookInput";
 import { readInterfaceLanguage } from "#src/services/readInterfaceLanguage";
 import { readLocalization } from "#src/services/readLocalization";
 import { readPersonaCard } from "#src/services/readPersonaCard";
 import { readReplyLanguage } from "#src/services/readReplyLanguage";
 import { readRoster } from "#src/services/readRoster";
-import { readStdin } from "#src/services/readStdin";
+import { readStdinSessionId } from "#src/services/readStdinSessionId";
 import { readVoiceRemark } from "#src/services/readVoiceRemark";
 import { registerQuietExit } from "#src/services/registerQuietExit";
 import { resolveSessionCharacter } from "#src/services/resolveSessionCharacter";
@@ -18,8 +17,7 @@ import { resolveSessionCharacter } from "#src/services/resolveSessionCharacter";
 // No card, and the output style answers plainly
 registerQuietExit();
 const today = Temporal.Now.plainDateISO();
-const input = await readStdin();
-const { session_id: sessionId = "" } = parseHookInput(input);
+const sessionId = await readStdinSessionId();
 // Both are a file read on this path: what was written to either was checked against the data package then, and the
 // Roster cache is keyed by the interface language, so a language changed since is a cache miss and not a mismatch
 const language = readInterfaceLanguage();

package/scripts/status.ts

@@ -1,16 +1,14 @@
 import type { PersonaStatus } from "#types";
 
 import { getPersonaCharacter } from "#src/services/getPersonaCharacter";
-import { parseHookInput } from "#src/services/parseHookInput";
 import { readSessionNameplate } from "#src/services/readSessionNameplate";
-import { readStdin } from "#src/services/readStdin";
+import { readStdinSessionId } from "#src/services/readStdinSessionId";
 import { registerQuietExit } from "#src/services/registerQuietExit";
 
 // The session's character for the hooks module, as JSON: run at session start, after every verb and after each turn
 // Until the session's own record exists
 registerQuietExit();
-const input = await readStdin();
-const { session_id: sessionId = "" } = parseHookInput(input);
+const sessionId = await readStdinSessionId();
 const sessionNameplate = readSessionNameplate(sessionId);
 if (sessionNameplate) {
   const { isRecorded, nameplate } = sessionNameplate;

package/scripts/statusLine.ts

@@ -1,13 +1,11 @@
 import { formatNameplate } from "#src/services/formatNameplate";
-import { parseHookInput } from "#src/services/parseHookInput";
 import { readSessionNameplate } from "#src/services/readSessionNameplate";
-import { readStdin } from "#src/services/readStdin";
+import { readStdinSessionId } from "#src/services/readStdinSessionId";
 import { registerQuietExit } from "#src/services/registerQuietExit";
 
 // A status line command a person names in their own settings, since no plugin can set one: the session's nameplate.
 // Claude Code hands it the session's id on stdin as it does a hook
 registerQuietExit();
-const input = await readStdin();
-const { session_id: sessionId = "" } = parseHookInput(input);
+const sessionId = await readStdinSessionId();
 const sessionNameplate = readSessionNameplate(sessionId);
 if (sessionNameplate) console.log(formatNameplate(sessionNameplate.nameplate));

package/scripts/voice.ts

@@ -90,27 +90,33 @@ const speak = async (request: SpeechRequest, player: AudioPlayer | undefined, ch
     if (playerFailure) writeVoiceLog(`the player did not play: ${playerFailure}`);
   };
   let playback: Promise<void> = Promise.resolve();
-  for (const line of request.lines) {
+  for (const [lineIndex, line] of request.lines.entries()) {
+    let isSpoken = false;
+    // Each chunk plays as it is vocoded, and a line that stops short is cut where it stood; leaving this loop early
+    // Ends the generation behind it
+    const label = `reply ${request.messageId}, line ${lineIndex + 1}`;
     // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
-    const clip = await synthesizer.synthesize(line, speaker);
-    if (!clip) {
-      // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
-      await playback;
-      return VoiceStatus.Error;
-    }
+    for await (const clip of synthesizer.streamSpeech(line, speaker, label, checkIsSuperseded)) {
+      isSpoken = true;
+      if (synthesizer.device !== settledDevice) {
+        settledDevice = synthesizer.device;
+        writeVoiceDevice(settledDevice);
+      }
 
-    if (synthesizer.device !== settledDevice) {
-      settledDevice = synthesizer.device;
-      writeVoiceDevice(settledDevice);
-    }
+      if (!player) continue;
 
-    if (!player) continue;
+      // oxlint-disable-next-line no-await-in-loop -- One device: chunks play back one after another
+      await playback;
+      if (checkIsSuperseded()) return VoiceStatus.Superseded;
 
-    // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
-    await playback;
-    if (checkIsSuperseded()) return VoiceStatus.Superseded;
+      playback = play(player, clip);
+    }
 
-    playback = play(player, clip);
+    if (!isSpoken) {
+      // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
+      await playback;
+      return VoiceStatus.Error;
+    }
   }
 
   await playback;

package/src/generated/CharacterLinesLoaderMap.ts

@@ -1,10 +1,9 @@
+/* eslint-disable no-restricted-syntax -- each language is its own chunk: the map is the entry every spinner read loads, so the other fourteen languages' lines, hundreds of kilobytes each, stay out of the eager graph */
 import type { VoiceLine } from "#src/models/VoiceLine";
 
 import { GameLanguage } from "#src/generated/genshinText/models/GameLanguage";
 
-// Written by `pnpm -C scripts genshin:text write`, never by hand. Each language is a dynamic import on purpose: the
-// Map is the entry every spinner read loads, so the import is the split that keeps the other fourteen languages'
-// Lines, hundreds of kilobytes each, out of it
+// Written by `pnpm -C scripts genshin:text write`, never by hand.
 export const CharacterLinesLoaderMap: Record<GameLanguage, () => Promise<Record<string, VoiceLine[]>>> = {
   [GameLanguage.ChineseSimplified]: async () =>
     (await import("#src/generated/characterLines/ChineseSimplified.json", { with: { type: "json" } })).default,

package/src/generated/genshinText/generated/GameTextLoaderMap.ts

@@ -1,12 +1,11 @@
 // Copied from `genshin-text` by `pnpm -C scripts genshin:text write`, never edited by hand
+/* eslint-disable no-restricted-syntax -- every language but English is its own chunk: the map is the entry every reader loads, so its dynamic imports keep the fourteen languages a page does not show out of the eager graph */
 import type { GameText } from "#src/generated/genshinText/models/GameText";
 
 import English from "#src/generated/genshinText/generated/text/English.json" with { type: "json" };
 import { GameLanguage } from "#src/generated/genshinText/models/GameLanguage";
 
-// Written by `pnpm -C scripts genshin:text write`, never by hand. Every language but English is a dynamic import
-// On purpose: the map is the entry every reader loads, so the import is the split that keeps the fourteen languages
-// A page does not show out of its eager graph
+// Written by `pnpm -C scripts genshin:text write`, never by hand.
 export const ENGLISH_GAME_TEXT: GameText = English;
 export const GameTextLoaderMap: Record<GameLanguage, () => Promise<GameText>> = {
   [GameLanguage.ChineseSimplified]: async () =>