openmausbot 0.1.86 → 0.1.88

package/dist-server/server/bot-attachment.js

@@ -0,0 +1,107 @@
+// Lets a bot hand a finished file to the user as a real chat attachment.
+// The source is opened with the same hardened resolver the message-file route
+// uses (realpath containment, O_NOFOLLOW, size cap), then copied into the
+// private attachment store, so the chat never needs to reach into a bot's
+// workspace or VM home afterwards.
+import { basename, join, posix } from "node:path";
+import { extensionForFileMime, extensionForMime, FILE_MAX_BYTES, IMAGE_MAX_BYTES, saveFile, saveImage, } from "./attachments.js";
+import { mimeFor, openMessageFile } from "./message-file.js";
+export const ATTACH_SUPPORTED_TYPES = "images (png, jpg, gif, webp), video (mp4, webm, mov), audio (mp3, m4a, aac, wav, ogg, opus, flac), " +
+    "pdf, Word/Excel/PowerPoint and OpenDocument files, and csv, tsv, txt, md, json, rtf";
+function statusError(status, message) {
+    return Object.assign(new Error(message), { status });
+}
+/** Map a path inside a VM's durable workspace (for example
+ * /home/cua/workspace/report.pdf, optionally as a file:// URL) onto the host
+ * directory that is bind-mounted there. Anything outside the guest workspace,
+ * including `..` escapes, is not a VM path and returns null. */
+export function guestWorkspaceToHost(input, guestRoot, hostRoot) {
+    let value = input.trim();
+    if (/^file:\/\//i.test(value)) {
+        try {
+            value = decodeURIComponent(new URL(value).pathname);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!value.startsWith("/"))
+        return null;
+    const normalized = posix.normalize(value);
+    const relative = posix.relative(guestRoot, normalized);
+    if (!relative || relative === ".." || relative.startsWith("../") || posix.isAbsolute(relative))
+        return null;
+    return join(hostRoot, ...relative.split("/"));
+}
+/** A display name for the chat: the model's suggestion if it gave one, else
+ * the file's own name. Directory parts are dropped, never trusted. */
+function displayNameFor(requested, fallback) {
+    const cleaned = requested?.trim().replace(/\\/g, "/");
+    const name = cleaned ? posix.basename(cleaned) : "";
+    return name || fallback;
+}
+export async function saveBotAttachment(input) {
+    const requested = input.path.trim();
+    if (!requested)
+        throw statusError(400, "path is required");
+    const guestHost = input.guest ? guestWorkspaceToHost(requested, input.guest.root, input.guest.host) : null;
+    // A bot with a VM works in it: a relative path means its VM workspace first.
+    const roots = input.guest ? [input.guest.host, ...input.roots] : input.roots;
+    const file = await openMessageFile(guestHost ?? requested, roots);
+    try {
+        const mime = mimeFor(file.name);
+        const name = displayNameFor(input.name, file.name);
+        if (extensionForMime(mime)) {
+            if (file.bytes > IMAGE_MAX_BYTES)
+                throw statusError(413, `image exceeds ${IMAGE_MAX_BYTES} bytes`);
+            const saved = saveImage(await file.handle.readFile(), mime);
+            return { attachment: { kind: "image", path: saved.path, mime: saved.mime }, bytes: saved.bytes };
+        }
+        if (!extensionForFileMime(mime)) {
+            throw statusError(415, `${file.name} is not a supported attachment type. Supported: ${ATTACH_SUPPORTED_TYPES}.`);
+        }
+        if (file.bytes > FILE_MAX_BYTES)
+            throw statusError(413, `file exceeds ${FILE_MAX_BYTES} bytes`);
+        const saved = await saveFile(file.handle.createReadStream({ start: 0, autoClose: false }), name || basename(file.name), mime, {
+            expectedBytes: file.bytes,
+        });
+        return { attachment: { kind: "file", path: saved.path, mime: saved.mime, name: saved.name }, bytes: saved.bytes };
+    }
+    finally {
+        await file.handle.close().catch(() => undefined);
+    }
+}
+/**
+ * Attach one file for one provider turn. Two things must hold while the copy
+ * is awaited, so both are handled here rather than in the route:
+ *
+ * - The per-turn count is exact under parallel calls: the slot is reserved
+ *   before the await, so simultaneous calls cannot all pass the same check.
+ *   A call that fails or is refused gives its slot back.
+ * - Nothing is published for a turn that ended (stopped, replaced, deleted, or
+ *   moved) while the copy ran. `stillLive` is asked again after the await,
+ *   just before `publish`, and the copy is discarded when it says no.
+ */
+export async function attachForTurn(turn, max, hooks) {
+    const used = turn.attachedFiles ?? 0;
+    if (used >= max)
+        return { status: "limit" };
+    turn.attachedFiles = used + 1;
+    let saved;
+    let published = false;
+    try {
+        saved = await hooks.save();
+        if (!hooks.stillLive())
+            return { status: "ended" };
+        hooks.publish(saved);
+        published = true;
+        return { status: "attached", saved };
+    }
+    finally {
+        if (!published) {
+            turn.attachedFiles = Math.max(0, (turn.attachedFiles ?? 1) - 1);
+            if (saved !== undefined)
+                hooks.discard(saved);
+        }
+    }
+}

package/dist-server/server/bot-overview.js

@@ -126,6 +126,24 @@ export async function connectedAppsFacts(configured, availability, read) {
 function couldUseApps(facts) {
     return facts.bot.composio !== false && facts.connectedApps.configured && Boolean(facts.engine?.composioMcp);
 }
+/** Summarize a bot's connectorTools record for the Overview. Undefined in,
+ * undefined out: a bot with no record keeps legacy all-tools behavior and
+ * the field stays off the wire. An explicit record — even an empty one —
+ * becomes a (possibly empty) list, sorted by slug so both phones and the
+ * web dialog render it in one deterministic order. */
+export function grantsSummary(connectorTools) {
+    if (connectorTools === undefined)
+        return undefined;
+    return Object.entries(connectorTools)
+        .map(([slug, grant]) => {
+        if (grant.tools === "*")
+            return { slug, level: "all", toolCount: 0 };
+        if (grant.tools.length > 0)
+            return { slug, level: "partial", toolCount: grant.tools.length };
+        return { slug, level: "none", toolCount: 0 };
+    })
+        .sort((a, b) => (a.slug < b.slug ? -1 : 1));
+}
 function computerReach(computer) {
     switch (computer) {
         case "cloud":
@@ -210,6 +228,7 @@ export function buildBotOverview(facts) {
         reaches: reachesLines(facts),
         wont: wontLines(facts),
         recent: facts.recent,
+        grants: grantsSummary(facts.bot.connectorTools),
         setup: setupSteps(facts),
     };
 }

package/dist-server/server/bot-package.js

@@ -1,300 +1,26 @@
-import { z } from "zod";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { schemaIssue } from "./schema.js";
-import { isSkillName, parseSkillMd, SKILL_FILE_MAX_BYTES } from "./skills.js";
-import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
-import { normalizeCronSchedule } from "../shared/routine-schedule.js";
+import { stringify as stringifyYaml } from "yaml";
 import { cronScheduleLabel } from "../shared/cron-label.js";
-export const BOT_PACKAGE_FORMAT = "openmaus.package";
-export const BOT_PACKAGE_VERSION = 1;
-export const BOTMRR_MARKDOWN_VERSION = 1;
+import { BOTMRR_MARKDOWN_VERSION, isPackageDocument, PACKAGE_FORMAT, PACKAGE_V1_MAX_SKILLS, PACKAGE_V1_VERSION, parsePackageV1, utf8Bytes, } from "../shared/package-format.js";
+// The package file format (v1 and v2) lives in shared/package-format.ts: one
+// validation gate for the server, the renderer and Admin. This module keeps
+// the v1 names the v1 exporter and its Markdown playbook are written in, and
+// re-exports the v2 reader so server code has one place to import from.
+export { canonicalJson, downgradeToV1, PACKAGE_MAX_BYTES, PACKAGE_VERSION, PackageFormatError, packageKeys, packageScanFindings, packageSecretFindings, packageSummary, parsePackageDocument, redactPackageSecrets, upgradeV1, } from "../shared/package-format.js";
+export const BOT_PACKAGE_FORMAT = PACKAGE_FORMAT;
+export const BOT_PACKAGE_VERSION = PACKAGE_V1_VERSION;
+export { BOTMRR_MARKDOWN_VERSION };
 export const BOT_PACKAGE_SKILLS_VERSION = 1;
-export const BOT_PACKAGE_MAX_SKILLS = 20;
+export const BOT_PACKAGE_MAX_SKILLS = PACKAGE_V1_MAX_SKILLS;
 const BOT_PACKAGE_MARKDOWN_MAX_BYTES = 1_000_000;
-const COLORS = [
-    "green",
-    "blue",
-    "red",
-    "orange",
-    "purple",
-    "cyan",
-    "pink",
-    "yellow",
-    "teal",
-    "coral",
-];
-const requiredText = (max) => z.string({ error: "must be text" }).trim().min(1, { message: "is required" }).max(max, { message: "is too long" });
-const optionalText = (max) => z
-    .union([z.string({ error: "must be text" }), z.null(), z.undefined()])
-    .transform((value) => value?.trim() || undefined)
-    .refine((value) => value === undefined || value.length <= max, { message: "is too long" })
-    .optional();
-const key = requiredText(64).regex(/^[a-z0-9][a-z0-9_-]*$/, {
-    message: "may only contain lowercase letters, numbers, - and _",
-});
-const MAX_DATE_MS = 8_640_000_000_000_000;
-const skillName = requiredText(64).refine(isSkillName, {
-    message: "must be a lowercase skill name",
-});
-const portableSource = optionalText(2_000).refine((value) => value === undefined || !/^(?:[a-z]:[\\/]|[\\/]|\\\\|file:)/i.test(value), { message: "must not be an absolute path" });
-const skillInstructions = z
-    .string({ error: "must be text" })
-    .min(1, { message: "is required" })
-    .max(SKILL_FILE_MAX_BYTES, { message: "is too long" })
-    .refine((value) => Buffer.byteLength(value, "utf8") <= SKILL_FILE_MAX_BYTES, { message: "is too large" })
-    .refine((value) => /^---\r?\n/.test(value), { message: "must start with SKILL.md frontmatter" });
-const portableSkillSchema = z.object({
-    name: skillName,
-    description: requiredText(1_024),
-    source: portableSource,
-    license: optionalText(200),
-    compatibility: optionalText(200),
-    instructions: skillInstructions,
-});
-const CLOCK_TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
-const intervalWeekdays = z.array(z.number().int().min(0).max(6)).min(1).max(7).refine((weekdays) => new Set(weekdays).size === weekdays.length, "must contain unique weekdays");
-const intervalWindow = z.object({
-    start: z.string().regex(CLOCK_TIME, { message: "must use HH:MM" }),
-    end: z.string().regex(CLOCK_TIME, { message: "must use HH:MM" }),
-}).strict().refine(({ start, end }) => start < end, {
-    message: "must end later on the same day",
-});
-const packageRoutineScheduleSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("cron"), expression: requiredText(256), timeZone: requiredText(100) }).strict(),
-    z.object({ type: z.literal("once"), at: z.number().int() }),
-    z.object({
-        type: z.literal("daily"),
-        time: requiredText(5).regex(CLOCK_TIME, { message: "must use HH:MM" }),
-        weekdays: z.array(z.number().int().min(0).max(6)).min(1).max(7),
-    }),
-    z.object({
-        type: z.literal("interval"),
-        everyMinutes: z.number().int().min(5).max(1_440),
-        anchorAt: z.number().int().nonnegative().max(MAX_DATE_MS),
-        weekdays: intervalWeekdays.optional(),
-        window: intervalWindow.optional(),
-        endsAt: z.number().int().nonnegative().max(MAX_DATE_MS).optional(),
-    }),
-]).superRefine((schedule, context) => {
-    if (schedule.type === "cron") {
-        try {
-            normalizeCronSchedule(schedule);
-        }
-        catch (error) {
-            context.addIssue({ code: "custom", message: error instanceof Error ? error.message : "Invalid cron schedule" });
-        }
-        return;
-    }
-    if (schedule.type !== "interval")
-        return;
-    if (schedule.window) {
-        const [startHour, startMinute] = schedule.window.start.split(":").map(Number);
-        const [endHour, endMinute] = schedule.window.end.split(":").map(Number);
-        const windowMinutes = endHour * 60 + endMinute - (startHour * 60 + startMinute);
-        if (windowMinutes < schedule.everyMinutes) {
-            context.addIssue({
-                code: "custom",
-                message: "must be at least as long as the interval cadence",
-                path: ["window"],
-            });
-        }
-    }
-    if (schedule.endsAt !== undefined && schedule.endsAt < schedule.anchorAt) {
-        context.addIssue({
-            code: "custom",
-            message: "must not be before the interval anchor",
-            path: ["endsAt"],
-        });
-    }
-});
-const packageSchema = z.object({
-    format: z.literal(BOT_PACKAGE_FORMAT, { error: "This is not an OpenMaus package" }),
-    version: z.literal(BOT_PACKAGE_VERSION, { error: "Package version is not supported" }),
-    package: z.object({
-        id: requiredText(80).regex(/^[a-z0-9][a-z0-9-]*$/, { message: "must be a lowercase slug" }),
-        release: requiredText(30).regex(/^\d+\.\d+\.\d+$/, { message: "must be semantic versioning" }),
-        name: requiredText(100),
-        tagline: requiredText(160),
-        summary: requiredText(2_000),
-        category: requiredText(80),
-        author: z.object({ name: requiredText(100), url: optionalText(500) }),
-        license: requiredText(80),
-        featured: z.boolean().optional(),
-        tags: z.array(requiredText(80)).max(30).optional(),
-        outcomes: z.array(requiredText(240)).min(1).max(12),
-        setupMinutes: z.number().int().min(1).max(240),
-        requirements: z.object({
-            apps: z.array(z.object({
-                slug: key,
-                label: requiredText(100),
-                reason: requiredText(240),
-                optional: z.boolean().optional(),
-            })).max(30),
-            capabilities: z.array(requiredText(80)).max(20),
-            platforms: z.array(requiredText(80)).max(10).optional(),
-        }),
-        agents: z.array(z.object({
-            key,
-            name: requiredText(100),
-            title: optionalText(200),
-            description: optionalText(4_000),
-            soul: z.string().refine((value) => Buffer.byteLength(value, "utf8") <= BOT_PROFILE_LIMITS.soul, {
-                error: "standing instructions must be at most 24000 bytes",
-            }).optional(),
-            appearance: z.object({
-                color: z.enum(COLORS, { error: "is not supported" }),
-                mascotExpression: optionalText(80),
-                mascotBody: optionalText(40),
-            }),
-            playbooks: z.array(key).max(40).optional(),
-            skills: z.array(skillName).max(BOT_PACKAGE_MAX_SKILLS).optional(),
-        })).min(1).max(200),
-        chiefOfStaff: key.optional(),
-        rooms: z.array(z.object({
-            key,
-            name: requiredText(100),
-            members: z.array(key).min(1).max(200),
-            bulletin: optionalText(12_000),
-            defaultResponder: z.discriminatedUnion("kind", [
-                z.object({ kind: z.literal("agent"), agent: key }),
-                z.object({ kind: z.literal("everyone") }),
-                z.object({ kind: z.literal("mentions") }),
-            ]),
-        })).max(30).optional(),
-        routines: z.array(z.object({
-            key,
-            name: requiredText(80),
-            agent: key,
-            prompt: requiredText(20_000),
-            runOn: z.enum(["maus", "cloud"]),
-            schedule: packageRoutineScheduleSchema,
-            durationMinutes: z.number().int().min(5).max(240),
-            timeoutMinutes: z.number().int().min(5).max(240).optional(),
-            overlap: z.enum(["skip", "queue"]).optional(),
-            enabledAfterInstall: z.literal(false),
-        })).max(50).optional(),
-        playbooks: z.array(z.object({
-            key,
-            name: requiredText(100),
-            summary: requiredText(300),
-            triggers: z.array(requiredText(100)).min(1).max(30),
-            instructions: requiredText(24_000),
-        })).max(80).optional(),
-        skills: z.object({
-            version: z.literal(BOT_PACKAGE_SKILLS_VERSION),
-            entries: z.array(portableSkillSchema).min(1).max(BOT_PACKAGE_MAX_SKILLS),
-        }).optional(),
-        examples: z.array(z.object({
-            title: requiredText(120),
-            input: requiredText(4_000),
-            output: requiredText(8_000),
-        })).max(12).optional(),
-    }),
-});
 export function isBotPackage(value) {
-    if (typeof value === "string")
-        return /^---\r?\n[\s\S]*?\bbotmrr:\s*1\b/m.test(value);
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value) &&
-        value.format === BOT_PACKAGE_FORMAT;
+    return isPackageDocument(value);
 }
