updateday 0.0.0-stage → 0.2.0

package/dist/config.js

@@ -0,0 +1,261 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { HOURGLASS_STYLES } from "./icons.js";
+const DEFAULT_LANGUAGE = "en";
+const DEFAULT_API_KEY_ENV = "UPDATEDAY_API_KEY";
+const DEFAULT_ADMIN_ABUSE_MINUTES = 60;
+const STATE_PREFIX = "updateday";
+const STATE_SUFFIX = ".state.json";
+const MERGED_SECTIONS = ["countdown", "sale", "event", "broadcast", "restartServers", "title"];
+const DEFAULT_TITLE = { format: "[{time}] {name}", nowFormat: "[LIVE] {name}", afterFormat: "{name}" };
+const NAME_TOKEN = "{name}";
+const SNAPSHOT_SUFFIX = ".original-icon.png";
+const NOW_MARK = "now";
+const NEW_ICON_TIMINGS = ["now", "end"];
+const REPEAT_PERIODS_MS = { day: 864e5, week: 7 * 864e5, "2weeks": 14 * 864e5 };
+const REPEAT_GRACE_MS = 30 * 60 * 1000;
+const HOUR_MS = 60 * 60 * 1000;
+const MINUTE_MS = 60 * 1000;
+const MAX_MONTH_STEPS = 1200;
+export const DEFAULT_WEBHOOK_ENV = "UPDATEDAY_DISCORD_WEBHOOK";
+export const DEFAULT_NOTIFY_EVENTS = ["reminders", "failures", "live", "finished"];
+const NOTIFY_EVENTS = ["reminders", "failures", "live", "finished", "steps"];
+export const DEFAULT_MARKS = ["24h", "12h", "6h", "5h", "4h", "3h", "2h", "1h", "45m", "30m", "15m", "10m", "5m"];
+const DEFAULT_COUNTDOWN = {
+    marks: DEFAULT_MARKS,
+    skip: [],
+    newIconAt: "end",
+    iconMethod: "reminder",
+    uploadLeadSeconds: 90,
+    localizeLabels: true,
+    style: "original",
+    hourglassSize: 0.66,
+    hourglassY: 0.4,
+    textSize: 0.15,
+    textY: 0.85,
+    anchor: "center",
+    scale: 0.88,
+    dim: 0.45,
+    label: true,
+    labelColor: "#ffffff",
+    labelOutline: "#000000",
+};
+function countdownConfig(raw, baseDir) {
+    if (raw === false) {
+        return undefined;
+    }
+    const merged = { ...DEFAULT_COUNTDOWN, ...(raw ?? {}) };
+    const resolvePath = (path) => (path ? resolve(baseDir, path) : undefined);
+    const known = new Set([...merged.marks, NOW_MARK]);
+    const unknown = merged.skip.filter((mark) => !known.has(mark));
+    if (unknown.length > 0) {
+        fail(`countdown.skip has stages that aren't in the countdown: ${unknown.join(", ")}`);
+    }
+    if (!["languageSwap", "reminder"].includes(merged.iconMethod)) {
+        fail(`countdown.iconMethod must be "languageSwap" or "reminder"`);
+    }
+    if (!HOURGLASS_STYLES.includes(merged.style)) {
+        fail(`countdown.style must be one of ${HOURGLASS_STYLES.join(", ")}`);
+    }
+    if (!NEW_ICON_TIMINGS.includes(merged.newIconAt)) {
+        fail(`countdown.newIconAt must be "now" or "end"`);
+    }
+    return {
+        ...merged,
+        overlayDir: resolvePath(merged.overlayDir),
+        customDir: resolvePath(merged.customDir),
+        newIcon: resolvePath(merged.newIcon ?? merged.finalIcon),
+    };
+}
+export function activeMarks(countdown) {
+    return countdown.marks.filter((mark) => !countdown.skip.includes(mark));
+}
+export function showsNow(countdown) {
+    return !countdown.skip.includes(NOW_MARK);
+}
+export function occurrence(base, every, index) {
+    if (every === "month") {
+        const date = new Date(base);
+        date.setUTCMonth(date.getUTCMonth() + index);
+        return date;
+    }
+    return new Date(base.getTime() + index * REPEAT_PERIODS_MS[every]);
+}
+function occurrenceTailMs(raw) {
+    let tail = (raw.adminAbuseMinutes ?? DEFAULT_ADMIN_ABUSE_MINUTES) * MINUTE_MS;
+    const base = Date.parse(raw.updateAt);
+    if (raw.sale) {
+        const start = raw.sale.startsAt ? Date.parse(raw.sale.startsAt) : base;
+        const end = raw.sale.endsAt ? Date.parse(raw.sale.endsAt) : start + (raw.sale.durationHours ?? 48) * HOUR_MS;
+        tail = Math.max(tail, end - base);
+    }
+    if (raw.event) {
+        tail = Math.max(tail, (raw.event.durationHours ?? 2) * HOUR_MS);
+    }
+    return tail + REPEAT_GRACE_MS;
+}
+function repeatIndexFor(raw, now) {
+    const every = raw.repeat.every;
+    const base = new Date(raw.updateAt);
+    const tail = occurrenceTailMs(raw);
+    let index = 0;
+    if (every === "month") {
+        while (index < MAX_MONTH_STEPS && occurrence(base, every, index).getTime() + tail < now.getTime()) {
+            index++;
+        }
+    }
+    else {
+        index = Math.max(0, Math.ceil((now.getTime() - tail - base.getTime()) / REPEAT_PERIODS_MS[every]));
+    }
+    const until = raw.repeat.until ? Date.parse(raw.repeat.until) : NaN;
+    while (index > 0 && !Number.isNaN(until) && occurrence(base, every, index).getTime() > until) {
+        index--;
+    }
+    return index;
+}
+function shiftIso(value, deltaMs) {
+    return value ? new Date(Date.parse(value) + deltaMs).toISOString() : value;
+}
+function applyRepeat(raw, now) {
+    if (!raw.repeat) {
+        return { raw, index: 0 };
+    }
+    if (!["day", "week", "2weeks", "month"].includes(raw.repeat.every)) {
+        fail(`repeat.every must be "day", "week", "2weeks" or "month"`);
+    }
+    const index = repeatIndexFor(raw, now);
+    if (index === 0) {
+        return { raw, index };
+    }
+    const updateAt = occurrence(new Date(raw.updateAt), raw.repeat.every, index);
+    const delta = updateAt.getTime() - Date.parse(raw.updateAt);
+    const sale = raw.sale ? { ...raw.sale, startsAt: shiftIso(raw.sale.startsAt, delta), endsAt: shiftIso(raw.sale.endsAt, delta) } : raw.sale;
+    return { raw: { ...raw, updateAt: updateAt.toISOString(), sale }, index };
+}
+function titleConfig(raw, label) {
+    if (!raw) {
+        return undefined;
+    }
+    const merged = { ...DEFAULT_TITLE, ...raw };
+    for (const key of ["format", "nowFormat"]) {
+        if (!merged[key].includes(NAME_TOKEN)) {
+            fail(`${label}: title.${key} must include {name}`);
+        }
+    }
+    return merged;
+}
+function notifyConfig(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    const events = (raw.events ?? DEFAULT_NOTIFY_EVENTS).filter((event) => NOTIFY_EVENTS.includes(event));
+    return { discordWebhookEnv: raw.discordWebhookEnv || DEFAULT_WEBHOOK_ENV, events, mention: raw.mention || undefined };
+}
+function fail(message) {
+    throw new Error(`Config: ${message}`);
+}
+function mergeSection(shared, own) {
+    if (own === false || own === null) {
+        return false;
+    }
+    if (own === undefined) {
+        return shared;
+    }
+    if (shared && typeof shared === "object" && typeof own === "object" && !Array.isArray(own)) {
+        return { ...shared, ...own };
+    }
+    return own;
+}
+function mergeGame(shared, game) {
+    const merged = { ...shared, ...game };
+    for (const section of MERGED_SECTIONS) {
+        merged[section] = mergeSection(shared[section], game[section]);
+    }
+    return merged;
+}
+function enabledSections(raw) {
+    const sections = {};
+    for (const section of MERGED_SECTIONS) {
+        sections[section] = raw[section] === false ? undefined : raw[section];
+    }
+    return sections;
+}
+function statePathFor(raw, baseDir, multi) {
+    if (raw.statePath) {
+        return resolve(baseDir, raw.statePath);
+    }
+    const fileName = multi ? `${STATE_PREFIX}.${raw.universeId}${STATE_SUFFIX}` : STATE_PREFIX + STATE_SUFFIX;
+    return resolve(baseDir, fileName);
+}
+function buildConfig(original, baseDir, multi, now) {
+    const label = original.name ?? original.universeId ?? "game";
+    if (Number.isNaN(Date.parse(original.updateAt ?? ""))) {
+        fail(`${label}: updateAt must be an ISO date with a timezone, e.g. 2026-11-01T17:00:00Z`);
+    }
+    const { raw, index } = applyRepeat(original, now);
+    return buildOccurrence(raw, baseDir, multi, index, original.updateAt);
+}
+function buildOccurrence(raw, baseDir, multi, repeatIndex, baseUpdateAt) {
+    const label = raw.name ?? raw.universeId ?? "game";
+    if (!Number.isInteger(raw.universeId)) {
+        fail(`${label}: universeId must be a number`);
+    }
+    if (Number.isNaN(Date.parse(raw.updateAt ?? ""))) {
+        fail(`${label}: updateAt must be an ISO date with a timezone, e.g. 2026-11-01T17:00:00Z`);
+    }
+    if (raw.sale && !(raw.sale.percentOff > 0 && raw.sale.percentOff < 100)) {
+        fail(`${label}: sale.percentOff must be between 1 and 99`);
+    }
+    if (raw.sale?.startsAt && raw.sale?.endsAt && Date.parse(raw.sale.endsAt) <= Date.parse(raw.sale.startsAt)) {
+        fail(`${label}: the sale has to end after it starts`);
+    }
+    const statePath = statePathFor(raw, baseDir, multi);
+    return {
+        ...raw,
+        ...enabledSections(raw),
+        name: String(raw.name ?? raw.universeId),
+        apiKeyEnv: raw.apiKeyEnv ?? DEFAULT_API_KEY_ENV,
+        languageCode: raw.languageCode ?? DEFAULT_LANGUAGE,
+        adminAbuseMinutes: raw.adminAbuseMinutes ?? DEFAULT_ADMIN_ABUSE_MINUTES,
+        countdown: countdownConfig(raw.countdown, baseDir),
+        notify: notifyConfig(raw.notify),
+        title: titleConfig(raw.title, label),
+        repeatIndex,
+        baseUpdateAt,
+        statePath,
+        snapshotPath: statePath.replace(/\.json$/, "") + SNAPSHOT_SUFFIX,
+        baseDir,
+    };
+}
+export function parseConfigs(raw, baseDir, now = new Date()) {
+    if (!Array.isArray(raw.games)) {
+        return [buildConfig(raw, baseDir, false, now)];
+    }
+    const { games, ...shared } = raw;
+    const configs = games.map((game) => buildConfig(mergeGame(shared, game), baseDir, true, now));
+    const ids = configs.map((config) => config.universeId);
+    if (new Set(ids).size !== ids.length) {
+        fail("the same universeId is listed twice in games");
+    }
+    return configs;
+}
+export function flattenSingleGame(raw) {
+    if (!Array.isArray(raw.games) || raw.games.length !== 1) {
+        return raw;
+    }
+    const { games, ...shared } = raw;
+    return mergeGame(shared, games[0]);
+}
+export function nextOccurrence(config) {
+    if (!config.repeat) {
+        return null;
+    }
+    const next = occurrence(new Date(config.baseUpdateAt), config.repeat.every, config.repeatIndex + 1);
+    const until = config.repeat.until ? Date.parse(config.repeat.until) : NaN;
+    return !Number.isNaN(until) && next.getTime() > until ? null : next;
+}
+export function loadConfigs(path, now = new Date()) {
+    const fullPath = resolve(path);
+    const raw = JSON.parse(readFileSync(fullPath, "utf8"));
+    return parseConfigs(raw, dirname(fullPath), now);
+}

