openmausbot 0.1.86 → 0.1.88

package/dist-server/server/model-requests.js

@@ -0,0 +1,248 @@
+import { harnessCapabilityLines } from "./harness-capabilities.js";
+import { newId } from "./contracts.js";
+import { redactSecretsInText } from "./redact.js";
+const MAX_REASON = 500;
+const STALE = "This bot's default model changed after this card was prepared. Ask the bot to review it and propose again.";
+const NO_SUCH_BOT = "That bot no longer exists";
+export class ModelRequestError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.name = "ModelRequestError";
+        this.status = status;
+    }
+}
+const sameSelection = (a, b) => a.instanceId === b.instanceId && a.model === b.model && a.effort === b.effort && a.variant === b.variant;
+function reasonText(value) {
+    if (typeof value !== "string")
+        throw new ModelRequestError("reason is required");
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new ModelRequestError("reason is required");
+    if (trimmed.length > MAX_REASON)
+        throw new ModelRequestError("reason must be 500 characters or fewer");
+    return redactSecretsInText(trimmed);
+}
+/** Structural check only — the injected validateModel hook owns catalog and
+ * approval-compatibility checks with the live registry, at propose and again
+ * at confirm. */
+function parseSelection(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        throw new ModelRequestError("model_selection must be an object with instanceId and model");
+    }
+    const value = input;
+    if (typeof value.instanceId !== "string" || !value.instanceId.trim()) {
+        throw new ModelRequestError("model_selection.instanceId is required");
+    }
+    if (typeof value.model !== "string" || !value.model.trim()) {
+        throw new ModelRequestError("model_selection.model is required");
+    }
+    const selection = { instanceId: value.instanceId.trim(), model: value.model.trim() };
+    if (value.effort !== undefined) {
+        if (typeof value.effort !== "string" || !value.effort.trim())
+            throw new ModelRequestError("model_selection.effort must be a level name");
+        selection.effort = value.effort;
+    }
+    if (value.variant !== undefined) {
+        if (typeof value.variant !== "string" || !value.variant.trim())
+            throw new ModelRequestError("model_selection.variant must be a variant id");
+        selection.variant = value.variant;
+    }
+    return selection;
+}
+export function modelCardCopy(args) {
+    const title = args.crossBot
+        ? "Change @" + args.targetName + "'s default engine/model?"
+        : "Change " + args.targetName + "'s default engine/model?";
+    const lines = args.crossBot
+        ? ["Whose default model: @" + args.targetName, "Why: " + args.reason]
+        : ["Why: " + args.reason];
+    lines.push("Default engine/model: " + JSON.stringify(args.before) + " → " + JSON.stringify(args.selection));
+    lines.push(...args.capabilityLines);
+    // The same consent line the team-setup card shows for a model change:
+    // the default moves, saved thread selections do not.
+    lines.push("Default models apply to groups and new threads. Every existing thread keeps its current model and permissions.");
+    lines.push("Nothing runs.");
+    return { title, summary: title + " · default engine/model", detail: lines.join("\n") };
+}
+export class ModelRequestService {
+    store;
+    now;
+    canPersist;
+    autoApply;
+    validateTarget;
+    validateModel;
+    driverCapabilities;
+    constructor(options) {
+        this.store = options.store;
+        this.now = options.now ?? Date.now;
+        this.canPersist = options.canPersist;
+        this.autoApply = options.autoApply;
+        this.validateTarget = options.validateTarget;
+        this.validateModel = options.validateModel;
+        this.driverCapabilities = options.driverCapabilities;
+    }
+    propose(args) {
+        return this.prepare(args);
+    }
+    submit(args) {
+        const proposal = this.prepare(args, true);
+        return { ...proposal, state: proposal.result ? "applied" : "pending" };
+    }
+    prepare(args, submitted = false) {
+        const reason = reasonText(args.reason);
+        const selection = parseSelection(args.selection);
+        const targetBotId = args.targetBotId?.trim() || args.botId;
+        const target = this.store.bot(targetBotId);
+        if (!target)
+            throw new ModelRequestError(NO_SUCH_BOT, 404);
+        const crossBot = targetBotId !== args.botId;
+        if (crossBot && this.validateTarget) {
+            const refusal = this.validateTarget(args.botId, targetBotId);
+            if (refusal)
+                throw new ModelRequestError(refusal, 403);
+        }
+        if (sameSelection(selection, target.modelSelection))
+            throw new ModelRequestError("Nothing would change");
+        if (this.validateModel) {
+            const refusal = this.validateModel(selection, target);
+            if (refusal)
+                throw new ModelRequestError(refusal, 400);
+        }
+        const requestId = newId();
+        const targetName = redactSecretsInText(target.name);
+        const before = structuredClone(target.modelSelection);
+        const capabilityLines = this.driverCapabilities
+            ? harnessCapabilityLines(this.driverCapabilities(before.instanceId), this.driverCapabilities(selection.instanceId))
+            : [];
+        const payload = {
+            version: 1,
+            requestId,
+            botId: args.botId,
+            threadId: args.threadId,
+            targetBotId,
+            targetName,
+            createdAt: this.now(),
+            reason,
+            selection,
+            before,
+        };
+        const copy = modelCardCopy({ targetName, crossBot, before, selection, reason, capabilityLines });
+        const persistence = this.canPersist?.(args.botId, args.threadId);
+        if (persistence && !persistence.ok)
+            throw new ModelRequestError(persistence.error, persistence.status);
+        const automatic = submitted && this.autoApply?.(args.botId, args.threadId) === true;
+        const messageInput = {
+            role: "bot",
+            kind: "options",
+            card: {
+                title: copy.title,
+                subtitle: copy.detail,
+                options: automatic ? [] : ["Confirm", "Cancel"],
+                ...(automatic ? { dismissed: true } : {}),
+                requestId,
+                tool: "update_model",
+                modelRequest: payload,
+            },
+        };
+        if (args.from)
+            messageInput.from = args.from;
+        const message = this.store.appendMessage(args.threadId, messageInput);
+        const proposal = { requestId, messageId: message.id, title: copy.title, summary: copy.summary, detail: copy.detail };
+        if (!automatic)
+            return proposal;
+        const result = this.resolve({ botId: args.botId, threadId: args.threadId, requestId, behavior: "allow" });
+        if (result.state === "applied")
+            return { ...proposal, result };
+        throw new ModelRequestError(result.state === "invalid" ? result.error : "The model change could not be applied", result.state === "invalid" ? result.status : 409);
+    }
+    /** Claims a model card even after it was settled, so a duplicate click
+     * never re-applies an already-applied change. */
+    resolve(args) {
+        const message = this.store
+            .messagesFor(args.threadId)
+            .find((candidate) => candidate.card?.requestId === args.requestId && candidate.card.modelRequest);
+        const card = message?.card;
+        const payload = card?.modelRequest;
+        if (!message || !card || !payload)
+            return { claimed: false, state: "not_found" };
+        if (payload.requestId !== card.requestId) {
+            return { claimed: true, state: "invalid", error: "This model request does not match its card", status: 409 };
+        }
+        if (args.behavior !== "allow" && args.behavior !== "deny") {
+            return { claimed: true, state: "invalid", error: "Model confirmations must be confirmed or cancelled", status: 400 };
+        }
+        if (payload.botId !== args.botId || payload.threadId !== args.threadId) {
+            return { claimed: true, state: "invalid", error: "This model request belongs to another conversation", status: 403 };
+        }
+        if (card.answered)
+            return { claimed: true, state: "already_settled", behavior: card.answered };
+        // Cross-bot cards re-check authority on every allow, before any settle
+        // path can run: a proposer who lost Chief rights must not confirm, even
+        // when the requested selection is already live. Card level, not inside
+        // the try, so the crash-recovery catch cannot recast a refusal as an
+        // applied change.
+        if (args.behavior === "allow" && payload.targetBotId !== payload.botId && this.validateTarget) {
+            const refusal = this.validateTarget(payload.botId, payload.targetBotId);
+            if (refusal)
+                return { claimed: true, state: "invalid", error: refusal, status: 404 };
+        }
+        try {
+            const target = this.store.bot(payload.targetBotId);
+            if (!target)
+                throw new ModelRequestError(NO_SUCH_BOT, 404);
+            if (args.behavior === "deny") {
+                this.store.patchMessage(args.threadId, message.id, { card: { ...card, answered: "deny", held: undefined } });
+                return { claimed: true, state: "denied" };
+            }
+            // Idempotent close: if the exact requested selection is already the
+            // default (a crash after apply, or the same change arriving twice),
+            // settle the card without mutating anything again.
+            if (sameSelection(payload.selection, target.modelSelection)) {
+                const settled = this.store.patchMessage(args.threadId, message.id, {
+                    card: { ...card, answered: "allow", held: undefined, modelRequest: { ...payload, appliedAt: payload.appliedAt ?? this.now() } },
+                });
+                if (!settled)
+                    throw new ModelRequestError("This model confirmation card is no longer available", 409);
+                return { claimed: true, state: "already_settled", behavior: "allow" };
+            }
+            if (!sameSelection(payload.before, target.modelSelection)) {
+                throw new ModelRequestError(STALE, 409);
+            }
+            if (this.validateModel) {
+                const refusal = this.validateModel(payload.selection, target);
+                if (refusal)
+                    throw new ModelRequestError(refusal, 409);
+            }
+            if (!this.store.applyModelDefault(target.id, payload.selection))
+                throw new ModelRequestError(NO_SUCH_BOT, 404);
+            const appliedAt = this.now();
+            const settled = this.store.patchMessage(args.threadId, message.id, {
+                card: { ...card, answered: "allow", held: undefined, modelRequest: { ...payload, appliedAt } },
+            });
+            if (!settled)
+                throw new ModelRequestError("This model confirmation card is no longer available", 409);
+            return { claimed: true, state: "applied", targetBotId: target.id };
+        }
+        catch (error) {
+            const status = error instanceof ModelRequestError ? error.status : 400;
+            const detail = error instanceof Error ? error.message : String(error);
+            const applied = sameSelection(payload.selection, this.store.bot(payload.targetBotId)?.modelSelection ?? payload.before);
+            const notice = card.dismissed && card.options.length === 0
+                ? "Default model saved. Recording the operation receipt could not finish; the change will not be applied again."
+                : "Default model saved. Confirm again to finish recording this decision; the change will not be applied again.";
+            try {
+                this.store.patchMessage(args.threadId, message.id, {
+                    card: { ...card, held: applied ? notice : redactSecretsInText(detail).slice(0, 500) },
+                });
+            }
+            catch { /* The idempotent close above still permits a safe retry. */ }
+            if (applied)
+                return {
+                    claimed: true, state: "applied", targetBotId: payload.targetBotId,
+                    settlementPending: true, message: notice,
+                };
+            return { claimed: true, state: "invalid", error: detail, status };
+        }
+    }
+}

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

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { profilePatchSchema, fitsOnOneLine } from "./bot-profile.js";
+import { EFFORT_LEVELS } from "../shared/wire.js";
+import { isModelVariant } from "./contracts.js";
+import { normalizeCronSchedule } from "../shared/routine-schedule.js";
+const strings = (max, length) => z.array(z.string().max(length)).max(max);
+const clock = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
+const weekdays = z.array(z.number().int().min(0).max(6)).min(1).max(7);
+const timestamp = z.number().int().nonnegative().max(8_640_000_000_000_000);
+export const botDefaultModelSchema = z.object({
+    instanceId: z.string().trim().min(1).max(200),
+    model: z.string().trim().min(1).max(500),
+    effort: z.enum(EFFORT_LEVELS).optional(),
+    variant: z.string().refine(isModelVariant, "invalid model variant").optional(),
+}).strict().refine(value => value.effort === undefined || value.variant === undefined, "choose either a model variant or an effort level");
+// Preferences only. Consent flags, live grants, bot IDs and execution state
+// cannot be stored here and therefore cannot be replayed as permission grants.
+export const botDefaultsProfileSchema = profilePatchSchema.extend({
+    name: z.string().max(100).refine(fitsOnOneLine, "name must fit on one line").optional(),
+    section: z.string().trim().max(60).optional(),
+    color: z.enum(["green", "blue", "red", "orange", "purple", "cyan", "pink", "yellow", "teal", "coral"]).optional(),
+    mascotExpression: z.string().max(60).nullable().optional(),
+    modelSelection: botDefaultModelSchema.optional(),
+    computer: z.enum(["cloud", "vm", "local", "browser", "off"]).nullable().optional(),
+    cloudBackend: z.enum(["box", "vps"]).optional(),
+    autoStartVps: z.boolean().optional(),
+    cwd: z.string().max(4096).nullable().optional(),
+    approvalMode: z.enum(["ask", "auto", "full", "custom"]).optional(),
+    alwaysAllow: strings(200, 500).optional(),
+    chiefOfStaff: z.boolean().optional(),
+    managedSections: strings(100, 60).optional(),
+    approvePeerComms: z.boolean().optional(),
+    peers: strings(1000, 100).nullable().optional(),
+    composio: z.boolean().optional(),
+    browser: z.boolean().optional(),
+    browserProfile: z.string().max(100).nullable().optional(),
+    mcpServers: strings(100, 100).nullable().optional(),
+    parkDirectMessages: z.boolean().optional(),
+}).strict();
+const scheduleSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("once"), at: timestamp }).strict(),
+    z.object({ type: z.literal("daily"), time: clock, weekdays }).strict(),
+    z.object({
+        type: z.literal("interval"), everyMinutes: z.number().int().min(5).max(1440), anchorAt: timestamp,
+        weekdays: weekdays.nullable().optional(),
+        window: z.object({ start: clock, end: clock }).strict().nullable().optional(),
+        endsAt: timestamp.nullable().optional(),
+    }).strict(),
+    z.object({ type: z.literal("cron"), expression: z.string().max(256), timeZone: z.string().max(128) }).strict(),
+]).superRefine((value, ctx) => {
+    if (value.type === "cron") {
+        try {
+            normalizeCronSchedule(value);
+        }
+        catch (error) {
+            ctx.addIssue({ code: "custom", message: String(error) });
+        }
+    }
+    if (value.type === "interval" && value.window) {
+        const minutes = (time) => Number(time.slice(0, 2)) * 60 + Number(time.slice(3));
+        if (minutes(value.window.end) - minutes(value.window.start) < value.everyMinutes) {
+            ctx.addIssue({ code: "custom", message: "The interval must fit inside its time window" });
+        }
+    }
+});
+export const botRoutineTemplateSchema = z.object({
+    name: z.string().trim().min(1).max(80), prompt: z.string().trim().min(1).max(20_000),
+    schedule: scheduleSchema, enabled: z.boolean().optional(),
+    runOn: z.enum(["maus", "cloud"]).optional(),
+    durationMinutes: z.number().int().min(5).max(240).optional(),
+    timeoutMinutes: z.number().min(1).max(1440).nullable().optional(),
+    overlap: z.enum(["skip", "queue"]).optional(),
+    attachments: z.array(z.object({
+        id: z.string().min(1).max(200), kind: z.enum(["file", "image"]),
+        name: z.string().min(1).max(255), path: z.string().min(1).max(4096), size: z.number().nonnegative(),
+    }).strict()).max(50).optional(),
+}).strict();
+export const botSkillTemplateSchema = z.object({
+    name: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(64),
+    description: z.string().max(1024),
+    warnings: strings(100, 2000).default([]),
+    source: z.string().min(1).max(2000),
+    text: z.string().refine(value => Buffer.byteLength(value, "utf8") <= 262_144, "Skill exceeds 256 KiB"),
+    enabled: z.boolean(),
+}).strict();
+export const newBotDefaultsSchema = z.object({
+    profile: botDefaultsProfileSchema.default({}),
+    memory: z.record(z.string().regex(/^(?:MEMORY\.md|memory\/[a-zA-Z0-9_-]+\.md)$/), z.string().refine(value => Buffer.byteLength(value, "utf8") <= 262_144, "Memory file exceeds 256 KiB"))
+        .refine(value => Object.keys(value).length <= 100, "At most 100 memory files").default({}),
+    skills: z.array(botSkillTemplateSchema).max(100).default([]),
+    routines: z.array(botRoutineTemplateSchema).max(100).default([]),
+}).strict().refine(value => Buffer.byteLength(JSON.stringify(value), "utf8") <= 900_000, "Bot defaults must fit within 900 KB");
+/** Explicit values (including empty values) win. A resolved renderer draft
+ * opts out so deleted fields and template extras are not restored on POST. */
+export function resolveBotCreationDefaults(saved, body) {
+    if (body.useDefaults !== undefined && typeof body.useDefaults !== "boolean") {
+        throw Object.assign(new Error("useDefaults must be true or false"), { status: 400 });
+    }
+    const template = newBotDefaultsSchema.parse(body.useDefaults === false ? {} : saved ?? {});
+    const checked = botDefaultsProfileSchema.safeParse(body.settings === undefined ? {} : body.settings);
+    if (!checked.success)
+        throw Object.assign(new Error(checked.error.message), { status: 400 });
+    const explicit = checked.data;
+    const profile = { ...template.profile, ...explicit };
+    for (const key of ["name", "title", "description", "modelSelection", "section"]) {
+        if (Object.hasOwn(body, key))
+            Object.assign(profile, { [key]: key === "section" && body[key] === null ? "" : body[key] });
+    }
+    const resolved = botDefaultsProfileSchema.safeParse(profile);
+    if (!resolved.success)
+        throw Object.assign(new Error(resolved.error.message), { status: 400 });
+    if (!resolved.data.name?.trim())
+        delete resolved.data.name;
+    return { ...template, profile: resolved.data };
+}

package/dist-server/server/options-card.js

@@ -0,0 +1,21 @@
+import { parseOptionsCardInput, WATCHER_OPTIONS_CARD_BOT_ID, } from "../shared/options-card.js";
+/**
+ * Persist one passive, legacy options card. It deliberately has no requestId
+ * or tool field: clicking it replies to the conversation, but grants no tool
+ * approval and performs no external action.
+ */
+export function createOptionsCard(args) {
+    if (args.bot.id !== WATCHER_OPTIONS_CARD_BOT_ID) {
+        return { ok: false, status: 403, error: "create_options_card is not enabled for this bot." };
+    }
+    const parsed = parseOptionsCardInput(args.input);
+    if (!parsed.ok)
+        return { ok: false, status: 400, error: parsed.error };
+    const message = args.store.appendMessage(args.threadId, {
+        role: "bot",
+        kind: "options",
+        from: { botId: args.bot.id, name: args.bot.name, color: args.bot.color },
+        card: parsed.value,
+    });
+    return { ok: true, messageId: message.id };
+}