-function markdownDocument(markdown) {
-    if (Buffer.byteLength(markdown) > BOT_PACKAGE_MARKDOWN_MAX_BYTES)
-        throw new Error("The bot playbook is too large");
-    const frontmatter = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-    if (!frontmatter)
-        throw new Error("This Markdown is missing YAML frontmatter");
-    let metadata;
-    try {
-        metadata = parseYaml(frontmatter[1]);
-    }
-    catch {
-        throw new Error("This Markdown has invalid YAML frontmatter");
-    }
-    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
-        throw new Error("This Markdown is missing its BotMRR blueprint");
-    }
-    const { botmrr, ...definition } = metadata;
-    if (botmrr !== BOTMRR_MARKDOWN_VERSION)
-        throw new Error("BotMRR Markdown version is not supported");
-    for (const heading of ["Activation", "Mission", "Outcomes", "Connections", "Team", "Chief of Staff", "Completion rule"]) {
-        if (!markdown.includes(`## ${heading}`))
-            throw new Error(`This Markdown is missing its ${heading} section`);
-    }
-    return {
-        format: BOT_PACKAGE_FORMAT,
-        version: BOT_PACKAGE_VERSION,
-        package: definition,
-    };
-}
-/** Parse and cross-reference one complete, portable package. Unknown fields
- * are stripped; ids, grants, credentials, paths, model selections, and
- * runtime state therefore cannot ride through the package boundary. */
+/** Parse and cross-reference one complete v1 package. Unknown fields are
+ * stripped; ids, grants, credentials, paths, model selections, and runtime
+ * state therefore cannot ride through the package boundary. v2 documents
+ * go through parsePackageDocument instead. */
 export function parseBotPackage(value) {
-    const source = typeof value === "string" ? markdownDocument(value) : value;
-    const parsed = packageSchema.safeParse(source);
-    if (!parsed.success)
-        throw new Error(schemaIssue(parsed.error, "This is not a bot package"));
-    const pkg = parsed.data.package;
-    const unique = (values, label) => {
-        const seen = new Set();
-        for (const value of values) {
-            if (seen.has(value))
-                throw new Error(`Duplicate ${label} key: ${value}`);
-            seen.add(value);
-        }
-        return seen;
-    };
-    const agents = unique(pkg.agents.map((agent) => agent.key), "agent");
-    const playbooks = unique((pkg.playbooks ?? []).map((playbook) => playbook.key), "playbook");
-    const skills = unique((pkg.skills?.entries ?? []).map((skill) => skill.name), "skill");
-    unique((pkg.rooms ?? []).map((room) => room.key), "room");
-    unique((pkg.routines ?? []).map((routine) => routine.key), "routine");
-    if (pkg.chiefOfStaff && !agents.has(pkg.chiefOfStaff)) {
-        throw new Error(`Unknown Chief of Staff: ${pkg.chiefOfStaff}`);
-    }
-    for (const agent of pkg.agents) {
-        for (const playbook of agent.playbooks ?? []) {
-            if (!playbooks.has(playbook))
-                throw new Error(`Agent ${agent.key} references unknown playbook: ${playbook}`);
-        }
-        const assignedSkills = unique(agent.skills ?? [], `skill in agent ${agent.key}`);
-        for (const skill of assignedSkills) {
-            if (!skills.has(skill))
-                throw new Error(`Agent ${agent.key} references unknown skill: ${skill}`);
-        }
-    }
-    const referencedSkills = new Set(pkg.agents.flatMap((agent) => agent.skills ?? []));
-    for (const skill of pkg.skills?.entries ?? []) {
-        const parsed = parseSkillMd(skill.instructions);
-        if ("error" in parsed)
-            throw new Error(`Skill ${skill.name} is invalid: ${parsed.error}`);
-        if (parsed.name !== skill.name)
-            throw new Error(`Skill ${skill.name} does not match its SKILL.md name`);
-        if (parsed.description !== skill.description)
-            throw new Error(`Skill ${skill.name} does not match its description`);
-        for (const field of ["license", "compatibility"]) {
-            if (skill[field] !== undefined && skill[field] !== parsed[field]) {
-                throw new Error(`Skill ${skill.name} does not match its ${field}`);
-            }
-        }
-        if (!referencedSkills.has(skill.name))
-            throw new Error(`Skill ${skill.name} is not referenced by an agent`);
-    }
-    for (const room of pkg.rooms ?? []) {
-        const members = unique(room.members, `member in room ${room.key}`);
-        for (const member of members) {
-            if (!agents.has(member))
-                throw new Error(`Room ${room.key} references unknown agent: ${member}`);
-        }
-        if (room.defaultResponder.kind === "agent" && !members.has(room.defaultResponder.agent)) {
-            throw new Error(`Room ${room.key} has an unknown default responder`);
-        }
-    }
-    for (const routine of pkg.routines ?? []) {
-        if (!agents.has(routine.agent))
-            throw new Error(`Routine ${routine.key} references unknown agent: ${routine.agent}`);
-    }
-    return parsed.data;
+    return parsePackageV1(value);
 }
 const list = (values) => values.map((value) => `- ${value}`).join("\n");
 const WEEKDAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
