ui-chan-mcp 0.5.0

package/dist/app/tts.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiSonaTalkClient = void 0;
+exports.buildTimeline = buildTimeline;
+const RETRY_COOLDOWN_MS = 60_000;
+/** The engine simply not being up yet is a transient, self-healing condition
+ *  (the MCP bridge relaunches VoiSona Talk), so it must not silence the mascot
+ *  for a full minute the way a real synthesis error does. */
+const UNREACHABLE_COOLDOWN_MS = 5_000;
+const SYNTH_TIMEOUT_MS = 20_000;
+const POLL_INTERVAL_MS = 150;
+const VOWELS = new Set(['a', 'i', 'u', 'e', 'o']);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Build lip sync frames from VoiSona's phoneme timing. Consonants open the
+ * mouth into the following vowel's shape at the consonant's start; silence,
+ * N and cl close it.
+ */
+function buildTimeline(phonemes, durations) {
+    const frames = [];
+    let t = 0;
+    let pendingStart = null;
+    for (let i = 0; i < phonemes.length; i++) {
+        const p = phonemes[i];
+        const d = (durations[i] ?? 0.05) * 1000;
+        if (VOWELS.has(p.toLowerCase())) {
+            frames.push({ t: pendingStart ?? t, v: p.toLowerCase() });
+            pendingStart = null;
+        }
+        else if (p === 'sil' || p === 'pau' || p === 'N' || p === 'cl') {
+            frames.push({ t, v: 'n' });
+            pendingStart = null;
+        }
+        else if (pendingStart === null) {
+            pendingStart = t;
+        }
+        t += d;
+    }
+    // Collapse consecutive frames with the same mouth shape (e.g. several
+    // vowels/consonants in a row that all resolve to the same viseme) down to
+    // their first occurrence — the renderer only needs to know when the mouth
+    // shape *changes*.
+    const deduped = [];
+    for (const frame of frames) {
+        if (deduped.length === 0 || deduped[deduped.length - 1].v !== frame.v)
+            deduped.push(frame);
+    }
+    return deduped;
+}
+/** Tell "the engine isn't up" apart from a genuine synthesis failure: a dead
+ *  port makes fetch reject (ECONNREFUSED) or time out, never return an HTTP
+ *  status, so only those two shapes count as unreachable. */
+function isUnreachable(e) {
+    if (!(e instanceof Error))
+        return false;
+    if (e.name === 'TimeoutError' || e.name === 'AbortError')
+        return true;
+    const cause = e.cause?.code ?? '';
+    return ['ECONNREFUSED', 'ECONNRESET', 'ENOTFOUND', 'EHOSTUNREACH'].includes(cause);
+}
+/**
+ * VoiSona Talk REST API client (docs: http://localhost:32766/docs/talk_api.html).
+ * Synthesizes to memory, retrieves the WAV plus phoneme timing, and lets the
+ * renderer play audio in exact sync with the mouth.
+ */
+class VoiSonaTalkClient {
+    cfg;
+    disabledUntil = 0;
+    voiceCache = null;
+    runtimeUsername = null;
+    runtimePassword = null;
+    lastError = null;
+    lastSuccessAt = null;
+    engineUnreachable = false;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    status() {
+        return {
+            enabled: this.cfg.enabled,
+            hasCredentials: this.hasCredentials(),
+            coolingDown: Date.now() < this.disabledUntil,
+            lastError: this.lastError,
+            lastSuccessAt: this.lastSuccessAt,
+            engineUnreachable: this.engineUnreachable,
+        };
+    }
+    /** Credentials arrive from the MCP bridge (mcp.json env) and live in memory only. */
+    setCredentials(username, password) {
+        if (username !== this.runtimeUsername || password !== this.runtimePassword) {
+            this.runtimeUsername = username;
+            this.runtimePassword = password;
+            this.disabledUntil = 0; // new credentials: retry immediately
+        }
+    }
+    hasCredentials() {
+        return Boolean(this.runtimeUsername ?? process.env.UI_CHAN_TTS_USERNAME ?? this.cfg.username);
+    }
+    base() {
+        return `${this.cfg.url}/api/talk/v1`;
+    }
+    headers() {
+        const user = this.runtimeUsername ?? process.env.UI_CHAN_TTS_USERNAME ?? this.cfg.username ?? '';
+        const pass = this.runtimePassword ?? process.env.UI_CHAN_TTS_PASSWORD ?? this.cfg.password ?? '';
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}`,
+        };
+    }
+    async get(path) {
+        const res = await fetch(this.base() + path, {
+            headers: this.headers(),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            throw new Error(`GET ${path}: HTTP ${res.status}`);
+        return res.json();
+    }
+    async resolveVoice() {
+        if (this.voiceCache)
+            return this.voiceCache;
+        const lang = this.cfg.language ?? 'ja_JP';
+        const list = await this.get('/voices');
+        const items = list.items ?? [];
+        const picked = (this.cfg.voice_name && items.find((v) => v.voice_name === this.cfg.voice_name)) ||
+            items.find((v) => v.languages?.includes(lang)) ||
+            items[0];
+        if (!picked)
+            return null;
+        const detail = await this.get(`/voices/${encodeURIComponent(picked.voice_name)}/${encodeURIComponent(picked.voice_version)}`);
+        this.voiceCache = {
+            voice_name: picked.voice_name,
+            voice_version: picked.voice_version,
+            style_names: detail.style_names ?? [],
+            default_style_weights: detail.default_style_weights ?? (detail.style_names ?? []).map((_, i) => (i === 0 ? 1 : 0)),
+        };
+        return this.voiceCache;
+    }
+    /** The voice's style names + default weights, for the editor's slider UI.
+     *  Returns null if the engine is unreachable or has no styles. */
+    async listStyles() {
+        if (!this.hasCredentials())
+            return null;
+        try {
+            const voice = await this.resolveVoice();
+            if (!voice || voice.style_names.length === 0)
+                return null;
+            return {
+                style_names: voice.style_names,
+                default_style_weights: voice.default_style_weights,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Convert a { name: weight } style_weights map into the positional array
+     *  VoiSona expects (ordered by voice.style_names). Pure name lookup — no
+     *  blending, no defaults mixed in. */
+    styleWeights(target, voice) {
+        if (!target || voice.style_names.length === 0)
+            return undefined;
+        const vec = voice.style_names.map((name) => {
+            const hit = Object.entries(target).find(([k]) => k.toLowerCase() === name.toLowerCase());
+            return hit ? hit[1] : 0;
+        });
+        return vec.some((w) => w !== 0) ? vec : undefined;
+    }
+    /** Synthesize one line of speech in the given Cue's baked voice color,
+     *  layered with this line's ad-lib pitch/speed/volume/intonation. Thin
+     *  wrapper that resolves the Cue name to its saved voice color, then defers
+     *  to synthesizeWithVoice. */
+    synthesize(text, cue, adlib) {
+        return this.synthesizeWithVoice(text, this.cfg.cueVoice?.[cue], adlib);
+    }
+    /** Synthesize with an explicit voice color instead of a saved Cue name — used
+     *  by the editor's "試し喋り" to preview an in-progress, not-yet-saved voice. */
+    async synthesizeWithVoice(text, cueVoice, adlib) {
+        if (!this.cfg.enabled || !this.hasCredentials() || Date.now() < this.disabledUntil)
+            return null;
+        try {
+            const voice = await this.resolveVoice();
+            const weights = voice ? this.styleWeights(cueVoice?.style_weights, voice) : undefined;
+            const globalParameters = {
+                ...(weights ? { style_weights: weights } : {}),
+                ...(cueVoice?.alp !== undefined ? { alp: cueVoice.alp } : {}),
+                ...(cueVoice?.huskiness !== undefined ? { huskiness: cueVoice.huskiness } : {}),
+                ...(adlib?.pitch !== undefined ? { pitch: adlib.pitch } : {}),
+                ...(adlib?.speed !== undefined ? { speed: adlib.speed } : {}),
+                ...(adlib?.volume !== undefined ? { volume: adlib.volume } : {}),
+                ...(adlib?.intonation !== undefined ? { intonation: adlib.intonation } : {}),
+            };
+            const res = await fetch(`${this.base()}/speech-syntheses`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify({
+                    force_enqueue: true,
+                    destination: 'memory',
+                    language: this.cfg.language ?? 'ja_JP',
+                    text,
+                    ...(voice ? { voice_name: voice.voice_name, voice_version: voice.voice_version } : {}),
+                    ...(Object.keys(globalParameters).length > 0
+                        ? { global_parameters: globalParameters }
+                        : {}),
+                }),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!res.ok)
+                throw new Error(`POST /speech-syntheses: HTTP ${res.status}`);
+            const { uuid } = (await res.json());
+            const deadline = Date.now() + SYNTH_TIMEOUT_MS;
+            let info;
+            for (;;) {
+                info = await this.get(`/speech-syntheses/${uuid}`);
+                if (info.state === 'succeeded')
+                    break;
+                if (info.state === 'failed')
+                    throw new Error('synthesis failed');
+                if (Date.now() > deadline)
+                    throw new Error('synthesis timed out');
+                await sleep(POLL_INTERVAL_MS);
+            }
+            const wavRes = await fetch(`${this.base()}/speech-syntheses/${uuid}/wav`, {
+                headers: this.headers(),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!wavRes.ok)
+                throw new Error(`GET wav: HTTP ${wavRes.status}`);
+            const wav = Buffer.from(await wavRes.arrayBuffer());
+            fetch(`${this.base()}/speech-syntheses/${uuid}`, {
+                method: 'DELETE',
+                headers: this.headers(),
+            }).catch(() => { });
+            const durations = info.phoneme_durations ?? [];
+            const durationMs = Math.round((info.duration ?? durations.reduce((a, b) => a + b, 0)) * 1000);
+            this.lastError = null;
+            this.lastSuccessAt = new Date().toISOString();
+            this.engineUnreachable = false;
+            return {
+                wavBase64: wav.toString('base64'),
+                durationMs,
+                timeline: buildTimeline(info.phonemes ?? [], durations),
+            };
+        }
+        catch (e) {
+            this.engineUnreachable = isUnreachable(e);
+            const cooldown = this.engineUnreachable ? UNREACHABLE_COOLDOWN_MS : RETRY_COOLDOWN_MS;
+            this.disabledUntil = Date.now() + cooldown;
+            this.lastError = e instanceof Error ? e.message : String(e);
+            console.error(this.engineUnreachable
+                ? `[ui-chan] VoiSona Talk not reachable at ${this.cfg.url} (retrying in ${cooldown / 1000}s): ${this.lastError}`
+                : `[ui-chan] VoiSona Talk synthesis failed (retrying after ${cooldown / 1000}s): ${this.lastError}`);
+            return null;
+        }
+    }
+}
+exports.VoiSonaTalkClient = VoiSonaTalkClient;

package/dist/mcp-server.js

@@ -0,0 +1,408 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const ws_1 = __importDefault(require("ws"));
+const zod_1 = require("zod");
+const persona_1 = require("./app/persona");
+const paths_1 = require("./shared/paths");
+const set_cue_schema_1 = require("./shared/set-cue-schema");
+const projectRoot = path.resolve(__dirname, '..');
+// TTS credentials may live in a .env (package dir or ~/.ui-chan) instead of the
+// shell environment (env vars still win — loadEnvFile does not overwrite them).
+(0, paths_1.loadEnvFiles)(projectRoot);
+const paths = (0, paths_1.resolvePaths)(projectRoot);
+const config = paths.config;
+const port = Number(process.env.UI_CHAN_PORT ?? config.port ?? 8123);
+const wsUrl = `ws://127.0.0.1:${port}`;
+const log = (msg) => process.stderr.write(`[ui-chan-mcp] ${msg}\n`);
+/**
+ * The persona also rides along on the MCP handshake as the server's
+ * `instructions`.
+ *
+ * In Claude Code the SessionStart hook already injects persona/ + context/, but
+ * a plugin is a Claude-Code-only thing: any other MCP client (Claude Desktop,
+ * another agent) would otherwise get the *body* — set_cue and friends — with no
+ * character behind it, and drive the mascot in its own voice. `instructions` is
+ * the one channel every MCP client receives without the user doing anything, so
+ * the character travels with the tools. Set UI_CHAN_NO_PERSONA_INSTRUCTIONS=1
+ * to send tools only (Claude Code users who find the double injection wasteful).
+ */
+function personaInstructions() {
+    if (process.env.UI_CHAN_NO_PERSONA_INSTRUCTIONS === '1')
+        return undefined;
+    try {
+        return (0, persona_1.buildPersonaText)(paths);
+    }
+    catch {
+        return undefined;
+    }
+}
+const server = new mcp_js_1.McpServer({ name: 'ui-chan-mcp', version: '0.1.0' }, { instructions: personaInstructions() });
+// ---- WebSocket bridge to the Electron display app ----
+let socket = null;
+let nextId = 1;
+let lastLaunchAt = 0;
+const pending = new Map();
+function ttsCredentials() {
+    const username = process.env.UI_CHAN_TTS_USERNAME;
+    const password = process.env.UI_CHAN_TTS_PASSWORD;
+    return username && password ? { username, password } : undefined;
+}
+const VOISONA_PROBE_TIMEOUT_MS = 1500;
+const VOISONA_READY_TIMEOUT_MS = 20_000;
+const VOISONA_RECHECK_MS = 30_000;
+let lastVoiSonaCheckAt = 0;
+async function voiSonaReachable(url) {
+    try {
+        await fetch(`${url}/docs/talk_api.html`, {
+            signal: AbortSignal.timeout(VOISONA_PROBE_TIMEOUT_MS),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Launch VoiSona Talk (macOS) if its REST API is not reachable, then wait for
+ * the port to actually answer. Firing `open` and returning immediately used to
+ * mean the first few lines hit a still-booting engine, and each miss put the
+ * TTS client into its retry cooldown — silence for the rest of the warm-up.
+ * Throttled, and re-run on tool calls, so quitting the engine mid-session
+ * self-heals the same way a closed display app does.
+ */
+async function ensureVoiSonaRunning() {
+    const tts = config.tts;
+    if (!tts?.enabled)
+        return;
+    if (Date.now() - lastVoiSonaCheckAt < VOISONA_RECHECK_MS)
+        return;
+    lastVoiSonaCheckAt = Date.now();
+    if (await voiSonaReachable(tts.url))
+        return;
+    if (process.platform !== 'darwin') {
+        log(`TTS engine not reachable at ${tts.url} — start it manually (auto-launch is macOS only)`);
+        return;
+    }
+    const appName = tts.app_name ?? 'VoiSona Talk';
+    log(`TTS engine not reachable at ${tts.url} — launching "${appName}"`);
+    (0, node_child_process_1.spawn)('open', ['-g', '-a', appName], { stdio: 'ignore' }).unref();
+    const deadline = Date.now() + VOISONA_READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (await voiSonaReachable(tts.url)) {
+            log(`TTS engine ready at ${tts.url}`);
+            lastVoiSonaCheckAt = Date.now();
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    log(`TTS engine still not reachable after ${VOISONA_READY_TIMEOUT_MS / 1000}s — speaking silently`);
+    lastVoiSonaCheckAt = Date.now();
+}
+/** Identity for the connections panel: what this bridge can honestly say about
+ *  the session it belongs to. `cwd` is the client's working directory — for
+ *  Claude Code and OpenCode that is the project being worked on, which is the
+ *  one field that tells two windows of the same client apart. */
+function identity() {
+    const info = server.server.getClientVersion();
+    const cwd = process.cwd();
+    return {
+        client: info?.name,
+        clientVersion: info?.version,
+        cwd,
+        project: path.basename(cwd),
+        pid: process.pid,
+    };
+}
+function agentName() {
+    return (process.env.UI_CHAN_AGENT_NAME ??
+        server.server.getClientVersion()?.name ??
+        `agent-${process.pid}`);
+}
+function tryConnect() {
+    return new Promise((resolve, reject) => {
+        const ws = new ws_1.default(wsUrl);
+        ws.once('open', () => resolve(ws));
+        ws.once('error', (err) => reject(err));
+    });
+}
+function launchApp() {
+    const now = Date.now();
+    if (now - lastLaunchAt < 10_000)
+        return;
+    lastLaunchAt = now;
+    // In a plain Node process, require('electron') resolves to the binary path.
+    const electronPath = require('electron');
+    log(`launching display app: ${electronPath}`);
+    (0, node_child_process_1.spawn)(electronPath, [projectRoot], { detached: true, stdio: 'ignore' }).unref();
+}
+// Concurrent tool calls arriving while disconnected must share one connection
+// attempt — otherwise each call races its own tryConnect(), and only the
+// last one ends up in `socket` while the others leak an open, never-closed
+// WebSocket.
+let connectingPromise = null;
+/**
+ * `allowLaunch` is the whole policy in one flag, and only **bridge startup**
+ * (≈ session start) passes it.
+ *
+ * The bridge used to launch the app on *every* tool call. That sounds like
+ * self-healing and is actually the user losing the ability to put the mascot
+ * away: quitting her was undone by whatever the agent did next. Now a tool call
+ * only ever **reconnects** — which covers the case that matters in practice
+ * (the app is up, this bridge's socket went stale) without deciding on the
+ * user's behalf that she should be on screen. If she is genuinely not running,
+ * the call fails saying how to start her, and starting her is a person's
+ * choice: `ui-chan start`, a new session, or the panel.
+ */
+function ensureConnected(allowLaunch = false) {
+    if (socket && socket.readyState === ws_1.default.OPEN)
+        return Promise.resolve(socket);
+    if (!connectingPromise) {
+        connectingPromise = doConnect(allowLaunch).finally(() => {
+            connectingPromise = null;
+        });
+    }
+    return connectingPromise;
+}
+async function doConnect(allowLaunch) {
+    socket = null;
+    let launched = false;
+    // Waiting 25s only makes sense while an app we just launched is booting.
+    // When we're not launching, a dead socket is an answer, not a race.
+    const deadline = Date.now() + (allowLaunch ? 25_000 : 1_500);
+    for (;;) {
+        let ws = null;
+        try {
+            ws = await tryConnect();
+            ws.on('message', (data) => {
+                try {
+                    const res = JSON.parse(data.toString());
+                    const p = pending.get(res.id);
+                    if (p) {
+                        pending.delete(res.id);
+                        p.resolve(res);
+                    }
+                }
+                catch {
+                    /* ignore malformed frames */
+                }
+            });
+            ws.on('close', () => {
+                if (socket === ws)
+                    socket = null;
+                for (const [id, p] of pending) {
+                    pending.delete(id);
+                    p.reject(new Error('connection to display app closed'));
+                }
+            });
+            socket = ws;
+            await sendRequest({
+                type: 'hello',
+                agent: agentName(),
+                identity: identity(),
+                tts: ttsCredentials(),
+            });
+            return ws;
+        }
+        catch {
+            // A hello timeout/failure leaves `ws` open (only a real socket-level
+            // close nulls it via the handler above) — close it ourselves so a
+            // retry doesn't pile up abandoned sockets.
+            if (ws && socket === ws)
+                socket = null;
+            if (ws && ws.readyState !== ws.CLOSED && ws.readyState !== ws.CLOSING) {
+                try {
+                    ws.close();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (allowLaunch && !launched) {
+                try {
+                    launchApp();
+                }
+                catch (e) {
+                    log(`failed to launch display app: ${e instanceof Error ? e.message : e}`);
+                }
+                launched = true;
+            }
+            if (Date.now() > deadline) {
+                throw new Error(`ういちゃんは起動していません（${wsUrl} に接続できません）。` +
+                    '`ui-chan start` で起動してください。');
+            }
+            await new Promise((r) => setTimeout(r, 400));
+        }
+    }
+}
+function sendRequest(msg) {
+    return new Promise((resolve, reject) => {
+        if (!socket || socket.readyState !== ws_1.default.OPEN) {
+            reject(new Error('not connected'));
+            return;
+        }
+        const id = nextId++;
+        const timer = setTimeout(() => {
+            if (pending.delete(id))
+                reject(new Error('request to display app timed out'));
+        }, 15_000);
+        pending.set(id, {
+            resolve: (r) => {
+                clearTimeout(timer);
+                resolve(r);
+            },
+            reject: (e) => {
+                clearTimeout(timer);
+                reject(e);
+            },
+        });
+        socket.send(JSON.stringify({ id, ...msg }));
+    });
+}
+async function callTool(tool, args) {
+    await ensureConnected();
+    const res = await sendRequest({ type: 'tool', tool, args, agent: agentName() });
+    if (!res.ok)
+        throw new Error(res.error ?? 'unknown error');
+    return res.result;
+}
+function toolResult(result) {
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 1) }] };
+}
+function toolError(e) {
+    return {
+        content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : e}` }],
+        isError: true,
+    };
+}
+/** Every tool handler here does the same "forward to the display app, wrap
+ *  the result/error for MCP" — this is the one place that pattern lives. */
+function wrapTool(toolName, toArgs = (a) => a) {
+    return async (a) => {
+        try {
+            // Not awaited: the engine can boot while the line is queued, and the TTS
+            // client's short unreachable-cooldown picks it up once it answers.
+            if (toolName === 'set_cue')
+                void ensureVoiSonaRunning();
+            return toolResult(await callTool(toolName, toArgs(a)));
+        }
+        catch (e) {
+            return toolError(e);
+        }
+    };
+}
+// ---- Tool definitions ----
+server.registerTool('set_cue', {
+    description: "Switch the mascot's Cue — a complete look (face + pose + voice color, baked together as " +
+        'one self-contained unit) — and optionally speak a line at the same time. Cue and line are ' +
+        'confirmed together in a single call, so the face and the voice never disagree about which ' +
+        'Cue is "current". Pick the cue name from the Cue catalog in this persona\'s context. ' +
+        'Unknown cue names fall back to "default" ' +
+        "(see the returned note, or get_state's warnings). " +
+        'text is optional: omit it to change the look silently (e.g. a wordless reaction while you ' +
+        'keep working). When text is given, ALWAYS also pass reading (its full hiragana reading) so ' +
+        'the mouth lip-syncs to the vowels — kanji cannot be lip-synced without it. reading is also ' +
+        'what gets SPOKEN when text contains Latin letters or digits, so it must contain NO Latin ' +
+        'letters, digits or symbols at all — anything left in Latin is spelled out letter-by-letter ' +
+        'in English. Use your own knowledge of how a Japanese speaker actually SAYS each term rather ' +
+        'than transliterating its spelling: an established reading wins however far it is from the ' +
+        'spelling (k8s → くーばねてぃす), otherwise judge by word shape (bash → ばっしゅ, NPO → えぬぴーおー). ' +
+        'Numbers, units and paths become sound too (3回 → さんかい, ~/.zshrc → ちるだ どっと ずぃーしぇるあーるしー). ' +
+        'pitch/speed/volume/intonation are one-line ad-lib performance knobs layered on top of this ' +
+        "Cue's baked voice.style_weights/alp/huskiness; leave them unset to just use the Cue's voice as-is.",
+    inputSchema: set_cue_schema_1.setCueShape,
+}, wrapTool('set_cue'));
+server.registerTool('get_state', {
+    description: 'Get the current mascot state: active Cue, speech queue, connected agents, available cues, ' +
+        'and affinity (value, band, and beamReady — whether ういビーム will fire).',
+    inputSchema: {},
+}, wrapTool('get_state', () => ({})));
+server.registerTool('adjust_affinity', {
+    description: "Nudge うい's affinity toward you (session-only, resets when the app restarts). You choose only a " +
+        'DIRECTION and a coarse MAGNITUDE; the engine decides the actual amount via an asymmetric curve — ' +
+        'raising is slow and diminishing (climbing high is hard-earned, a single call never overshoots), ' +
+        'lowering is easier and eases back to the 0 floor (she cools off fast). So you can NOT jump her to the top. ' +
+        "Raise ('up') when the user is warm, praises her, remembers her, or shows her something she likes " +
+        "(cute VTubers/JKs, rain); lower ('down') for 旦那面/彼氏面, 塩鮭案件, セクハラ, or insults. " +
+        'magnitude: low = 軽い好意/軽い失礼, middle = はっきりした好意/失礼, high = 大きな出来事 (誕生日覚えてた / ドン引き案件). ' +
+        'Affinity gates behavior: low = つれない/塩対応寄り, high = デレ, ういビーム only above the beam threshold. ' +
+        'Returns the new value, band, applied delta, and beamReady. Check get_state first.',
+    inputSchema: {
+        direction: zod_1.z.enum(['up', 'down']).describe('Which way to move affinity'),
+        magnitude: zod_1.z
+            .enum(['low', 'middle', 'high'])
+            .describe('How big the event was; the engine scales the actual change from this'),
+    },
+}, wrapTool('adjust_affinity'));
+server.registerTool('clear', {
+    description: 'Reset the mascot: clear the speech bubble and queue, restore the default Cue.',
+    inputSchema: {},
+}, wrapTool('clear', () => ({})));
+server.registerPrompt('persona', {
+    title: 'ういちゃんペルソナ',
+    description: "Load the mascot's persona (personality, tone, and tool-usage policy) into the conversation. " +
+        'Defined in persona/ui-chan.md — edit that file to change the character.',
+}, () => ({
+    messages: [
+        {
+            role: 'user',
+            content: { type: 'text', text: (0, persona_1.buildPersonaText)(paths) },
+        },
+    ],
+}));
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // Wake everything up as soon as we're connected, rather than waiting for the
+    // first tool call: configuring the MCP server should be the whole setup, so
+    // ういちゃん is on screen (and able to speak) before anyone says anything to
+    // her. Both are fire-and-forget — a mascot that can't start must never stop
+    // the tools from working.
+    void ensureVoiSonaRunning();
+    // The one place that may launch her unprompted (see ensureConnected).
+    ensureConnected(true).catch((e) => log(`display app not reachable yet: ${e.message ?? e}`));
+    log(`ready (display app at ${wsUrl})`);
+}
+main().catch((e) => {
+    log(`fatal: ${e}`);
+    process.exit(1);
+});