package/dist/doctor.js

@@ -0,0 +1,119 @@
+import { OpenCloudError } from "./openCloud.js";
+const PROBE_KEY = "UpdateDayKeyCheck";
+const PROBE_TOPIC = "UpdateDayKeyCheck";
+function entryPath(cloud, store, key) {
+    return `/cloud/v2/universes/${cloud.universeId}/data-stores/${encodeURIComponent(store)}/entries/${encodeURIComponent(key)}`;
+}
+async function readMissingEntry(cloud) {
+    try {
+        await cloud.request("GET", entryPath(cloud, PROBE_KEY, PROBE_KEY), "read entry");
+    }
+    catch (error) {
+        if (error instanceof OpenCloudError && error.status === 404) {
+            return;
+        }
+        throw error;
+    }
+}
+const PROBES = [
+    {
+        feature: "Game info",
+        permission: "Universe: read",
+        used: () => true,
+        run: (cloud) => cloud.getUniverse(),
+    },
+    {
+        feature: "Name and description",
+        permission: "Places: read + write",
+        used: (config) => Boolean(config.nameChanges?.length || config.title),
+        run: async (cloud) => cloud.getPlace(await cloud.rootPlaceId()),
+        note: "Write is checked the first time a name change runs.",
+    },
+    {
+        feature: "Countdown icons",
+        permission: "Legacy universe: manage",
+        used: (config) => Boolean(config.countdown),
+        run: (cloud) => cloud.listIcons(),
+    },
+    {
+        feature: "Sale: game passes",
+        permission: "Game passes: read + write",
+        used: (config) => Boolean(config.sale),
+        run: (cloud) => cloud.listItems("gamePass"),
+        note: "Write is checked when the sale starts; every price is read back.",
+    },
+    {
+        feature: "Sale: developer products",
+        permission: "Developer products: read + write",
+        used: (config) => Boolean(config.sale),
+        run: (cloud) => cloud.listItems("developerProduct"),
+    },
+    {
+        feature: "Events",
+        permission: "Universe events: read + write",
+        used: (config) => Boolean(config.event),
+        run: (cloud) => cloud.request("GET", `/virtual-events/v3/universes/${cloud.universeId}/game-events`, "list events"),
+    },
+    {
+        feature: "In-game warnings",
+        permission: "Messaging service: publish",
+        used: (config) => Boolean(config.broadcast),
+        run: (cloud) => cloud.publishMessage(PROBE_TOPIC, "key check"),
+    },
+    {
+        feature: "Player data: list stores",
+        permission: "DataStore: List data stores",
+        used: (config) => Boolean(config.playerData),
+        run: (cloud) => cloud.request("GET", `/cloud/v2/universes/${cloud.universeId}/data-stores?maxPageSize=1`, "list data stores"),
+    },
+    {
+        feature: "Player data and gifts",
+        permission: "DataStore: Read entry + Create entry + Update entry",
+        used: (config) => Boolean(config.playerData || config.gifts),
+        run: (cloud) => readMissingEntry(cloud),
+        note: "Create and update are checked on the first save.",
+    },
+    {
+        feature: "Server restarts",
+        permission: "Universe: write",
+        used: (config) => Boolean(config.restartServers),
+        note: "Can't be checked without restarting servers; checked when it runs.",
+    },
+    {
+        feature: "Publishing the place",
+        permission: "Places: publish (universe-places:write)",
+        used: (config) => Boolean(config.publish),
+        note: "Checked when it runs.",
+    },
+];
+function describe(error) {
+    if (error instanceof OpenCloudError) {
+        if (error.status === 401 || error.status === 403) {
+            const ip = /ip/i.test(error.body);
+            return {
+                status: "missing",
+                detail: ip ? "Roblox refused this computer's IP address: add it to the key's accepted IPs." : "The key doesn't have this permission for this game.",
+            };
+        }
+        return { status: "error", detail: `Roblox answered ${error.status}: ${error.body.slice(0, 160)}` };
+    }
+    return { status: "error", detail: error instanceof Error ? error.message : String(error) };
+}
+export async function checkKey(cloud, config) {
+    const results = [];
+    for (const spec of PROBES) {
+        const base = { feature: spec.feature, permission: spec.permission, used: spec.used(config) };
+        if (!spec.run) {
+            results.push({ ...base, status: "untested", detail: spec.note });
+            continue;
+        }
+        try {
+            await spec.run(cloud, config);
+            results.push({ ...base, status: "ok", detail: spec.note });
+        }
+        catch (error) {
+            results.push({ ...base, ...describe(error) });
+        }
+    }
+    return results;
+}