openmausbot 0.1.85 → 0.1.87

package/dist-server/server/presets.js

@@ -0,0 +1,492 @@
+// Preset bots: named starting points in the New bot dialog, carried by a
+// shared package (a file someone sent, or the organization's shelf).
+//
+// A preset is an ALLOWLIST (critique #3): a name and a short description,
+// the new bot's name, title, description, standing instructions and look,
+// playbooks, skills (SKILL.md text only) and starter notes. It has no field
+// for a model, a folder, a computer, an approval level, connected apps, MCP
+// servers, a browser or anything else that grants reach, so nothing a
+// preset says can widen what a bot may do. The person creating the bot
+// keeps their own choices for all of that.
+//
+// Where presets live: `DATA_DIR/org-library/presets.json` (contract §3.4).
+// One row per preset, stamped with where it came from ("file" or "org") and
+// the install it belongs to, plus the skill and playbook definitions each
+// install's presets use, so a bot can be created from a preset long after
+// the file or the organization's release is gone. Every use re-reads a row
+// through the same package parser every import uses, so a hand-edited file
+// can still only say what the package format allows.
+//
+// Trust is where the preset came from, never what it says: skills from an
+// organization preset are added switched on (the organization's Admin
+// published them), skills from a file preset switched off. Starter notes are
+// written once, through the normal memory writers (which scrub secrets).
+//
+// There is no confirm step anywhere: choosing a preset in New bot and
+// pressing Create is the decision.
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+import { AGENT_MAX_SKILLS, canonicalJson, PACKAGE_FORMAT, PACKAGE_VERSION, parsePackageDocument, SEED_FILE_MAX_BYTES, SEED_MAX_BYTES, SEED_MAX_FILES, utf8Bytes, } from "../shared/package-format.js";
+import { parseSkillMd } from "../shared/skill-md.js";
+export const PRESETS_FILE = join(DATA_DIR, "org-library", "presets.json");
+/** The organization library's state (W2-1, contract §3.4); read only here. */
+export const ORG_LIBRARY_STATE_FILE = join(DATA_DIR, "org-library", "state.json");
+/** What this installation last shared as a preset file (skills + presets, no team). */
+export const PUBLISHED_LIBRARY_FILE = join(DATA_DIR, "published-library.json");
+/** Enough for every preset of ten full packages; a runaway import cannot grow the file without bound. */
+export const MAX_STORED_PRESETS = 200;
+/** The key "Include my New bot defaults as a preset" is shared under. Fixed,
+ * so renaming the preset keeps its identity across releases. */
+export const DEFAULTS_PRESET_KEY = "new-bot-defaults";
+export const PRESET_UNAVAILABLE_MESSAGE = "That preset is no longer available. Choose another starting role.";
+export const ORG_PRESET_REMOVE_MESSAGE = "Presets from your organization are managed in Admin.";
+// ── the stored file ─────────────────────────────────────────────────────────
+const text = (max) => z.string().max(max);
+const storedPresetSchema = z.object({
+    id: z.string().regex(/^[\w-]{1,64}$/),
+    source: z.enum(["file", "org"]),
+    installId: text(100).min(1),
+    packageId: text(80).min(1),
+    packageName: text(100).min(1),
+    release: text(30).min(1),
+    publisherName: text(100).optional(),
+    publisher: z.object({ organizationId: text(200), slug: text(40), name: text(100) }).optional(),
+    ref: text(120).optional(),
+    sha256: text(64).optional(),
+    key: text(64).min(1),
+    name: text(100).min(1),
+    description: text(300).optional(),
+    // Checked field by field through the package parser on every use.
+    bot: z.record(z.string(), z.unknown()),
+    playbooks: z.array(z.string()).optional(),
+    skills: z.array(z.string()).optional(),
+    seed: z.object({ memory: z.record(z.string(), z.string()) }).optional(),
+    addedAt: z.number(),
+});
+const fileSchema = z.object({
+    version: z.literal(1),
+    presets: z.array(z.unknown()),
+    content: z.record(z.string(), z.object({ skills: z.array(z.unknown()), playbooks: z.array(z.unknown()) })).optional(),
+});
+/** A preset exactly as the package carried it: what `preset:<key>` hashes
+ * over (contract §1.6), with the row's bookkeeping left out. */
+export function storedPresetObject(row) {
+    return {
+        key: row.key,
+        name: row.name,
+        ...(row.description !== undefined ? { description: row.description } : {}),
+        bot: row.bot,
+        ...(row.playbooks ? { playbooks: row.playbooks } : {}),
+        ...(row.skills ? { skills: row.skills } : {}),
+        ...(row.seed ? { seed: row.seed } : {}),
+    };
+}
+function resolveRow(row, content) {
+    const wantedSkills = new Set(row.skills ?? []);
+    const wantedPlaybooks = new Set(row.playbooks ?? []);
+    const skills = (content?.skills ?? []).filter((skill) => wantedSkills.has(skill.name));
+    const playbooks = (content?.playbooks ?? []).filter((playbook) => wantedPlaybooks.has(playbook.key));
+    let document;
+    try {
+        document = parsePackageDocument({
+            format: PACKAGE_FORMAT,
+            version: PACKAGE_VERSION,
+            package: {
+                id: row.packageId,
+                release: row.release,
+                name: row.packageName,
+                tagline: row.packageName,
+                summary: row.packageName,
+                category: "Presets",
+                author: { name: row.publisherName ?? row.packageName },
+                license: "Unspecified",
+                outcomes: [row.name],
+                setupMinutes: 1,
+                requirements: { apps: [], capabilities: [] },
+                presets: [storedPresetObject(row)],
+                ...(skills.length ? { skills: { version: 1, entries: skills } } : {}),
+                ...(playbooks.length ? { playbooks } : {}),
+            },
+        }, { trust: "file" });
+    }
+    catch {
+        return null;
+    }
+    const pkg = document.package;
+    return { row, preset: pkg.presets[0], skills: pkg.skills?.entries ?? [], playbooks: pkg.playbooks ?? [] };
+}
+export function createPresetStore(file = PRESETS_FILE) {
+    const load = () => {
+        const empty = { version: 1, presets: [], content: Object.create(null) };
+        if (!existsSync(file))
+            return empty;
+        try {
+            const parsed = fileSchema.parse(JSON.parse(readFileSync(file, "utf8")));
+            const presets = parsed.presets.flatMap((value) => {
+                const row = storedPresetSchema.safeParse(value);
+                return row.success ? [row.data] : [];
+            });
+            const content = Object.create(null);
+            // Own entries only: an install id is data from a file.
+            for (const [installId, value] of Object.entries(parsed.content ?? {})) {
+                content[installId] = { skills: value.skills, playbooks: value.playbooks };
+            }
+            return { version: 1, presets, content };
+        }
+        catch {
+            // An unreadable file offers no presets. It is left alone (never
+            // overwritten by a read), so nothing is lost to a transient error.
+            return empty;
+        }
+    };
+    const save = (state) => {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        // Content no preset uses any more is dropped with its last preset.
+        const used = new Set(state.presets.map((row) => row.installId));
+        const content = Object.create(null);
+        for (const [installId, value] of Object.entries(state.content))
+            if (used.has(installId))
+                content[installId] = value;
+        writeFileAtomic(file, JSON.stringify({ version: 1, presets: state.presets, content }, null, 2), { mode: 0o600 });
+    };
+    const sameFilePreset = (row, candidate, state, content) => row.source === "file" && candidate.source === "file" && row.packageId === candidate.packageId && row.release === candidate.release && row.key === candidate.key &&
+        canonicalJson(storedPresetObject(row)) === canonicalJson(storedPresetObject(candidate)) &&
+        canonicalJson(usedContent(row, state.content[row.installId])) === canonicalJson(usedContent(candidate, content));
+    return {
+        list: () => load().presets,
+        resolve(id) {
+            const state = load();
+            const row = state.presets.find((candidate) => candidate.id === id);
+            return row ? resolveRow(row, state.content[row.installId]) : null;
+        },
+        register(document, context) {
+            const pkg = document.package;
+            const presets = pkg.presets ?? [];
+            const added = [];
+            const existing = [];
+            const skipped = [];
+            const org = context.source === "org" ? context.org : undefined;
+            if (!presets.length && !org)
+                return { added, existing, skipped };
+            const state = load();
+            const used = new Set(presets.flatMap((preset) => preset.skills ?? []));
+            const usedPlaybooks = new Set(presets.flatMap((preset) => preset.playbooks ?? []));
+            const content = {
+                skills: (pkg.skills?.entries ?? []).filter((skill) => used.has(skill.name)),
+                playbooks: (pkg.playbooks ?? []).filter((playbook) => usedPlaybooks.has(playbook.key)),
+            };
+            // An organization install owns one set of rows. Adding it again (a
+            // removed team re-added, or an Add retried after the app stopped
+            // before state.json was written) refreshes them in place, keeping
+            // their ids, and drops keys the release no longer has. Nothing is
+            // duplicated, and nothing here decides whether it was added before:
+            // that is org-library.ts's index, rebuilt from the records.
+            const ownRow = (row) => row.source === "org" && row.installId === context.installId;
+            let refreshed = false;
+            if (org) {
+                const keys = new Set(presets.map((preset) => preset.key));
+                const kept = state.presets.filter((row) => !ownRow(row) || keys.has(row.key));
+                refreshed = kept.length !== state.presets.length;
+                state.presets = kept;
+            }
+            for (const preset of presets) {
+                const row = {
+                    id: randomUUID(),
+                    source: context.source,
+                    installId: context.installId,
+                    packageId: pkg.id,
+                    packageName: pkg.name,
+                    release: pkg.release,
+                    ...(org ? { publisherName: org.publisher.name, publisher: { ...org.publisher }, ref: org.ref, sha256: org.sha256 } : {}),
+                    key: preset.key,
+                    name: preset.name,
+                    ...(preset.description !== undefined ? { description: preset.description } : {}),
+                    bot: structuredClone(preset.bot),
+                    ...(preset.playbooks ? { playbooks: [...preset.playbooks] } : {}),
+                    ...(preset.skills ? { skills: [...preset.skills] } : {}),
+                    ...(preset.seed ? { seed: structuredClone(preset.seed) } : {}),
+                    addedAt: Date.now(),
+                };
+                const own = org ? state.presets.findIndex((candidate) => ownRow(candidate) && candidate.key === preset.key) : -1;
+                if (own >= 0) {
+                    const previous = state.presets[own];
+                    state.presets[own] = { ...row, id: previous.id, addedAt: previous.addedAt };
+                    existing.push({ id: previous.id, key: row.key, name: row.name });
+                    refreshed = true;
+                    continue;
+                }
+                // The same file added twice offers its presets once.
+                const same = state.presets.find((candidate) => sameFilePreset(candidate, row, state, content));
+                if (same) {
+                    existing.push({ id: same.id, key: same.key, name: same.name });
+                    continue;
+                }
+                if (state.presets.length >= MAX_STORED_PRESETS) {
+                    skipped.push({ part: `presets[${preset.key}]`, reason: "too_many_presets" });
+                    continue;
+                }
+                state.presets.push(row);
+                added.push({ id: row.id, key: row.key, name: row.name });
+            }
+            if (added.length || refreshed) {
+                state.content[context.installId] = content;
+                save(state);
+            }
+            return { added, existing, skipped };
+        },
+        remove(ids) {
+            if (!ids.length)
+                return;
+            const drop = new Set(ids);
+            const state = load();
+            const kept = state.presets.filter((row) => !drop.has(row.id));
+            if (kept.length === state.presets.length)
+                return;
+            save({ ...state, presets: kept });
+        },
+        removeFilePreset(id) {
+            const state = load();
+            const row = state.presets.find((candidate) => candidate.id === id);
+            if (!row)
+                return "not_found";
+            if (row.source !== "file")
+                return "organization";
+            save({ ...state, presets: state.presets.filter((candidate) => candidate.id !== id) });
+            return "removed";
+        },
+    };
+}
+function usedContent(row, content) {
+    const skills = new Set(row.skills ?? []);
+    const playbooks = new Set(row.playbooks ?? []);
+    return {
+        skills: (content?.skills ?? []).filter((skill) => skills.has(skill.name)),
+        playbooks: (content?.playbooks ?? []).filter((playbook) => playbooks.has(playbook.key)),
+    };
+}
+/** Each organization install's status from `org-library/state.json`
+ * (contract §3.4). No file, or an unreadable one, is an empty map: an
+ * organization preset is then shown like any copy that stays after sign-out. */
+export function readOrgInstallStatuses(file = ORG_LIBRARY_STATE_FILE) {
+    const statuses = new Map();
+    try {
+        const state = JSON.parse(readFileSync(file, "utf8"));
+        if (!state.installs || typeof state.installs !== "object" || Array.isArray(state.installs))
+            return statuses;
+        for (const [installId, value] of Object.entries(state.installs)) {
+            const status = value && typeof value === "object" ? value.status : undefined;
+            if (status === "installed" || status === "withdrawn" || status === "removed")
+                statuses.set(installId, status);
+        }
+    }
+    catch {
+        /* no organization state yet */
+    }
+    return statuses;
+}
+/** Whether New bot may use this preset: not one from an organization
+ * release that was withdrawn or an install that was removed. */
+export function presetOffered(row, statuses) {
+    if (row.source !== "org")
+        return true;
+    const status = statuses.get(row.installId);
+    return status !== "withdrawn" && status !== "removed";
+}
+/** Every preset the New bot dialog offers: the organization's first (by
+ * publisher, then name), then imported files (newest first). A preset from a
+ * release the organization withdrew, or an install removed, is not offered. */
+export function listBotPresets(store, statuses) {
+    const wire = [];
+    for (const row of store.list()) {
+        if (!presetOffered(row, statuses))
+            continue;
+        const resolved = store.resolve(row.id);
+        if (!resolved)
+            continue;
+        const { preset } = resolved;
+        wire.push({
+            id: row.id,
+            source: row.source,
+            key: preset.key,
+            name: preset.name,
+            ...(preset.description ? { description: preset.description } : {}),
+            packageName: row.packageName,
+            release: row.release,
+            ...(row.source === "org" && row.publisherName ? { publisherName: row.publisherName } : {}),
+            bot: preset.bot,
+            skills: resolved.skills.map((skill) => ({ name: skill.name, description: skill.description })),
+            skillsEnabled: row.source === "org",
+            playbooks: resolved.playbooks.map((playbook) => playbook.name),
+            notes: Object.keys(preset.seed?.memory ?? {}),
+            addedAt: row.addedAt,
+        });
+    }
+    const org = wire.filter((preset) => preset.source === "org")
+        .sort((a, b) => (a.publisherName ?? "").localeCompare(b.publisherName ?? "") || a.name.localeCompare(b.name));
+    const files = wire.filter((preset) => preset.source === "file").sort((a, b) => b.addedAt - a.addedAt);
+    return [...org, ...files].map(({ addedAt: _addedAt, ...preset }) => preset);
+}
+/** The preset's content onto a bot that was just created: playbooks, skills
+ * (switched on only for an organization preset), starter notes, and the
+ * provenance stamp. Persona fields are the caller's: the New bot dialog
+ * prefilled them from the preset and the person may have edited them.
+ * Throws on failure; the caller removes the half-made bot. */
+export function applyPresetToBot(botId, resolved, deps) {
+    const { row, preset } = resolved;
+    const org = row.source === "org";
+    const playbooks = (preset.playbooks ?? []).flatMap((key) => {
+        const playbook = resolved.playbooks.find((candidate) => candidate.key === key);
+        return playbook ? [{ ...playbook, triggers: [...playbook.triggers] }] : [];
+    });
+    const installed = {
+        id: row.packageId,
+        name: row.packageName,
+        release: row.release,
+        requiredApps: [],
+        source: row.source,
+        installId: row.installId,
+        presetKey: row.key,
+        ...(org && row.publisher ? { publisher: { ...row.publisher } } : {}),
+        ...(org && row.ref ? { ref: row.ref } : {}),
+        ...(org && row.sha256 ? { sha256: row.sha256 } : {}),
+    };
+    deps.store.patchBot(botId, { installedPackage: installed, ...(playbooks.length ? { playbooks } : {}) });
+    const skills = [];
+    for (const name of preset.skills ?? []) {
+        const skill = resolved.skills.find((candidate) => candidate.name === name);
+        if (!skill)
+            throw new Error(`The preset's skill "${name}" is unavailable`);
+        // The organization channel names its own source; a file's is display only.
+        const source = org && row.ref ? `org:${row.ref}@${row.release}` : skill.source ?? `package:${row.packageId}`;
+        const added = deps.skills.install(botId, source, [{ path: "SKILL.md", content: skill.instructions }]);
+        if ("error" in added)
+            throw new Error(`The preset's skill "${name}" could not be added: ${added.error}`);
+        if (org) {
+            const enabled = deps.skills.setEnabled(botId, name, true);
+            if ("error" in enabled)
+                throw new Error(`The preset's skill "${name}" could not be switched on: ${enabled.error}`);
+        }
+        skills.push(name);
+    }
+    let notes = 0;
+    for (const [path, value] of Object.entries(preset.seed?.memory ?? {})) {
+        if (path === "MEMORY.md")
+            deps.memory.writeIndex(botId, value);
+        else
+            deps.memory.writeTopic(botId, path.slice("memory/".length), value);
+        notes += 1;
+    }
+    return { skills, notes };
+}
+function isPortableSource(value) {
+    return !/^(?:[a-z]:[\\/]|[\\/]|\\\\|file:)/i.test(value);
+}
+/** "Include my New bot defaults as a preset": the saved defaults, reduced to
+ * the preset allowlist. Name, look, standing instructions, skills and (when
+ * `includeNotes`) starter notes. Never the model, folder, computer, approval
+ * level, connected apps, MCP servers, browser, peers, Chief settings or
+ * routines. Null when nothing is left worth sharing. `avatar` is the
+ * picture the dialog prepared (a data URL), checked by the exporter. */
+export function presetFromDefaults(defaults, options) {
+    const skipped = [];
+    const profile = defaults?.profile ?? {};
+    const part = `presets[${DEFAULTS_PRESET_KEY}]`;
+    const trimmed = (value) => (value?.trim() ? value : undefined);
+    const bot = {
+        ...(trimmed(profile.name) ? { name: profile.name.trim() } : {}),
+        ...(trimmed(profile.title) ? { title: profile.title.trim() } : {}),
+        ...(trimmed(profile.description) ? { description: profile.description.trim() } : {}),
+        ...(trimmed(profile.soul) ? { soul: profile.soul } : {}),
+    };
+    const mascotExpression = profile.mascotExpression?.trim() || undefined;
+    const mascotBody = profile.mascotBody?.trim() || undefined;
+    if (profile.color || mascotExpression || mascotBody || options.avatar) {
+        const crop = profile.avatarCrop === "rounded" || profile.avatarCrop === "square" ? profile.avatarCrop : "circle";
+        bot.appearance = {
+            color: profile.color ?? "green",
+            ...(mascotExpression ? { mascotExpression } : {}),
+            ...(mascotBody ? { mascotBody } : {}),
+            ...(options.avatar ? { avatar: { ...options.avatar, crop } } : {}),
+        };
+    }
+    const skills = [];
+    for (const template of defaults?.skills ?? []) {
+        const parsed = parseSkillMd(template.text);
+        if ("error" in parsed || parsed.name !== template.name) {
+            skipped.push({ part: `${part}.skills[${template.name}]`, reason: "skill_changed" });
+            continue;
+        }
+        if (skills.length >= AGENT_MAX_SKILLS) {
+            skipped.push({ part: `${part}.skills[${template.name}]`, reason: "bot_skill_limit" });
+            continue;
+        }
+        skills.push({
+            name: parsed.name,
+            description: parsed.description,
+            ...(template.source && isPortableSource(template.source) ? { source: template.source } : {}),
+            ...(parsed.license ? { license: parsed.license } : {}),
+            ...(parsed.compatibility ? { compatibility: parsed.compatibility } : {}),
+            instructions: template.text,
+            enabled: template.enabled,
+        });
+    }
+    const memory = {};
+    if (options.includeNotes) {
+        let files = 0;
+        let total = 0;
+        for (const path of Object.keys(defaults?.memory ?? {}).sort((a, b) => (a === "MEMORY.md" ? -1 : b === "MEMORY.md" ? 1 : a.localeCompare(b)))) {
+            const value = defaults.memory[path];
+            if (!value.trim())
+                continue;
+            const bytes = utf8Bytes(value);
+            if (bytes > SEED_FILE_MAX_BYTES || files >= SEED_MAX_FILES || total + bytes > SEED_MAX_BYTES) {
+                skipped.push({ part: `${part}.seed.memory[${JSON.stringify(path)}]`, reason: "notes_too_large" });
+                continue;
+            }
+            memory[path] = value;
+            files += 1;
+            total += bytes;
+        }
+    }
+    const hasContent = Object.keys(bot).length > 0 || skills.length > 0 || Object.keys(memory).length > 0;
+    if (!hasContent) {
+        skipped.push({ part, reason: "preset_empty" });
+        return { value: null, skipped };
+    }
+    const name = (options.name?.trim() || profile.name?.trim() || "New bot").slice(0, 100).trim();
+    const description = options.description?.trim().slice(0, 300) || undefined;
+    return {
+        value: {
+            preset: {
+                key: DEFAULTS_PRESET_KEY,
+                name,
+                ...(description ? { description } : {}),
+                bot,
+                ...(skills.length ? { skills: skills.map((skill) => skill.name) } : {}),
+                ...(Object.keys(memory).length ? { seed: { memory } } : {}),
+            },
+            skills,
+        },
+        skipped,
+    };
+}
+// ── what this installation last shared as a preset file ────────────────────
+const publishedLibrarySchema = z.object({ version: z.literal(1), packageId: z.string().regex(/^[a-z0-9][a-z0-9-]*$/).max(80), lastRelease: z.string().min(1).max(30) });
+export function readPublishedLibrary(file = PUBLISHED_LIBRARY_FILE) {
+    try {
+        const parsed = publishedLibrarySchema.parse(JSON.parse(readFileSync(file, "utf8")));
+        return { packageId: parsed.packageId, lastRelease: parsed.lastRelease };
+    }
+    catch {
+        // Nothing shared yet (or unreadable): the next share starts at 1.0.0.
+        return null;
+    }
+}
+export function writePublishedLibrary(entry, file = PUBLISHED_LIBRARY_FILE) {
+    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+    writeFileAtomic(file, JSON.stringify({ version: 1, ...entry }, null, 2), { mode: 0o600 });
+}