@@ -368,7 +94,7 @@ export function renderBotPackageMarkdown(document) {
         ? pkg.requirements.apps.map((app) => `- **${app.label}${app.optional ? " (optional)" : ""}:** ${app.reason}`).join("\n")
         : "- No connected apps are required.";
     const markdown = `---\n${frontmatter}\n---\n\n# ${pkg.name}\n\n${pkg.tagline}\n\n> **Give this file to your Chief of Staff.** It is the complete team blueprint. Any agent system can run it; OpenMausBot can also install it directly.\n\n## Activation\n\nYou are the Chief of Staff for this blueprint. Read the whole document before acting. Confirm the user's goal and any missing inputs, then create or delegate to the specialist roles below. Preserve their names, ownership, boundaries, shared-room rules, and playbooks. If your platform cannot literally spawn agents, perform the roles one at a time and keep their outputs clearly separated.\n\nNever request pasted passwords or secret keys. Use the platform's normal connection flow. Do not send messages, publish content, spend money, delete data, or enable a schedule without the user's explicit approval. All routines start paused.\n\n## Mission\n\n${pkg.summary}\n\n## Outcomes\n\n${list(pkg.outcomes)}\n\n## Connections\n\n${connections}\n\n## Team\n\n${agents}\n\n## Chief of Staff\n\nThe Chief of Staff role is \`${pkg.chiefOfStaff ?? pkg.agents[0].key}\`. This role owns delegation, synthesis, conflict resolution, and the final answer to the user.\n${rooms ? `\n## Shared rooms\n\n${rooms}\n` : ""}${routines ? `\n## Suggested routines\n\n${routines}\n` : ""}${playbooks ? `\n## Playbooks\n\n${playbooks}\n` : ""}${examples ? `\n## Example job\n\n${examples}\n` : ""}\n## Completion rule\n\nReturn one clear result to the user, distinguish evidence from inference, cite source links when the work uses external material, and state what still needs human approval or a connected app.\n`;
-    if (Buffer.byteLength(markdown) > BOT_PACKAGE_MARKDOWN_MAX_BYTES)
+    if (utf8Bytes(markdown) > BOT_PACKAGE_MARKDOWN_MAX_BYTES)
         throw new Error("The bot playbook is too large");
     return markdown;
 }

