agent-sin 0.1.11 → 0.1.15

package/dist/even-g2/gateway.js

@@ -0,0 +1,868 @@
+import http from "node:http";
+import path from "node:path";
+import crypto from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import WebSocket, { WebSocketServer } from "ws";
+import { appendEventLog } from "../core/logger.js";
+import { stripInternalControlBlocks, } from "../core/chat-engine.js";
+import { createIntentRuntime, } from "../builder/build-flow.js";
+import { loadIntentRuntimeMap, saveIntentRuntimeMap, } from "../builder/intent-runtime-store.js";
+import { routeConversationMessage, } from "../builder/conversation-router.js";
+import { notify } from "../core/notifier.js";
+import { getApiKeys } from "../core/secrets.js";
+import { inferLocaleFromText, withLocale } from "../core/i18n.js";
+const DEFAULT_PORT = 8765;
+const DEFAULT_HOST = "127.0.0.1";
+const HISTORY_LIMIT = 20;
+const INBOX_LIMIT = 50;
+const REQUEST_BODY_LIMIT = 16 * 1024 * 1024;
+const AUDIO_BODY_LIMIT = 24 * 1024 * 1024;
+const DISCORD_API_BASE = "https://discord.com/api/v10";
+const DISCORD_PUBLIC_THREAD = 11;
+export async function startEvenG2Gateway(config, options = {}) {
+    const host = options.host || process.env.AGENT_SIN_G2_HOST || DEFAULT_HOST;
+    const port = options.port ?? numberFromEnv("AGENT_SIN_G2_PORT", DEFAULT_PORT);
+    const token = options.token ?? process.env.AGENT_SIN_G2_TOKEN ?? "";
+    const historyChannel = options.historyChannel || process.env.AGENT_SIN_G2_HISTORY_CHANNEL || "";
+    if (!isLoopbackHost(host) && !token) {
+        throw new Error("AGENT_SIN_G2_TOKEN is required when binding the G2 gateway outside localhost.");
+    }
+    const dir = path.join(config.workspace, "even-g2");
+    const state = {
+        config,
+        histories: await loadG2Histories(path.join(dir, "histories.json")),
+        historiesFile: path.join(dir, "histories.json"),
+        intentRuntimes: await loadIntentRuntimeMap(path.join(dir, "intent-runtimes.json"), "chats"),
+        intentRuntimesFile: path.join(dir, "intent-runtimes.json"),
+        inbox: await loadG2Inbox(path.join(dir, "inbox.json")),
+        inboxFile: path.join(dir, "inbox.json"),
+        discordThreadId: await loadG2DiscordThreadId(path.join(dir, "discord-thread.json")),
+        discordThreadFile: path.join(dir, "discord-thread.json"),
+        clients: new Set(),
+        historyChannel,
+    };
+    const server = http.createServer((request, response) => {
+        void handleHttpRequest(state, token, request, response);
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (request, socket, head) => {
+        const url = new URL(request.url || "/", `http://${request.headers.host || "localhost"}`);
+        if (url.pathname !== "/ws" || !isAuthorized(token, request, url)) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit("connection", ws, request);
+        });
+    });
+    wss.on("connection", (ws) => {
+        state.clients.add(ws);
+        sendWs(ws, {
+            type: "hello",
+            inbox: unreadInbox(state),
+            message: "connected",
+        });
+        ws.on("message", (data) => {
+            void handleWsMessage(state, ws, data);
+        });
+        ws.on("close", () => {
+            state.clients.delete(ws);
+        });
+        ws.on("error", () => {
+            state.clients.delete(ws);
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const actual = server.address();
+    const actualPort = typeof actual === "object" && actual ? actual.port : port;
+    const urlHost = host === "0.0.0.0" ? localLanHint() || host : host;
+    const url = `http://${urlHost}:${actualPort}`;
+    await appendEventLog(config, {
+        level: "info",
+        source: "g2",
+        event: "gateway_started",
+        message: url,
+        details: { host, port: actualPort, auth: Boolean(token), history_channel: historyChannel || "none" },
+    });
+    return {
+        host,
+        port: actualPort,
+        url,
+        close: () => new Promise((resolve) => {
+            for (const client of state.clients) {
+                client.close();
+            }
+            wss.close(() => {
+                server.close(() => resolve());
+            });
+        }),
+    };
+}
+export async function runEvenG2Gateway(config, options = {}) {
+    const handle = await startEvenG2Gateway(config, options);
+    console.log(`agent-sin g2: listening on ${handle.url}`);
+    if (!process.env.AGENT_SIN_G2_TOKEN && isLoopbackHost(handle.host)) {
+        console.log("agent-sin g2: auth token is not set; localhost-only access is allowed.");
+    }
+    if (handle.host === "0.0.0.0" && handle.url.includes("0.0.0.0")) {
+        console.log("agent-sin g2: set --host to your LAN IP for the QR URL if needed.");
+    }
+    let stopping = false;
+    const shutdown = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        void handle.close().then(() => {
+            console.log("agent-sin g2: stopped");
+            process.exit(0);
+        });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    await new Promise(() => undefined);
+    return 0;
+}
+async function handleHttpRequest(state, token, request, response) {
+    setCors(response);
+    if (request.method === "OPTIONS") {
+        response.writeHead(204);
+        response.end();
+        return;
+    }
+    const url = new URL(request.url || "/", `http://${request.headers.host || "localhost"}`);
+    try {
+        if (request.method === "GET" && url.pathname === "/") {
+            sendHtml(response, browserConsoleHtml());
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/health") {
+            sendJson(response, 200, {
+                ok: true,
+                clients: state.clients.size,
+                unread: unreadInbox(state).length,
+            });
+            return;
+        }
+        if (!isAuthorized(token, request, url)) {
+            sendJson(response, 401, { ok: false, error: "unauthorized" });
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/api/inbox") {
+            sendJson(response, 200, { ok: true, notifications: unreadInbox(state) });
+            return;
+        }
+        if (request.method === "POST" && url.pathname === "/api/ack") {
+            const body = await readJsonBody(request);
+            await ackNotification(state, stringField(body, "id"));
+            sendJson(response, 200, { ok: true });
+            return;
+        }
+        if (request.method === "POST" && url.pathname === "/api/notify") {
+            const body = await readJsonBody(request);
+            const notification = await addNotification(state, {
+                title: stringField(body, "title") || "Agent-Sin",
+                body: stringField(body, "body"),
+                subtitle: stringField(body, "subtitle") || undefined,
+            });
+            await mirrorText(state, "notification", formatNotificationForMirror(notification));
+            sendJson(response, 200, { ok: true, notification });
+            return;
+        }
+        if (request.method === "POST" && url.pathname === "/api/message") {
+            const body = await readJsonBody(request);
+            const result = await handleG2UserMessage(state, {
+                text: stringField(body, "text"),
+                conversationId: stringField(body, "conversation_id") || "g2",
+                inputMode: stringField(body, "input_mode") || "text",
+            });
+            sendJson(response, 200, { ok: true, ...result });
+            return;
+        }
+        if (request.method === "POST" && url.pathname === "/api/audio-message") {
+            const body = await readJsonBody(request, AUDIO_BODY_LIMIT);
+            const transcript = stringField(body, "text") || await transcribeAudioJson(body);
+            const result = await handleG2UserMessage(state, {
+                text: transcript,
+                conversationId: stringField(body, "conversation_id") || "g2",
+                inputMode: "voice",
+            });
+            sendJson(response, 200, { ok: true, transcript, ...result });
+            return;
+        }
+        sendJson(response, 404, { ok: false, error: "not_found" });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await appendEventLog(state.config, {
+            level: "error",
+            source: "g2",
+            event: "request_failed",
+            message: message.slice(0, 200),
+            details: { path: url.pathname, method: request.method },
+        });
+        sendJson(response, 500, { ok: false, error: message });
+    }
+}
+async function handleWsMessage(state, ws, data) {
+    let message;
+    try {
+        message = JSON.parse(data.toString());
+    }
+    catch {
+        sendWs(ws, { type: "error", error: "invalid_json" });
+        return;
+    }
+    const type = stringField(message, "type");
+    try {
+        if (type === "message") {
+            sendWs(ws, { type: "thinking" });
+            const result = await handleG2UserMessage(state, {
+                text: stringField(message, "text"),
+                conversationId: stringField(message, "conversation_id") || "g2",
+                inputMode: stringField(message, "input_mode") || "text",
+            });
+            sendWs(ws, { type: "reply", ...result });
+            return;
+        }
+        if (type === "audio") {
+            sendWs(ws, { type: "transcribing" });
+            const transcript = stringField(message, "text") || await transcribeAudioJson(message);
+            sendWs(ws, { type: "transcript", text: transcript });
+            const result = await handleG2UserMessage(state, {
+                text: transcript,
+                conversationId: stringField(message, "conversation_id") || "g2",
+                inputMode: "voice",
+            });
+            sendWs(ws, { type: "reply", transcript, ...result });
+            return;
+        }
+        if (type === "ack") {
+            await ackNotification(state, stringField(message, "id"));
+            sendWs(ws, { type: "ack", ok: true });
+            return;
+        }
+        sendWs(ws, { type: "error", error: "unknown_type" });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        sendWs(ws, { type: "error", error: detail });
+    }
+}
+async function handleG2UserMessage(state, input) {
+    const text = input.text.trim();
+    if (!text) {
+        throw new Error("message text is required");
+    }
+    const conversationId = normalizeConversationId(input.conversationId);
+    let history = state.histories.get(conversationId);
+    if (!history) {
+        history = [];
+        state.histories.set(conversationId, history);
+    }
+    let intentRuntime = state.intentRuntimes.get(conversationId);
+    if (!intentRuntime) {
+        intentRuntime = createIntentRuntime(true);
+        state.intentRuntimes.set(conversationId, intentRuntime);
+    }
+    await mirrorText(state, "user", `G2から:\n${text}`);
+    const lines = await withLocale(inferLocaleFromText(text), () => routeConversationMessage({
+        config: state.config,
+        text,
+        history,
+        intentRuntime,
+        eventSource: "g2",
+        createBuildProgress: () => createG2BuildProgressReporter(state),
+        onChatProgress: (event) => broadcastProgress(state, event),
+    }));
+    trimHistory(history);
+    await saveG2Histories(state);
+    await saveIntentRuntimeMap(state.intentRuntimesFile, "chats", state.intentRuntimes);
+    const reply = stripInternalControlBlocks(lines.join("\n")).trim() || "(no response)";
+    const display = compactForG2(reply);
+    await mirrorText(state, "assistant", `Agent:\n${reply}`);
+    broadcast(state, { type: "reply_broadcast", text, reply, display, input_mode: input.inputMode });
+    return { text, reply, display };
+}
+function createG2BuildProgressReporter(state) {
+    const messages = [];
+    return {
+        onProgress(event) {
+            const text = progressText(event);
+            if (!text)
+                return;
+            messages.push(text);
+            broadcast(state, { type: "build_progress", text });
+        },
+        async flush() {
+            if (messages.length === 0)
+                return;
+            await appendEventLog(state.config, {
+                level: "info",
+                source: "g2",
+                event: "build_progress",
+                message: messages[messages.length - 1].slice(0, 200),
+                details: { count: messages.length },
+            });
+        },
+    };
+}
+function broadcastProgress(state, event) {
+    if (event.kind === "thinking") {
+        broadcast(state, { type: "progress", text: "thinking" });
+    }
+    else if (event.kind === "tool_running") {
+        broadcast(state, { type: "progress", text: `tool:${event.skill_id}` });
+    }
+    else if (event.kind === "model_failed") {
+        broadcast(state, { type: "progress", text: "model_failed" });
+    }
+}
+function progressText(event) {
+    if (event.kind === "thinking")
+        return event.text || "Thinking";
+    if (event.kind === "tool")
+        return event.text || event.name || "Running tool";
+    if (event.kind === "message")
+        return event.text || "";
+    if (event.kind === "info")
+        return event.text;
+    if (event.kind === "stderr")
+        return event.text;
+    return "";
+}
+async function addNotification(state, input) {
+    const notification = {
+        id: crypto.randomUUID(),
+        title: input.title.trim() || "Agent-Sin",
+        body: input.body.trim(),
+        subtitle: input.subtitle?.trim() || undefined,
+        created_at: new Date().toISOString(),
+        read: false,
+    };
+    state.inbox.unshift(notification);
+    state.inbox = state.inbox.slice(0, INBOX_LIMIT);
+    await saveG2Inbox(state);
+    broadcast(state, { type: "notification", notification });
+    return notification;
+}
+async function ackNotification(state, id) {
+    if (!id)
+        return;
+    let changed = false;
+    for (const item of state.inbox) {
+        if (item.id === id && !item.read) {
+            item.read = true;
+            changed = true;
+        }
+    }
+    if (changed) {
+        await saveG2Inbox(state);
+        broadcast(state, { type: "inbox", notifications: unreadInbox(state) });
+    }
+}
+function unreadInbox(state) {
+    return state.inbox.filter((item) => !item.read);
+}
+async function mirrorText(state, kind, body) {
+    const channels = configuredMirrorChannels(state.historyChannel);
+    if (channels.length === 0)
+        return;
+    for (const channel of channels) {
+        const discordThreadId = channel === "discord" ? await resolveG2DiscordThreadId(state) : undefined;
+        const result = await notify({
+            channel,
+            title: kind === "notification" ? "G2通知" : "G2 Agent",
+            body,
+            discordThreadId,
+        });
+        if (!result.ok) {
+            await appendEventLog(state.config, {
+                level: "warn",
+                source: "g2",
+                event: "mirror_failed",
+                message: `${channel}: ${result.detail || "failed"}`,
+            });
+        }
+    }
+}
+async function resolveG2DiscordThreadId(state) {
+    const explicit = normalizeDiscordSnowflake(firstListValue(process.env.AGENT_SIN_G2_DISCORD_THREAD_ID));
+    if (explicit)
+        return explicit;
+    if (!shouldAutoCreateG2DiscordThread())
+        return undefined;
+    if (state.discordThreadId)
+        return state.discordThreadId;
+    const token = (process.env.AGENT_SIN_DISCORD_BOT_TOKEN || "").trim();
+    const parentChannelId = g2DiscordThreadParentChannelId();
+    if (!token || !parentChannelId) {
+        await appendEventLog(state.config, {
+            level: "warn",
+            source: "g2",
+            event: "discord_thread_skipped",
+            message: "Discord bot token or parent channel id is missing",
+        });
+        return undefined;
+    }
+    const thread = await createG2DiscordThread(state, token, parentChannelId);
+    if (!thread)
+        return undefined;
+    state.discordThreadId = thread.id;
+    await saveG2DiscordThread(state, thread);
+    return thread.id;
+}
+function shouldAutoCreateG2DiscordThread() {
+    const raw = firstListValue(process.env.AGENT_SIN_G2_DISCORD_THREAD || process.env.AGENT_SIN_G2_DISCORD_THREAD_ID)
+        .toLowerCase();
+    return raw === "auto" || raw === "create" || raw === "1" || raw === "true" || raw === "yes";
+}
+function g2DiscordThreadParentChannelId() {
+    return normalizeDiscordSnowflake(firstListValue(process.env.AGENT_SIN_G2_DISCORD_THREAD_PARENT_CHANNEL_ID) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_NOTIFY_CHANNEL_ID) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_CHANNEL_ID) ||
+        firstListValue(process.env.AGENT_SIN_DISCORD_LISTEN_CHANNEL_IDS));
+}
+async function createG2DiscordThread(state, token, parentChannelId) {
+    const name = makeG2DiscordThreadName();
+    const archiveMinutes = numberFromEnv("AGENT_SIN_G2_DISCORD_THREAD_ARCHIVE_MINUTES", 10080);
+    try {
+        const response = await fetch(`${DISCORD_API_BASE}/channels/${parentChannelId}/threads`, {
+            method: "POST",
+            headers: {
+                authorization: `Bot ${token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                name,
+                auto_archive_duration: archiveMinutes,
+                type: DISCORD_PUBLIC_THREAD,
+            }),
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => "");
+            await appendEventLog(state.config, {
+                level: "warn",
+                source: "g2",
+                event: "discord_thread_create_failed",
+                message: `HTTP ${response.status}`,
+                details: { parent_channel_id: parentChannelId, detail: detail.slice(0, 300) },
+            });
+            return null;
+        }
+        const json = await response.json();
+        const id = normalizeDiscordSnowflake(typeof json.id === "string" ? json.id : "");
+        if (!id) {
+            await appendEventLog(state.config, {
+                level: "warn",
+                source: "g2",
+                event: "discord_thread_create_failed",
+                message: "Discord response did not include a thread id",
+                details: { parent_channel_id: parentChannelId },
+            });
+            return null;
+        }
+        return {
+            id,
+            parent_channel_id: typeof json.parent_id === "string" ? json.parent_id : parentChannelId,
+            name: typeof json.name === "string" ? json.name : name,
+        };
+    }
+    catch (error) {
+        await appendEventLog(state.config, {
+            level: "warn",
+            source: "g2",
+            event: "discord_thread_create_failed",
+            message: error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200),
+            details: { parent_channel_id: parentChannelId },
+        });
+        return null;
+    }
+}
+function makeG2DiscordThreadName() {
+    const raw = (process.env.AGENT_SIN_G2_DISCORD_THREAD_NAME || `Agent-Sin G2 ${new Date().toISOString().slice(0, 10)}`)
+        .replace(/[\r\n]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const name = raw || "Agent-Sin G2";
+    return name.length <= 95 ? name : `${name.slice(0, 95).trimEnd()}…`;
+}
+function normalizeDiscordSnowflake(value) {
+    const trimmed = value.trim();
+    return /^\d+$/.test(trimmed) ? trimmed : "";
+}
+function configuredMirrorChannels(historyChannel) {
+    const selected = (historyChannel || process.env.AGENT_SIN_G2_HISTORY_CHANNEL || "").trim();
+    if (selected) {
+        return historyChannelsFromSetting(selected);
+    }
+    const legacy = process.env.AGENT_SIN_G2_MIRROR_CHANNELS;
+    if (legacy) {
+        return historyChannelsFromSetting(legacy);
+    }
+    return [];
+}
+function historyChannelsFromSetting(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (/^(none|off|false|0)$/i.test(normalized)) {
+        return [];
+    }
+    if (normalized === "auto") {
+        return autoHistoryChannel();
+    }
+    const channels = normalized
+        .split(/[,\s]+/)
+        .map((item) => item.trim())
+        .filter((item) => item === "discord" || item === "telegram");
+    return Array.from(new Set(channels));
+}
+function autoHistoryChannel() {
+    if (hasTelegramNotifyConfig())
+        return ["telegram"];
+    if (hasDiscordNotifyConfig())
+        return ["discord"];
+    return [];
+}
+function hasDiscordNotifyConfig() {
+    return Boolean(process.env.AGENT_SIN_DISCORD_WEBHOOK_URL ||
+        (process.env.AGENT_SIN_DISCORD_BOT_TOKEN &&
+            (firstListValue(process.env.AGENT_SIN_DISCORD_NOTIFY_THREAD_ID) ||
+                firstListValue(process.env.AGENT_SIN_DISCORD_THREAD_ID) ||
+                firstListValue(process.env.AGENT_SIN_DISCORD_NOTIFY_CHANNEL_ID) ||
+                firstListValue(process.env.AGENT_SIN_DISCORD_CHANNEL_ID) ||
+                firstListValue(process.env.AGENT_SIN_DISCORD_LISTEN_CHANNEL_IDS))));
+}
+function hasTelegramNotifyConfig() {
+    return Boolean(process.env.AGENT_SIN_TELEGRAM_BOT_TOKEN &&
+        (firstListValue(process.env.AGENT_SIN_TELEGRAM_NOTIFY_CHAT_ID) ||
+            firstListValue(process.env.AGENT_SIN_TELEGRAM_CHAT_ID) ||
+            firstListValue(process.env.AGENT_SIN_TELEGRAM_LISTEN_CHAT_IDS)));
+}
+function firstListValue(value) {
+    return (value || "")
+        .split(/[,\s]+/)
+        .map((item) => item.trim())
+        .find(Boolean) || "";
+}
+async function transcribeAudioJson(body) {
+    const audio = audioBufferFromJson(body);
+    if (audio.length === 0) {
+        throw new Error("audio data is required");
+    }
+    const sampleRate = numericField(body, "sample_rate") || numericField(body, "sampleRate") || 16000;
+    const channels = numericField(body, "channels") || 1;
+    const format = stringField(body, "format") || "pcm16";
+    const wav = format === "wav" ? audio : wavFromPcm16(audio, sampleRate, channels);
+    return transcribeWavWithOpenAI(wav, {
+        language: stringField(body, "language") || process.env.AGENT_SIN_G2_STT_LANGUAGE || "ja",
+        prompt: stringField(body, "prompt") || process.env.AGENT_SIN_G2_STT_PROMPT || "",
+    });
+}
+function audioBufferFromJson(body) {
+    const wavBase64 = stringField(body, "wavBase64") || stringField(body, "audioBase64");
+    if (wavBase64)
+        return decodeBase64(wavBase64);
+    const pcmBase64 = stringField(body, "pcmBase64") || stringField(body, "pcm_base64");
+    if (pcmBase64)
+        return decodeBase64(pcmBase64);
+    const pcm = body.pcm;
+    if (Array.isArray(pcm)) {
+        const bytes = pcm.map((value) => {
+            const n = typeof value === "number" ? value : Number(value);
+            return Number.isFinite(n) ? Math.max(0, Math.min(255, Math.trunc(n))) : 0;
+        });
+        return Buffer.from(bytes);
+    }
+    return Buffer.alloc(0);
+}
+function decodeBase64(value) {
+    const base64 = value.replace(/^data:[^,]+,/, "").replace(/\s+/g, "");
+    return Buffer.from(base64, "base64");
+}
+async function transcribeWavWithOpenAI(wav, options) {
+    const keys = getApiKeys("openai");
+    if (keys.length === 0) {
+        throw new Error("OPENAI_API_KEY is required for G2 voice transcription");
+    }
+    const model = process.env.AGENT_SIN_G2_STT_MODEL || "gpt-4o-mini-transcribe";
+    const form = new FormData();
+    form.set("model", model);
+    form.set("response_format", "json");
+    if (options.language)
+        form.set("language", options.language);
+    if (options.prompt)
+        form.set("prompt", options.prompt);
+    form.set("file", new Blob([new Uint8Array(wav)], { type: "audio/wav" }), "g2.wav");
+    const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: { authorization: `Bearer ${keys[0]}` },
+        body: form,
+    });
+    if (!response.ok) {
+        const detail = await response.text();
+        throw new Error(`OpenAI transcription failed: HTTP ${response.status} ${detail.slice(0, 300)}`);
+    }
+    const json = (await response.json());
+    const text = (json.text || "").trim();
+    if (!text) {
+        throw new Error("transcription was empty");
+    }
+    return text;
+}
+function wavFromPcm16(pcm, sampleRate, channels) {
+    const bitsPerSample = 16;
+    const byteRate = sampleRate * channels * bitsPerSample / 8;
+    const blockAlign = channels * bitsPerSample / 8;
+    const header = Buffer.alloc(44);
+    header.write("RIFF", 0);
+    header.writeUInt32LE(36 + pcm.length, 4);
+    header.write("WAVE", 8);
+    header.write("fmt ", 12);
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(bitsPerSample, 34);
+    header.write("data", 36);
+    header.writeUInt32LE(pcm.length, 40);
+    return Buffer.concat([header, pcm]);
+}
+async function loadG2Histories(file) {
+    try {
+        const raw = await readFile(file, "utf8");
+        const data = JSON.parse(raw);
+        const map = new Map();
+        for (const [key, turns] of Object.entries(data.chats || {})) {
+            if (Array.isArray(turns)) {
+                map.set(key, turns.filter(isChatTurn).slice(-HISTORY_LIMIT));
+            }
+        }
+        return map;
+    }
+    catch {
+        return new Map();
+    }
+}
+async function saveG2Histories(state) {
+    await mkdir(path.dirname(state.historiesFile), { recursive: true });
+    const chats = {};
+    for (const [key, history] of state.histories) {
+        if (history.length > 0) {
+            chats[key] = history.slice(-HISTORY_LIMIT);
+        }
+    }
+    await writeFile(state.historiesFile, `${JSON.stringify({ saved_at: new Date().toISOString(), chats }, null, 2)}\n`, "utf8");
+}
+async function loadG2Inbox(file) {
+    try {
+        const raw = await readFile(file, "utf8");
+        const data = JSON.parse(raw);
+        return Array.isArray(data.notifications)
+            ? data.notifications.filter(isNotification).slice(0, INBOX_LIMIT)
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function saveG2Inbox(state) {
+    await mkdir(path.dirname(state.inboxFile), { recursive: true });
+    await writeFile(state.inboxFile, `${JSON.stringify({ saved_at: new Date().toISOString(), notifications: state.inbox }, null, 2)}\n`, "utf8");
+}
+async function loadG2DiscordThreadId(file) {
+    try {
+        const raw = await readFile(file, "utf8");
+        const data = JSON.parse(raw);
+        return normalizeDiscordSnowflake(typeof data.thread_id === "string" ? data.thread_id : "");
+    }
+    catch {
+        return "";
+    }
+}
+async function saveG2DiscordThread(state, thread) {
+    await mkdir(path.dirname(state.discordThreadFile), { recursive: true });
+    await writeFile(state.discordThreadFile, `${JSON.stringify({
+        thread_id: thread.id,
+        parent_channel_id: thread.parent_channel_id,
+        name: thread.name,
+        saved_at: new Date().toISOString(),
+    }, null, 2)}\n`, "utf8");
+}
+function isChatTurn(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const turn = value;
+    return ((turn.role === "user" || turn.role === "assistant" || turn.role === "tool") &&
+        typeof turn.content === "string");
+}
+function isNotification(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const item = value;
+    return typeof item.id === "string" && typeof item.title === "string" && typeof item.body === "string";
+}
+function trimHistory(history) {
+    while (history.length > HISTORY_LIMIT) {
+        history.shift();
+    }
+}
+function broadcast(state, payload) {
+    for (const client of state.clients) {
+        sendWs(client, payload);
+    }
+}
+function sendWs(ws, payload) {
+    if (ws.readyState !== WebSocket.OPEN)
+        return;
+    ws.send(JSON.stringify(payload));
+}
+function sendJson(response, status, payload) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(payload));
+}
+function sendHtml(response, html) {
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    response.end(html);
+}
+function setCors(response) {
+    response.setHeader("access-control-allow-origin", "*");
+    response.setHeader("access-control-allow-methods", "GET,POST,OPTIONS");
+    response.setHeader("access-control-allow-headers", "content-type,authorization,x-agent-sin-g2-token");
+}
+async function readJsonBody(request, limit = REQUEST_BODY_LIMIT) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buffer.length;
+        if (total > limit) {
+            throw new Error("request body is too large");
+        }
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString("utf8");
+    return JSON.parse(raw);
+}
+function isAuthorized(token, request, url) {
+    if (!token)
+        return true;
+    const authorization = request.headers.authorization || "";
+    if (authorization === `Bearer ${token}`)
+        return true;
+    if (request.headers["x-agent-sin-g2-token"] === token)
+        return true;
+    return url.searchParams.get("token") === token;
+}
+function stringField(source, key) {
+    const value = source[key];
+    return typeof value === "string" ? value : "";
+}
+function numericField(source, key) {
+    const value = source[key];
+    const numeric = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isFinite(numeric) ? numeric : undefined;
+}
+function numberFromEnv(name, fallback) {
+    const value = process.env[name];
+    if (!value)
+        return fallback;
+    const numeric = Number.parseInt(value, 10);
+    return Number.isFinite(numeric) && numeric > 0 ? numeric : fallback;
+}
+function normalizeConversationId(value) {
+    const normalized = value.trim().replace(/[^A-Za-z0-9_.:-]/g, "_").slice(0, 80);
+    return normalized || "g2";
+}
+function compactForG2(text) {
+    const cleaned = text.replace(/\r/g, "").replace(/\n{3,}/g, "\n\n").trim();
+    if (cleaned.length <= 900)
+        return cleaned;
+    return `${cleaned.slice(0, 880).trimEnd()}\n...`;
+}
+function formatNotificationForMirror(notification) {
+    const head = notification.subtitle
+        ? `${notification.title} - ${notification.subtitle}`
+        : notification.title;
+    return `${head}\n${notification.body}`.trim();
+}
+function isLoopbackHost(host) {
+    return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+function localLanHint() {
+    return process.env.AGENT_SIN_G2_PUBLIC_HOST || "";
+}
+function browserConsoleHtml() {
+    return `<!doctype html>
+<html lang="ja">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Agent-Sin G2</title>
+  <style>
+    :root { color-scheme: dark; font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    body { margin: 0; min-height: 100vh; background: #101412; color: #eef6ef; }
+    main { width: min(760px, calc(100vw - 32px)); margin: 0 auto; padding: 32px 0; }
+    h1 { font-size: 24px; line-height: 1.2; margin: 0 0 20px; font-weight: 650; }
+    #log { min-height: 280px; border: 1px solid #38443d; border-radius: 8px; padding: 16px; background: #161d19; overflow-wrap: anywhere; white-space: pre-wrap; }
+    form { display: grid; grid-template-columns: 1fr auto; gap: 8px; margin-top: 12px; }
+    input, button { font: inherit; border-radius: 6px; border: 1px solid #405048; padding: 10px 12px; }
+    input { background: #0e1310; color: #eef6ef; min-width: 0; }
+    button { background: #d7f7d8; color: #102014; cursor: pointer; }
+    .muted { color: #a7b7ad; font-size: 13px; margin-top: 12px; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>Agent-Sin G2</h1>
+    <div id="log">connecting...</div>
+    <form id="form">
+      <input id="text" autocomplete="off" placeholder="G2の代わりにテスト入力">
+      <button>送信</button>
+    </form>
+    <p class="muted">Even G2アプリからは同じゲートウェイにWebSocket/HTTPで接続します。</p>
+  </main>
+  <script>
+    const params = new URLSearchParams(location.search);
+    const token = params.get("token") || localStorage.getItem("agentSinG2Token") || "";
+    if (params.get("token")) localStorage.setItem("agentSinG2Token", token);
+    const log = document.querySelector("#log");
+    const input = document.querySelector("#text");
+    const form = document.querySelector("#form");
+    const wsUrl = new URL("/ws", location.href);
+    wsUrl.protocol = location.protocol === "https:" ? "wss:" : "ws:";
+    if (token) wsUrl.searchParams.set("token", token);
+    const ws = new WebSocket(wsUrl);
+    function add(label, text) {
+      log.textContent += "\\n\\n" + label + "\\n" + text;
+      log.scrollTop = log.scrollHeight;
+    }
+    ws.addEventListener("open", () => { log.textContent = "connected"; });
+    ws.addEventListener("message", (event) => {
+      const msg = JSON.parse(event.data);
+      if (msg.type === "reply") add("Agent", msg.display || msg.reply || "");
+      if (msg.type === "notification") add("通知", msg.notification.title + "\\n" + msg.notification.body);
+      if (msg.type === "thinking") add("status", "thinking...");
+      if (msg.type === "error") add("error", msg.error);
+    });
+    form.addEventListener("submit", (event) => {
+      event.preventDefault();
+      const text = input.value.trim();
+      if (!text) return;
+      add("G2", text);
+      ws.send(JSON.stringify({ type: "message", text }));
+      input.value = "";
+    });
+  </script>
+</body>
+</html>`;
+}