package/dist-server/server/provider-key-check.js

@@ -1,8 +1,9 @@
-export const PROVIDER_KEY_KINDS = ["anthropic", "openaiCompat", "xai"];
+export const PROVIDER_KEY_KINDS = ["anthropic", "openaiCompat", "xai", "mistral"];
 const DEFAULT_URLS = {
     anthropic: "https://api.anthropic.com",
     openaiCompat: "https://openrouter.ai/api/v1",
     xai: "https://api.x.ai/v1",
+    mistral: "https://api.mistral.ai/v1",
 };
 const MAX_MODELS = 5;
 function isLoopback(hostname) {
@@ -18,7 +19,7 @@ export function providerModelsUrl(provider, base) {
 }
 function modelIds(body) {
     const record = body && typeof body === "object" ? body : null;
-    const list = Array.isArray(record?.data) ? record.data : Array.isArray(record?.models) ? record.models : [];
+    const list = Array.isArray(body) ? body : Array.isArray(record?.data) ? record.data : Array.isArray(record?.models) ? record.models : [];
     const ids = [];
     for (const entry of list) {
         const item = entry && typeof entry === "object" ? entry : null;

package/dist-server/server/published-teams.js

@@ -0,0 +1,80 @@
+// What this installation has shared, per team: the package id and the
+// release last exported, plus the key each bot, group chat and routine was
+// published under.
+//
+// Keys are a package's identity across releases (Admin refuses a release
+// that silently drops one, and later updates match on them). They must not
+// come from names once they exist: renaming a bot, a room, a routine or the
+// team would otherwise read as "everything removed, everything added". So
+// the first export records them here, keyed by record id, and every later
+// export of the same team reuses them. Teams are name strings in OMB, so the
+// team entry is renamed with the section (section-context.ts calls
+// renamePublishedTeam from the one function every rename goes through).
+//
+// Server-private: nothing here is on the wire, and nothing here is a secret.
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+export const PUBLISHED_TEAMS_FILE = join(DATA_DIR, "published-teams.json");
+const keyMap = z.record(z.string(), z.string());
+const publishedTeamSchema = z.object({
+    packageId: z.string().min(1),
+    lastRelease: z.string().min(1),
+    keys: z.object({ bots: keyMap, rooms: keyMap, routines: keyMap }).default({ bots: {}, rooms: {}, routines: {} }),
+});
+const fileSchema = z.object({ version: z.literal(1), teams: z.record(z.string(), z.unknown()) });
+function load() {
+    const teams = new Map();
+    if (!existsSync(PUBLISHED_TEAMS_FILE))
+        return teams;
+    try {
+        const file = fileSchema.parse(JSON.parse(readFileSync(PUBLISHED_TEAMS_FILE, "utf8")));
+        // Own entries only: a team may be called anything, including __proto__.
+        for (const [section, value] of Object.entries(file.teams)) {
+            const entry = publishedTeamSchema.safeParse(value);
+            if (entry.success)
+                teams.set(section, entry.data);
+        }
+    }
+    catch {
+        // An unreadable record only costs key stability on the next export,
+        // which then derives keys from names as a first export does.
+    }
+    return teams;
+}
+function save(teams) {
+    mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 });
+    const out = Object.create(null);
+    for (const [section, entry] of teams)
+        out[section] = entry;
+    writeFileAtomic(PUBLISHED_TEAMS_FILE, JSON.stringify({ version: 1, teams: out }, null, 2), { mode: 0o600 });
+}
+export function readPublishedTeam(section) {
+    return load().get(section) ?? null;
+}
+export function writePublishedTeam(section, entry) {
+    const teams = load();
+    teams.set(section, entry);
+    save(teams);
+}
+/** Follow a team rename; null forgets the team (it was deleted). */
+export function renamePublishedTeam(name, nextName) {
+    const teams = load();
+    const entry = teams.get(name);
+    if (!entry || name === nextName)
+        return;
+    teams.delete(name);
+    if (nextName !== null)
+        teams.set(nextName, entry);
+    save(teams);
+}
+/** "1.2.3" → "1.2.4"; nothing published yet (or unreadable) starts at 1.0.0. */
+export function nextPatchRelease(release) {
+    const match = release?.match(/^(\d{1,6})\.(\d{1,6})\.(\d{1,6})$/);
+    if (!match)
+        return "1.0.0";
+    const [major, minor, patch] = match.slice(1).map(Number);
+    return patch < 999_999 ? `${major}.${minor}.${patch + 1}` : `${major}.${minor + 1}.0`;
+}

package/dist-server/server/recent-work.js

@@ -143,3 +143,18 @@ export function parseSince(value, now = Date.now()) {
     const parsed = Date.parse(/^\d{4}-\d{2}-\d{2}$/.test(text) ? `${text}T00:00` : value.trim());
     return Number.isFinite(parsed) ? parsed : null;
 }
+/** The forms that name a whole day rather than one instant. */
+const WHOLE_DAY = /^(?:today|yesterday|\d{4}-\d{2}-\d{2})$/;
+/** The closing end of a window a person types. `since` takes a day's first
+ * instant, so `until` has to take its last: read the same way, `since` and
+ * `until` on one day span no time at all and a full day of work reads back as
+ * nothing. Only the forms that name a day are stretched — a span ("24h"), an
+ * epoch, or a date with a clock time still means the instant it names. */
+export function parseUntil(value, now = Date.now()) {
+    const at = parseSince(value, now);
+    if (at === null || !WHOLE_DAY.test(value.trim().toLowerCase()))
+        return at;
+    const end = new Date(at);
+    end.setHours(23, 59, 59, 999);
+    return end.getTime();
+}