updateday 0.0.0-stage → 0.2.0

package/dist/icons.js

@@ -0,0 +1,216 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import sharp from "sharp";
+import { localizedLabel } from "./labels.js";
+export const ICON_SIZE = 512;
+const THUMBNAIL_URL = "https://thumbnails.roblox.com/v1/games/icons";
+const BUNDLED_OVERLAY_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../assets/hourglass");
+export const STYLE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../assets/hourglass-styles");
+export const HOURGLASS_STYLES = ["original", "classic", "pixel", "rounded", "glow", "blocky", "outline"];
+const ORIGINAL_STYLE = "original";
+const TEXT_WIDTH_LIMIT = 0.94;
+const TEXT_BASELINE_SHIFT = 0.36;
+const OVERLAY_EXTENSIONS = [".png", ".webp", ".svg"];
+const LABEL_FONT = "Arial Black, Arial, Noto Sans, Noto Sans CJK SC, Microsoft YaHei, Malgun Gothic, Yu Gothic, Leelawadee UI, Noto Sans Thai, DejaVu Sans, sans-serif";
+const WIDE_CHAR = /[ᄀ-ᇿ⺀-鿿가-힯豈-﫿＀-￯]/;
+const WIDE_CHAR_SCALE = 1.4;
+const DEFAULT_OVERLAY = "default";
+const LABEL_CHAR_WIDTH = 0.74;
+const LABEL_MAX_FONT_RATIO = 0.2;
+const LABEL_OUTLINE_RATIO = 0.22;
+const DEFAULT_ART_HEIGHT_RATIO = 0.74;
+const EDGE_MARGIN = 12;
+const TRANSPARENT = { r: 0, g: 0, b: 0, alpha: 0 };
+export async function fetchCurrentIcon(universeId) {
+    const query = `?universeIds=${universeId}&size=${ICON_SIZE}x${ICON_SIZE}&format=Png&isCircular=false&returnPolicy=PlaceHolder`;
+    const response = await fetch(THUMBNAIL_URL + query);
+    if (!response.ok) {
+        throw new Error(`Could not look up the game icon (${response.status})`);
+    }
+    const entry = (await response.json()).data?.[0];
+    if (!entry?.imageUrl || entry.state !== "Completed") {
+        throw new Error(`Game icon isn't available yet (state: ${entry?.state ?? "missing"})`);
+    }
+    const image = await fetch(entry.imageUrl);
+    if (!image.ok) {
+        throw new Error(`Could not download the game icon (${image.status})`);
+    }
+    return Buffer.from(await image.arrayBuffer());
+}
+export async function snapshotIcon(universeId, path) {
+    const icon = await sharp(await fetchCurrentIcon(universeId)).resize(ICON_SIZE, ICON_SIZE).png().toBuffer();
+    writeFileSync(path, icon);
+    return icon;
+}
+function findFile(dir, name) {
+    for (const extension of OVERLAY_EXTENSIONS) {
+        const path = join(dir, name + extension);
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    return null;
+}
+function findOverlay(dir, mark) {
+    const exact = findFile(dir, mark);
+    if (exact) {
+        return { path: exact, hasText: true };
+    }
+    const fallback = findFile(dir, "default");
+    return fallback ? { path: fallback, hasText: false } : null;
+}
+export function overlayFor(style, mark) {
+    const userOverlay = style.overlayDir ? findOverlay(style.overlayDir, mark) : null;
+    const overlay = userOverlay ?? findOverlay(BUNDLED_OVERLAY_DIR, mark);
+    if (!overlay) {
+        throw new Error(`No hourglass overlay found for "${mark}"`);
+    }
+    return overlay;
+}
+export function labelText(mark) {
+    if (mark === "now") {
+        return "NOW!";
+    }
+    const match = /^(\d+)([smhd])$/.exec(mark);
+    if (!match) {
+        return mark.toUpperCase();
+    }
+    const count = Number(match[1]);
+    const units = { s: "SEC", m: "MIN", h: "HOUR", d: "DAY" };
+    return `${count} ${units[match[2]]}${count === 1 ? "" : "S"}`;
+}
+function escapeXml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function placement(style) {
+    if (style.anchor === "full") {
+        return { x: 0, y: 0, size: ICON_SIZE };
+    }
+    const size = Math.round(ICON_SIZE * style.scale);
+    const far = ICON_SIZE - EDGE_MARGIN - size;
+    const middle = Math.round((ICON_SIZE - size) / 2);
+    if (style.anchor === "center") {
+        return { x: middle, y: middle, size };
+    }
+    const x = style.anchor.endsWith("right") ? far : EDGE_MARGIN;
+    const y = style.anchor.startsWith("top") ? EDGE_MARGIN : far;
+    return { x, y, size };
+}
+function dimLayer(opacity) {
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${ICON_SIZE}" height="${ICON_SIZE}">
+	<rect width="100%" height="100%" fill="#000000" fill-opacity="${opacity}"/>
+</svg>`;
+    return Buffer.from(svg);
+}
+function visualLength(text) {
+    let length = 0;
+    for (const char of text) {
+        length += WIDE_CHAR.test(char) ? WIDE_CHAR_SCALE : 1;
+    }
+    return length;
+}
+function labelSvg(text, box, style) {
+    const fontSize = Math.round(Math.min(box.size * LABEL_MAX_FONT_RATIO, box.size / (LABEL_CHAR_WIDTH * visualLength(text))));
+    const outline = Math.round(fontSize * LABEL_OUTLINE_RATIO);
+    const centerX = box.x + box.size / 2;
+    const baseline = Math.round(box.y + box.size - outline / 2);
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${ICON_SIZE}" height="${ICON_SIZE}">
+	<text x="${centerX}" y="${baseline}" text-anchor="middle" font-family="${LABEL_FONT}" font-weight="900"
+		font-size="${fontSize}" fill="${style.labelColor}" stroke="${style.labelOutline}" stroke-width="${outline}"
+		stroke-linejoin="round" paint-order="stroke">${escapeXml(text)}</text>
+</svg>`;
+    return Buffer.from(svg);
+}
+function customIcon(dir, mark) {
+    if (!dir) {
+        return null;
+    }
+    const path = join(dir, `${mark}.png`);
+    return existsSync(path) ? path : null;
+}
+function plainIcon(source) {
+    return sharp(source).resize(ICON_SIZE, ICON_SIZE).png().toBuffer();
+}
+function baseFor(original, mark, options) {
+    if (mark === "now" && options.newIcon && options.newIconAt === "now") {
+        return options.newIcon;
+    }
+    return original;
+}
+export async function renderIcon(original, mark, options, languageCode) {
+    if (mark === "final") {
+        return plainIcon(options.newIcon ?? original);
+    }
+    const custom = customIcon(options.customDir, mark);
+    if (custom) {
+        return plainIcon(custom);
+    }
+    const base = await plainIcon(baseFor(original, mark, options));
+    const translated = languageCode && options.localizeLabels !== false ? localizedLabel(mark, languageCode) : null;
+    const ownText = options.labels?.[mark]?.trim() || null;
+    return composeIcon(base, mark, options, translated ?? ownText);
+}
+function usesStyle(style) {
+    return Boolean(style.style) && style.style !== ORIGINAL_STYLE && !style.overlayDir;
+}
+export function stylePath(name) {
+    return join(STYLE_DIR, `${name}.png`);
+}
+function textSvg(text, centerY, sizeRatio, style) {
+    const widest = (ICON_SIZE * TEXT_WIDTH_LIMIT) / (LABEL_CHAR_WIDTH * visualLength(text));
+    const fontSize = Math.round(Math.min(ICON_SIZE * sizeRatio, widest));
+    const outline = Math.round(fontSize * LABEL_OUTLINE_RATIO);
+    const baseline = Math.round(centerY + fontSize * TEXT_BASELINE_SHIFT);
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${ICON_SIZE}" height="${ICON_SIZE}">
+	<text x="${ICON_SIZE / 2}" y="${baseline}" text-anchor="middle" font-family="${LABEL_FONT}" font-weight="900"
+		font-size="${fontSize}" fill="${style.labelColor}" stroke="${style.labelOutline}" stroke-width="${outline}"
+		stroke-linejoin="round" paint-order="stroke">${escapeXml(text)}</text>
+</svg>`;
+    return Buffer.from(svg);
+}
+function clamp(value, low, high) {
+    return Math.min(high, Math.max(low, value));
+}
+async function composeStyled(base, mark, style, labelOverride) {
+    const size = Math.round(ICON_SIZE * clamp(style.hourglassSize ?? 0.66, 0.1, 1));
+    const centerY = ICON_SIZE * clamp(style.hourglassY ?? 0.4, 0, 1);
+    const top = Math.round(clamp(centerY - size / 2, 0, ICON_SIZE - size));
+    const left = Math.round((ICON_SIZE - size) / 2);
+    const art = await sharp(stylePath(style.style)).resize(size, size, { fit: "contain", background: TRANSPARENT }).png().toBuffer();
+    const layers = [];
+    if (style.dim > 0) {
+        layers.push({ input: dimLayer(Math.min(style.dim, 1)) });
+    }
+    layers.push({ input: art, left, top });
+    if (style.label) {
+        layers.push({ input: textSvg(labelOverride || labelText(mark), ICON_SIZE * clamp(style.textY ?? 0.85, 0, 1), clamp(style.textSize ?? 0.15, 0.04, 0.4), style) });
+    }
+    return sharp(base).resize(ICON_SIZE, ICON_SIZE).composite(layers).png().toBuffer();
+}
+export async function composeIcon(base, mark, style, labelOverride) {
+    if (usesStyle(style)) {
+        return composeStyled(base, mark, style, labelOverride);
+    }
+    const overlay = overlayFor(style, labelOverride ? DEFAULT_OVERLAY : mark);
+    const box = placement(style);
+    const drawLabel = Boolean(labelOverride) || (style.label && !overlay.hasText);
+    const artHeight = drawLabel ? Math.round(box.size * DEFAULT_ART_HEIGHT_RATIO) : box.size;
+    const art = await sharp(overlay.path, { density: 300 })
+        .resize(box.size, artHeight, { fit: "contain", background: TRANSPARENT })
+        .png()
+        .toBuffer();
+    const layers = [];
+    if (style.dim > 0) {
+        layers.push({ input: dimLayer(Math.min(style.dim, 1)) });
+    }
+    layers.push({ input: art, left: box.x, top: box.y });
+    if (drawLabel) {
+        layers.push({ input: labelSvg(labelOverride || labelText(mark), box, style) });
+    }
+    return sharp(base)
+        .resize(ICON_SIZE, ICON_SIZE)
+        .composite(layers)
+        .png()
+        .toBuffer();
+}

package/dist/labels.js

@@ -0,0 +1,64 @@
+function simple(one, many) {
+    return (count) => (count === 1 ? one : many);
+}
+function same(word) {
+    return () => word;
+}
+function slavic(one, few, many) {
+    return (count) => {
+        const lastTwo = count % 100;
+        const last = count % 10;
+        if (last === 1 && lastTwo !== 11) {
+            return one;
+        }
+        if (last >= 2 && last <= 4 && (lastTwo < 12 || lastTwo > 14)) {
+            return few;
+        }
+        return many;
+    };
+}
+function polish(one, few, many) {
+    const rule = slavic(one, few, many);
+    return (count) => (count === 1 ? one : count % 10 === 1 ? many : rule(count));
+}
+const LANGUAGES = {
+    de: { hour: simple("STUNDE", "STUNDEN"), minute: simple("MINUTE", "MINUTEN"), now: "JETZT!" },
+    es: { hour: simple("HORA", "HORAS"), minute: simple("MINUTO", "MINUTOS"), now: "¡YA!" },
+    fr: { hour: simple("HEURE", "HEURES"), minute: simple("MINUTE", "MINUTES"), now: "MAINTENANT !" },
+    pt: { hour: simple("HORA", "HORAS"), minute: simple("MINUTO", "MINUTOS"), now: "AGORA!" },
+    it: { hour: simple("ORA", "ORE"), minute: simple("MINUTO", "MINUTI"), now: "ADESSO!" },
+    pl: { hour: polish("GODZINA", "GODZINY", "GODZIN"), minute: polish("MINUTA", "MINUTY", "MINUT"), now: "TERAZ!" },
+    ru: { hour: slavic("ЧАС", "ЧАСА", "ЧАСОВ"), minute: slavic("МИНУТА", "МИНУТЫ", "МИНУТ"), now: "СЕЙЧАС!" },
+    tr: { hour: same("SAAT"), minute: same("DAKİKA"), now: "ŞİMDİ!" },
+    id: { hour: same("JAM"), minute: same("MENIT"), now: "SEKARANG!" },
+    vi: { hour: same("GIỜ"), minute: same("PHÚT"), now: "BẮT ĐẦU!" },
+    th: { hour: same("ชั่วโมง"), minute: same("นาที"), now: "ตอนนี้!" },
+    ja: { hour: same("時間"), minute: same("分"), now: "今すぐ！", joined: true },
+    ko: { hour: same("시간"), minute: same("분"), now: "지금!", joined: true },
+    "zh-hans": { hour: same("小时"), minute: same("分钟"), now: "现在！", joined: true },
+    "zh-hant": { hour: same("小時"), minute: same("分鐘"), now: "現在！", joined: true },
+};
+function unitsFor(languageCode) {
+    const code = languageCode.toLowerCase().replace("_", "-");
+    return LANGUAGES[code] ?? LANGUAGES[code.split("-")[0]] ?? (code.startsWith("zh") ? LANGUAGES["zh-hans"] : null);
+}
+export function localizedLabel(mark, languageCode) {
+    const units = unitsFor(languageCode);
+    if (!units) {
+        return null;
+    }
+    if (mark === "now") {
+        return units.now;
+    }
+    const match = /^(\d+)([mh])$/.exec(mark);
+    if (!match) {
+        return null;
+    }
+    const count = Number(match[1]);
+    const word = match[2] === "h" ? units.hour(count) : units.minute(count);
+    return units.joined ? `${count}${word}` : `${count} ${word}`;
+}
+export function hasTranslation(languageCode) {
+    return unitsFor(languageCode) !== null;
+}
+export const LABEL_LANGUAGES = Object.keys(LANGUAGES);

package/dist/mcp.js

@@ -0,0 +1,302 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import sharp from "sharp";
+import { nextOccurrence, parseConfigs } from "./config.js";
+import { readHistory, recording } from "./history.js";
+import { fetchCurrentIcon, ICON_SIZE, renderIcon } from "./icons.js";
+import { discordNotifier } from "./notify.js";
+import { OpenCloud } from "./openCloud.js";
+import { preflight } from "./preflight.js";
+import { endCountdown, restorePrices, tick } from "./runner.js";
+import { buildSchedule } from "./schedule.js";
+import { loadState, saveState } from "./state.js";
+const SERVER_INFO = { name: "updateday", version: "0.2.0" };
+const DEFAULT_PROTOCOL = "2025-06-18";
+const HISTORY_LIMIT = 50;
+const GAME_ARG = { type: "string", description: "Game name or universe ID. Leave out for every game." };
+const CONFIRM_ARG = { type: "boolean", description: "Must be true. This changes the live game." };
+function text(value) {
+    return { content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }] };
+}
+function failure(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function mergePatch(target, patch) {
+    if (!isPlainObject(patch)) {
+        return patch;
+    }
+    const result = isPlainObject(target) ? { ...target } : {};
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete result[key];
+        }
+        else {
+            result[key] = mergePatch(result[key], value);
+        }
+    }
+    return result;
+}
+class Planner {
+    path;
+    baseDir;
+    constructor(configPath) {
+        this.path = resolve(configPath);
+        this.baseDir = dirname(this.path);
+    }
+    raw() {
+        return JSON.parse(readFileSync(this.path, "utf8"));
+    }
+    configs(filter) {
+        const all = parseConfigs(this.raw(), this.baseDir);
+        if (!filter) {
+            return all;
+        }
+        const picked = all.filter((config) => config.name === filter || String(config.universeId) === String(filter));
+        if (!picked.length) {
+            throw new Error(`No game called "${filter}". Games: ${all.map((config) => `${config.name} (${config.universeId})`).join(", ")}`);
+        }
+        return picked;
+    }
+    write(raw) {
+        const configs = parseConfigs(raw, this.baseDir);
+        writeFileSync(this.path, JSON.stringify(raw, null, "\t"));
+        return configs;
+    }
+    context(config) {
+        const apiKey = process.env[config.apiKeyEnv];
+        const webhook = config.notify ? process.env[config.notify.discordWebhookEnv] : undefined;
+        return {
+            config,
+            state: loadState(config.statePath, config.updateAt),
+            cloud: apiKey ? new OpenCloud(apiKey, config.universeId) : null,
+            now: new Date(),
+            notify: discordNotifier(config, webhook),
+        };
+    }
+}
+function summary(config) {
+    return {
+        name: config.name,
+        universeId: config.universeId,
+        updateAt: config.updateAt,
+        nextUpdateAt: nextOccurrence(config)?.toISOString() ?? null,
+        countdown: config.countdown ? { method: config.countdown.iconMethod, skipped: config.countdown.skip } : false,
+        sale: config.sale ? { percentOff: config.sale.percentOff } : false,
+        event: Boolean(config.event),
+        warnings: Boolean(config.broadcast),
+        restartServers: Boolean(config.restartServers),
+        alerts: config.notify ? config.notify.events : false,
+        hasApiKey: Boolean(process.env[config.apiKeyEnv]),
+    };
+}
+async function captured(task) {
+    const lines = [];
+    const original = { log: console.log, error: console.error };
+    console.log = (...args) => {
+        lines.push(args.join(" "));
+        process.stderr.write(`${args.join(" ")}\n`);
+    };
+    console.error = (...args) => {
+        lines.push(`ERROR ${args.join(" ")}`);
+        process.stderr.write(`${args.join(" ")}\n`);
+    };
+    try {
+        await task();
+    }
+    catch (error) {
+        lines.push(`ERROR ${error instanceof Error ? error.message : error}`);
+    }
+    finally {
+        console.log = original.log;
+        console.error = original.error;
+    }
+    return lines;
+}
+function tools(planner) {
+    return [
+        {
+            name: "get_plan",
+            description: "Read the UpdateDay plan: the raw config file and a summary of every game (update time, countdown, sale, event, alerts).",
+            inputSchema: { type: "object", properties: {} },
+            run: async () => text({ file: planner.path, config: planner.raw(), games: planner.configs().map(summary) }),
+        },
+        {
+            name: "change_plan",
+            description: "Change the plan with a JSON merge patch (RFC 7396): objects merge, arrays and values replace, null removes a key. Example: {\"updateAt\":\"2026-11-07T18:00:00Z\",\"sale\":{\"percentOff\":40}}. The result is checked before it's saved.",
+            inputSchema: { type: "object", properties: { patch: { type: "object" } }, required: ["patch"] },
+            run: async ({ patch }) => {
+                const next = mergePatch(planner.raw(), patch);
+                const configs = planner.write(next);
+                return text({ saved: true, games: configs.map(summary) });
+            },
+        },
+        {
+            name: "get_schedule",
+            description: "List every step of the update day in order, with its time and whether it already ran.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG } },
+            run: async ({ game }) => text(planner.configs(game).map((config) => {
+                const state = loadState(config.statePath, config.updateAt);
+                return {
+                    game: config.name,
+                    steps: buildSchedule(config).map((step) => ({ at: step.at.getTime() === 0 ? "right away" : step.at.toISOString(), label: step.label, done: state.done[step.id] ?? null })),
+                };
+            })),
+        },
+        {
+            name: "check_plan",
+            description: "Pre-flight check: API key permissions, times, files, countdown icons, sale items and alerts. Lines with level \"bad\" must be fixed.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG } },
+            run: async ({ game }) => {
+                const reports = [];
+                for (const config of planner.configs(game)) {
+                    const ctx = planner.context(config);
+                    reports.push(await preflight(config, ctx.cloud, config.notify ? process.env[config.notify.discordWebhookEnv] : undefined));
+                }
+                return text(reports);
+            },
+        },
+        {
+            name: "preview_icon",
+            description: "Render one countdown icon as players would see it. Stage is e.g. 24h, 1h, 5m, now or final.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG, stage: { type: "string" } }, required: ["stage"] },
+            run: async ({ game, stage }) => {
+                const config = planner.configs(game)[0];
+                if (!config.countdown) {
+                    return failure(`${config.name} has countdown icons turned off`);
+                }
+                const base = await sharp(await fetchCurrentIcon(config.universeId)).resize(ICON_SIZE, ICON_SIZE).png().toBuffer();
+                const image = await renderIcon(base, stage, config.countdown);
+                return { content: [{ type: "image", data: image.toString("base64"), mimeType: "image/png" }] };
+            },
+        },
+        {
+            name: "run_due_steps",
+            description: "Run every step that is due now, like one check of a running UpdateDay. Defaults to a dry run that only reports. Set dry_run false and confirm true to really do it.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG, dry_run: { type: "boolean", default: true }, confirm: CONFIRM_ARG } },
+            run: async ({ game, dry_run = true, confirm = false }) => {
+                if (!dry_run && confirm !== true) {
+                    return failure("This changes the live game. Call again with confirm: true.");
+                }
+                const lines = await captured(async () => {
+                    for (const config of planner.configs(game)) {
+                        const ctx = planner.context(config);
+                        if (!dry_run && !ctx.cloud) {
+                            throw new Error(`${config.name}: set ${config.apiKeyEnv} to an Open Cloud API key`);
+                        }
+                        const run = () => tick(buildSchedule(config), ctx, dry_run);
+                        const left = dry_run ? await run() : await recording(config, run);
+                        console.log(`${config.name}: ${left} step${left === 1 ? "" : "s"} left`);
+                    }
+                });
+                return text(lines.join("\n") || "Nothing is due right now.");
+            },
+        },
+        {
+            name: "restore_everything",
+            description: "Undo: put every saved price and name back and end the countdown icons. Use when an update is cancelled.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG, confirm: CONFIRM_ARG }, required: ["confirm"] },
+            run: async ({ game, confirm }) => {
+                if (confirm !== true) {
+                    return failure("This changes the live game. Call again with confirm: true.");
+                }
+                const lines = await captured(async () => {
+                    for (const config of planner.configs(game)) {
+                        const ctx = planner.context(config);
+                        await recording(config, async () => {
+                            await restorePrices(ctx);
+                            await endCountdown(ctx);
+                        });
+                        saveState(config.statePath, ctx.state);
+                    }
+                });
+                return text(lines.join("\n") || "Nothing needed restoring.");
+            },
+        },
+        {
+            name: "get_history",
+            description: "What UpdateDay did and when, newest first.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG, limit: { type: "number", default: HISTORY_LIMIT } } },
+            run: async ({ game, limit = HISTORY_LIMIT }) => {
+                const universeId = game ? planner.configs(game)[0].universeId : undefined;
+                return text(readHistory(planner.baseDir, universeId, limit));
+            },
+        },
+        {
+            name: "list_sale_items",
+            description: "List a game's passes and developer products with prices, to choose what goes on sale.",
+            inputSchema: { type: "object", properties: { game: GAME_ARG } },
+            run: async ({ game }) => {
+                const config = planner.configs(game)[0];
+                const ctx = planner.context(config);
+                if (!ctx.cloud) {
+                    return failure(`Set ${config.apiKeyEnv} to an Open Cloud API key`);
+                }
+                return text([...(await ctx.cloud.listItems("gamePass")), ...(await ctx.cloud.listItems("developerProduct"))]);
+            },
+        },
+    ];
+}
+function reply(id, result) {
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+}
+function replyError(id, code, message) {
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+}
+export async function handleMessage(list, message) {
+    const { id, method, params } = message;
+    if (id === undefined) {
+        return;
+    }
+    if (method === "initialize") {
+        reply(id, { protocolVersion: params?.protocolVersion ?? DEFAULT_PROTOCOL, capabilities: { tools: {} }, serverInfo: SERVER_INFO });
+        return;
+    }
+    if (method === "ping") {
+        reply(id, {});
+        return;
+    }
+    if (method === "tools/list") {
+        reply(id, { tools: list.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) });
+        return;
+    }
+    if (method === "tools/call") {
+        const tool = list.find((item) => item.name === params?.name);
+        if (!tool) {
+            replyError(id, -32602, `Unknown tool ${params?.name}`);
+            return;
+        }
+        try {
+            reply(id, await tool.run(params.arguments ?? {}));
+        }
+        catch (error) {
+            reply(id, failure(error instanceof Error ? error.message : String(error)));
+        }
+        return;
+    }
+    replyError(id, -32601, `Unknown method ${method}`);
+}
+export function startMcp(configPath) {
+    console.log = (...args) => process.stderr.write(`${args.join(" ")}\n`);
+    const list = tools(new Planner(configPath));
+    const input = createInterface({ input: process.stdin });
+    let queue = Promise.resolve();
+    input.on("line", (line) => {
+        if (!line.trim()) {
+            return;
+        }
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            replyError(null, -32700, "Parse error");
+            return;
+        }
+        queue = queue.then(() => handleMessage(list, message));
+    });
+    return new Promise((done) => input.on("close", () => queue.then(done)));
+}

package/dist/moderation.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { iconMarks } from "./bundle.js";
+import { renderIcon } from "./icons.js";
+const LEDGER_SUFFIX = ".moderation.json";
+const FINAL_MARK = "final";
+function ledgerPath(config) {
+    return config.statePath.replace(/\.state\.json$/, "") + LEDGER_SUFFIX;
+}
+function readLedger(config) {
+    const path = ledgerPath(config);
+    return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+}
+function writeLedger(config, ledger) {
+    writeFileSync(ledgerPath(config), JSON.stringify(ledger, null, "\t"));
+}
+function artStamp(config, mark) {
+    const dir = config.countdown?.overlayDir;
+    if (!dir) {
+        return "";
+    }
+    return [mark, "default"].map((name) => {
+        const path = join(dir, `${name}.png`);
+        return existsSync(path) ? String(statSync(path).mtimeMs) : "";
+    }).join("|");
+}
+export function designKey(config, base, mark) {
+    const hash = createHash("sha1");
+    hash.update(base);
+    hash.update(JSON.stringify(config.countdown));
+    hash.update(mark);
+    hash.update(artStamp(config, mark));
+    return hash.digest("hex");
+}
+function checkedMarks(config) {
+    const marks = iconMarks(config.countdown);
+    return config.countdown?.newIcon ? marks : marks.filter((mark) => mark !== FINAL_MARK);
+}
+async function readState(cloud, assetId) {
+    const asset = await cloud.request("GET", `/assets/v1/assets/${assetId}?readMask=moderationResult`, "read asset");
+    const state = String(asset?.moderationResult?.moderationState ?? "unknown");
+    return (["Approved", "Reviewing", "Rejected"].includes(state) ? state : "unknown");
+}
+export async function moderationStatus(config, cloud, base) {
+    if (!config.countdown) {
+        return [];
+    }
+    const ledger = readLedger(config);
+    let changed = false;
+    const result = [];
+    for (const mark of checkedMarks(config)) {
+        const entry = ledger[mark];
+        if (!entry || entry.design !== designKey(config, base, mark)) {
+            result.push({ mark, state: "unchecked", assetId: null, checkedAt: null });
+            continue;
+        }
+        if (cloud && (entry.state === "Reviewing" || entry.state === "unknown")) {
+            entry.state = await readState(cloud, entry.assetId);
+            entry.checkedAt = new Date().toISOString();
+            changed = true;
+        }
+        result.push({ mark, state: entry.state, assetId: entry.assetId, checkedAt: entry.checkedAt });
+    }
+    if (changed) {
+        writeLedger(config, ledger);
+    }
+    return result;
+}
+export async function submitForModeration(config, cloud, base) {
+    const ledger = readLedger(config);
+    let sent = 0;
+    for (const mark of checkedMarks(config)) {
+        const design = designKey(config, base, mark);
+        const entry = ledger[mark];
+        if (entry && entry.design === design && entry.state !== "Rejected") {
+            continue;
+        }
+        const image = await renderIcon(base, mark, config.countdown);
+        const assetId = await cloud.uploadImage(new Blob([new Uint8Array(image)], { type: "image/png" }), `UpdateDay ${config.name} ${mark}`);
+        ledger[mark] = { design, assetId, state: "Reviewing", checkedAt: new Date().toISOString() };
+        writeLedger(config, ledger);
+        sent++;
+    }
+    return sent;
+}