package/dist-server/server/bot-profile.js

@@ -1,22 +1,10 @@
 import { z } from "zod";
 import { BOT_AVATAR_CROPS, botAvatarCropSchema, botAvatarUrlSchema } from "../shared/bot-avatar.js";
-import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
+import { BOT_PROFILE_LIMITS, fitsOnOneLine } from "../shared/bot-profile.js";
 import { MASCOT_BODY_IDS, mascotBodySchema } from "../shared/mascot-bodies.js";
-/** A name or title is quoted inside prompts and cards as one line — a
- * roster entry, a "Name: …" speaker line, the bracketed provenance note.
- * Text that can break out of that line (a newline, a control byte, the
- * Unicode separators) is refused at the door rather than flattened later,
- * so what the person sees in the sidebar is what every prompt sees too.
- * Written as a scan because a control-character class is the kind of
- * literal the linter (rightly) refuses. */
-export function fitsOnOneLine(value) {
-    for (let i = 0; i < value.length; i += 1) {
-        const code = value.charCodeAt(i);
-        if (code < 0x20 || (code >= 0x7f && code <= 0x9f) || code === 0x2028 || code === 0x2029)
-            return false;
-    }
-    return true;
-}
+// Shared with the package format, which checks the same rule on names it
+// carries; re-exported under its historical path.
+export { fitsOnOneLine } from "../shared/bot-profile.js";
 export const BOT_PROFILE_PATCH_FIELDS = [
     "name",
     "title",
@@ -29,7 +17,7 @@ export const BOT_PROFILE_PATCH_FIELDS = [
     "voice",
     "speakReplies",
 ];
-const profilePatchSchema = z.object({
+export const profilePatchSchema = z.object({
     name: z
         .string({ error: "name must be a string" })
         .max(BOT_PROFILE_LIMITS.name, { error: "name must be at most 100 characters" })

package/dist-server/server/box-create-idempotency.js

@@ -33,7 +33,7 @@ function isRequest(value) {
 }
 function recoveryStateError(detail, cause) {
     return Object.assign(new Error(`Cloud computer creation is paused because its recovery state is ${detail}. `
-        + "Check ascii.dev for an unnamed Box before repairing OpenMausBot's local state."), { status: 503, cause });
+        + "Check boat.dev for an unnamed Box before repairing OpenMausBot's local state."), { status: 503, cause });
 }
 function loadFresh() {
     let raw;
@@ -337,7 +337,7 @@ export function beginBoxCreate(botId, requestBody) {
                 // Once the provider forgets the idempotency key, retrying it (or using
                 // a new key) may create a second billable Box. Absence cannot be
                 // inferred from a lost response, so stop for manual reconciliation.
-                throw recoveryStateError("older than ascii.dev's 24-hour retry window");
+                throw recoveryStateError("older than boat.dev's 24-hour retry window");
             }
             return { request: { ...pending }, startedNow: false };
         }
@@ -356,7 +356,7 @@ export function beginBoxCreate(botId, requestBody) {
 /** Persist the returned identity before the caller attempts to rename it. */
 export function rememberCreatedBox(request, boxId) {
     if (!BOX_ID.test(boxId))
-        throw new Error("ascii.dev returned an invalid cloud computer id");
+        throw new Error("boat.dev returned an invalid cloud computer id");
     return withJournalLock((requests) => {
         const current = requests.find((candidate) => (candidate.botId === request.botId
             && candidate.requestBody === request.requestBody