openmausbot 0.1.68 → 0.1.69

package/dist-server/server/routines.js

@@ -12,6 +12,9 @@ function routineRequestOwnerKey(owner) {
 const ALL_DAYS = [0, 1, 2, 3, 4, 5, 6];
 const CATCH_UP_MS = 12 * 60 * 60_000;
 const MAX_DATE_MS = 8_640_000_000_000_000;
+const LOCAL_DAY_MS = 24 * 60 * 60_000;
+const INTERVAL_RESTRICTION_SEARCH_MS = 9 * LOCAL_DAY_MS;
+const CLOCK_TIME = /^([01]\d|2[0-3]):([0-5]\d)$/;
 const MAX_RUNS = 2_000;
 const MAX_ATTACHMENTS = 50;
 const attachmentSchema = z.object({
@@ -86,7 +89,14 @@ function cloneSchedule(schedule) {
     if (schedule.type === "once")
         return { type: "once", at: schedule.at };
     if (schedule.type === "interval") {
-        return { type: "interval", everyMinutes: schedule.everyMinutes, anchorAt: schedule.anchorAt };
+        return {
+            type: "interval",
+            everyMinutes: schedule.everyMinutes,
+            anchorAt: schedule.anchorAt,
+            ...(schedule.weekdays ? { weekdays: [...schedule.weekdays] } : {}),
+            ...(schedule.window ? { window: { ...schedule.window } } : {}),
+            ...(schedule.endsAt === undefined ? {} : { endsAt: schedule.endsAt }),
+        };
     }
     return { type: "daily", time: schedule.time, weekdays: [...schedule.weekdays] };
 }
@@ -164,6 +174,57 @@ function composeExecutionPrompt(prompt, attachments, carry) {
     }
     return parts.filter(Boolean).join("\n\n");
 }
+function cleanIntervalWeekdays(value) {
+    if (value == null)
+        return undefined;
+    if (!Array.isArray(value) || value.length === 0 || value.length > ALL_DAYS.length) {
+        throw new Error("Choose at least one valid interval day");
+    }
+    if (value.some((day) => typeof day !== "number" || !Number.isInteger(day) || day < 0 || day > 6)) {
+        throw new Error("Interval days must be whole numbers from 0 to 6");
+    }
+    if (new Set(value).size !== value.length)
+        throw new Error("Choose each interval day only once");
+    const weekdays = [...value].sort((a, b) => a - b);
+    return weekdays.length === ALL_DAYS.length ? undefined : weekdays;
+}
+function clockMinutes(value) {
+    const match = CLOCK_TIME.exec(value);
+    return match ? Number(match[1]) * 60 + Number(match[2]) : null;
+}
+function cleanIntervalWindow(value, everyMinutes) {
+    if (value == null)
+        return undefined;
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Choose a valid interval time window");
+    }
+    const candidate = value;
+    const start = typeof candidate.start === "string" ? candidate.start : "";
+    const end = typeof candidate.end === "string" ? candidate.end : "";
+    const startMinutes = clockMinutes(start);
+    const endMinutes = clockMinutes(end);
+    if (startMinutes == null || endMinutes == null) {
+        throw new Error("Interval window times must use HH:MM");
+    }
+    if (startMinutes >= endMinutes) {
+        throw new Error("Interval window must start before it ends on the same day");
+    }
+    if (endMinutes - startMinutes < everyMinutes) {
+        throw new Error("Interval window must be at least as long as the interval");
+    }
+    return { start, end };
+}
+function cleanIntervalEndsAt(value, anchorAt) {
+    if (value == null)
+        return undefined;
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < anchorAt ||
+        value > MAX_DATE_MS) {
+        throw new Error("Choose a valid interval end time after its start");
+    }
+    return value;
+}
 function finishedOrder(run) {
     return run.finishedAt ?? run.createdAt;
 }
@@ -191,7 +252,17 @@ function cleanSchedule(schedule) {
             anchorAt > MAX_DATE_MS) {
             throw new Error("Choose a valid interval start time");
         }
-        return { type: "interval", everyMinutes, anchorAt };
+        const weekdays = cleanIntervalWeekdays(schedule.weekdays);
+        const window = cleanIntervalWindow(schedule.window, everyMinutes);
+        const endsAt = cleanIntervalEndsAt(schedule.endsAt, anchorAt);
+        return {
+            type: "interval",
+            everyMinutes,
+            anchorAt,
+            ...(weekdays ? { weekdays } : {}),
+            ...(window ? { window } : {}),
+            ...(endsAt === undefined ? {} : { endsAt }),
+        };
     }
     throw new Error("Choose a supported schedule");
 }
@@ -203,17 +274,56 @@ function loadSchedule(value) {
         return null;
     }
 }
+function intervalHasRestrictions(schedule) {
+    return schedule.weekdays !== undefined || schedule.window !== undefined || schedule.endsAt !== undefined;
+}
+function intervalAllowsOccurrence(schedule, at) {
+    if (schedule.endsAt !== undefined && at > schedule.endsAt)
+        return false;
+    const date = new Date(at);
+    if (schedule.weekdays && !schedule.weekdays.includes(date.getDay()))
+        return false;
+    if (schedule.window) {
+        const minute = date.getHours() * 60 + date.getMinutes();
+        const start = clockMinutes(schedule.window.start);
+        const end = clockMinutes(schedule.window.end);
+        if (minute < start || minute >= end)
+            return false;
+    }
+    return true;
+}
+function isSameLocalDay(left, right) {
+    const a = new Date(left);
+    const b = new Date(right);
+    return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function nextAlignedInterval(schedule, after) {
+    if (schedule.anchorAt > after)
+        return schedule.anchorAt;
+    const intervalMs = schedule.everyMinutes * 60_000;
+    const intervalsElapsed = Math.floor((after - schedule.anchorAt) / intervalMs);
+    const candidate = schedule.anchorAt + (intervalsElapsed + 1) * intervalMs;
+    return Number.isSafeInteger(candidate) && candidate <= MAX_DATE_MS ? candidate : null;
+}
 /** Next wall-clock occurrence in this computer's timezone, strictly after `after`. */
 export function nextOccurrence(schedule, after) {
     if (schedule.type === "once")
         return schedule.at > after ? schedule.at : null;
     if (schedule.type === "interval") {
-        if (schedule.anchorAt > after)
-            return schedule.anchorAt;
         const intervalMs = schedule.everyMinutes * 60_000;
-        const intervalsElapsed = Math.floor((after - schedule.anchorAt) / intervalMs);
-        const candidate = schedule.anchorAt + (intervalsElapsed + 1) * intervalMs;
-        return Number.isSafeInteger(candidate) && candidate <= MAX_DATE_MS ? candidate : null;
+        let candidate = nextAlignedInterval(schedule, after);
+        if (!intervalHasRestrictions(schedule))
+            return candidate;
+        const maxCandidates = Math.ceil(INTERVAL_RESTRICTION_SEARCH_MS / intervalMs) + 2;
+        for (let checked = 0; candidate !== null && checked < maxCandidates; checked++) {
+            if (schedule.endsAt !== undefined && candidate > schedule.endsAt)
+                return null;
+            if (intervalAllowsOccurrence(schedule, candidate))
+                return candidate;
+            const next = candidate + intervalMs;
+            candidate = Number.isSafeInteger(next) && next <= MAX_DATE_MS ? next : null;
+        }
+        return null;
     }
     const [hour, minute] = schedule.time.split(":").map(Number);
     const weekdays = new Set(cleanDays(schedule.weekdays));
@@ -227,10 +337,38 @@ export function nextOccurrence(schedule, after) {
     return null;
 }
 function latestIntervalOccurrence(schedule, at) {
-    if (schedule.anchorAt > at)
-        return null;
     const intervalMs = schedule.everyMinutes * 60_000;
-    return schedule.anchorAt + Math.floor((at - schedule.anchorAt) / intervalMs) * intervalMs;
+    const ceiling = Math.min(at, schedule.endsAt ?? at);
+    if (schedule.anchorAt > ceiling)
+        return null;
+    let candidate = schedule.anchorAt + Math.floor((ceiling - schedule.anchorAt) / intervalMs) * intervalMs;
+    if (!intervalHasRestrictions(schedule))
+        return candidate;
+    const maxCandidates = Math.ceil(INTERVAL_RESTRICTION_SEARCH_MS / intervalMs) + 2;
+    for (let checked = 0; checked < maxCandidates; checked++) {
+        if (intervalAllowsOccurrence(schedule, candidate))
+            return candidate;
+        const previous = candidate - intervalMs;
+        if (!Number.isSafeInteger(previous) || previous < schedule.anchorAt)
+            return null;
+        candidate = previous;
+    }
+    return null;
+}
+function mergeScheduleUpdate(current, incoming) {
+    if (current.type !== "interval" || incoming.type !== "interval")
+        return incoming;
+    const merged = { ...incoming };
+    if (!Object.hasOwn(incoming, "weekdays") && current.weekdays) {
+        merged.weekdays = [...current.weekdays];
+    }
+    if (!Object.hasOwn(incoming, "window") && current.window) {
+        merged.window = { ...current.window };
+    }
+    if (!Object.hasOwn(incoming, "endsAt") && current.endsAt !== undefined) {
+        merged.endsAt = current.endsAt;
+    }
+    return merged;
 }
 function sanitizeInput(input) {
     const name = String(input.name ?? "").trim().slice(0, 80);
@@ -467,13 +605,17 @@ export class RoutineManager {
         if (this.targetState(clean) === "missing")
             throw new Error(this.missingTargetMessage(clean.target));
         const at = this.now();
+        const nextRunAt = clean.enabled ? this.initialOccurrence(clean.schedule, at) : null;
+        if (clean.schedule.type === "interval" && clean.enabled && nextRunAt === null) {
+            throw new Error("This interval has no future runs. Choose a later end date or turn it off.");
+        }
         const routine = {
             id: randomUUID(),
             ...clean,
             // Only a confirmed chat card supplies `request`; the public calendar
             // API cannot choose an arbitrary transcript as a reporting target.
             sourceThreadId: request?.threadId,
-            nextRunAt: clean.enabled ? this.initialOccurrence(clean.schedule, at) : null,
+            nextRunAt,
             createdAt: at,
             updatedAt: at,
         };
@@ -505,7 +647,7 @@ export class RoutineManager {
             groupId: Object.hasOwn(patch, "groupId") ? patch.groupId : routine.groupId,
             runOn: patch.runOn ?? routine.runOn,
             enabled: patch.enabled ?? routine.enabled,
-            schedule: patch.schedule ?? routine.schedule,
+            schedule: patch.schedule ? mergeScheduleUpdate(routine.schedule, patch.schedule) : routine.schedule,
             durationMinutes: patch.durationMinutes ?? routine.durationMinutes,
             timeoutMinutes: Object.hasOwn(patch, "timeoutMinutes") ? patch.timeoutMinutes : routine.timeoutMinutes,
             attachments: patch.attachments ?? routine.attachments,
@@ -513,16 +655,19 @@ export class RoutineManager {
         });
         if (this.targetState(clean) === "missing")
             throw new Error(this.missingTargetMessage(clean.target));
-        const cancelledRuns = [];
         const scheduleChanged = JSON.stringify(clean.schedule) !== JSON.stringify(routine.schedule);
         const enabledChanged = clean.enabled !== routine.enabled;
+        // Definition-only edits retain due work and offline catch-up.
+        const nextRunAt = !clean.enabled ? null : scheduleChanged || enabledChanged
+            ? this.initialOccurrence(clean.schedule, now)
+            : routine.nextRunAt;
+        if (clean.schedule.type === "interval" && clean.enabled && nextRunAt === null) {
+            throw new Error("This interval has no future runs. Choose a later end date or turn it off.");
+        }
+        const cancelledRuns = [];
         this.commitMutation(() => {
             Object.assign(routine, clean, {
-                // Renaming/editing instructions must not skip an occurrence that
-                // became due since the last tick (or erase an offline catch-up).
-                nextRunAt: !clean.enabled ? null : scheduleChanged || enabledChanged
-                    ? this.initialOccurrence(clean.schedule, now)
-                    : routine.nextRunAt,
+                nextRunAt,
                 // `updatedAt` doubles as the optimistic revision on durable routine
                 // confirmation cards. Keep it monotonic even for two writes in one ms.
                 updatedAt: Math.max(now, routine.updatedAt + 1),
@@ -871,6 +1016,10 @@ export class RoutineManager {
                     routine.enabled = false;
                     routine.updatedAt = Math.max(now, routine.updatedAt + 1);
                 }
+                else if (routine.schedule.type === "interval" && routine.nextRunAt === null) {
+                    routine.enabled = false;
+                    routine.updatedAt = Math.max(now, routine.updatedAt + 1);
+                }
                 this.emitRoutine(routine);
                 changed = true;
             }
@@ -900,6 +1049,15 @@ export class RoutineManager {
                         this.save();
                         this.emitRun(run);
                     }
+                    const requiresCurrentDayOccurrence = definition.schedule.weekdays !== undefined || definition.schedule.window !== undefined;
+                    const mayDispatch = intervalAllowsOccurrence(definition.schedule, now) &&
+                        (!requiresCurrentDayOccurrence || (latest !== null && isSameLocalDay(latest, now)));
+                    if (!mayDispatch) {
+                        if (nextOccurrence(definition.schedule, now) === null) {
+                            this.missQueuedRun(run, "The routine ended before this scheduled run could start");
+                        }
+                        continue;
+                    }
                 }
                 const state = this.targetState(run);
                 if (state === "busy")
@@ -1071,6 +1229,15 @@ export class RoutineManager {
         this.emitRun(run);
         this.options.onRunFailed?.(cloneRun(run));
     }
+    missQueuedRun(run, message) {
+        run.status = "missed";
+        run.attention = undefined;
+        run.error = redactSecretsInText(message).slice(0, 500);
+        run.finishedAt = this.now();
+        this.save();
+        this.emitRun(run);
+        this.options.onRunFailed?.(cloneRun(run));
+    }
     targetState(target) {
         if (target.target === "room-goal") {
             if (!target.groupId || !this.options.goalState)

package/dist-server/server/steer-queue.js

@@ -18,6 +18,30 @@
 // the feature.
 import { newId } from "./contracts.js";
 const queues = new Map(); // threadId → waiting sends
+const listeners = new Set();
+const changed = () => {
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch {
+            console.warn("steer-queue: change listener failed");
+        }
+    }
+};
+/** Public pending chips only: never expose provider prompts or reply context. */
+export function queuedSteerSnapshot(ownsThread) {
+    return Object.fromEntries([...queues]
+        .filter(([threadId, entry]) => ownsThread(entry.botId, threadId))
+        .map(([threadId, entry]) => [threadId, entry.items.map((item) => ({
+            queueId: item.messageId, text: item.text, ...(item.reason ? { reason: item.reason } : {}),
+        }))]));
+}
+/** Publish changes synchronously so every client can restore/cancel the queue. */
+export function onSteeredQueueChange(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}
 /** Hold a mid-turn send off the transcript until drain. */
 export function queueSteeredMessage(botId, threadId, text, options = {}) {
     const id = newId();
@@ -35,6 +59,7 @@ export function queueSteeredMessage(botId, threadId, text, options = {}) {
         reason: options.reason,
     });
     queues.set(threadId, entry);
+    changed();
     return { id };
 }
 /** Drain every queue whose task is idle: append the held lines (leaf is now
@@ -53,6 +78,7 @@ export function drainSteeredMessages(store, run, isBlocked) {
         if (!bot) {
             // the bot or task was deleted while messages waited
             queues.delete(threadId);
+            changed();
             continue;
         }
         if (bot.busy || isBlocked?.(entry.botId, threadId))
@@ -60,6 +86,7 @@ export function drainSteeredMessages(store, run, isBlocked) {
         // committed to draining: the entry leaves the map before anything runs,
         // so a settle racing another settle can never fire the same queue twice
         queues.delete(threadId);
+        changed();
         const appended = [];
         for (const item of entry.items) {
             // queueId is the pending-chip identity from the 202; append still
@@ -107,6 +134,7 @@ export function cancelSteeredMessage(botId, messageId, expectedThreadId) {
             queues.delete(threadId);
         else
             queues.set(threadId, { botId: entry.botId, items });
+        changed();
         return true;
     }
     return false;

package/dist-server/shared/image-generation.js

@@ -0,0 +1,28 @@
+/** A deliberately configured Images API endpoint, not a provider-returned URL.
+ * Local HTTP is useful for self-hosted routers; internet endpoints require TLS. */
+export function normalizeImageGenerationUrl(value) {
+    const message = "Use an HTTPS API base URL, or HTTP for a local router, without passwords, query parameters or fragments";
+    let url;
+    try {
+        url = new URL(value.trim());
+    }
+    catch {
+        throw new Error(message);
+    }
+    if (value.length > 2048 || url.username || url.password || url.search || url.hash)
+        throw new Error(message);
+    const host = url.hostname.toLowerCase();
+    const ipv4 = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(host);
+    const local = host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")
+        || host === "host.docker.internal" || host === "host.containers.internal"
+        || host === "[::1]" || /^\[f[cd][0-9a-f]{2}:/.test(host)
+        || (ipv4 && (Number(ipv4[1]) === 127 || Number(ipv4[1]) === 10
+            || (Number(ipv4[1]) === 192 && Number(ipv4[2]) === 168)
+            || (Number(ipv4[1]) === 172 && Number(ipv4[2]) >= 16 && Number(ipv4[2]) <= 31)));
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && local))
+        throw new Error(message);
+    if (ipv4 && (Number(ipv4[1]) === 0 || (Number(ipv4[1]) === 169 && Number(ipv4[2]) === 254)))
+        throw new Error(message);
+    url.pathname = url.pathname.replace(/\/+$/, "").replace(/\/images\/generations$/, "");
+    return url.toString().replace(/\/+$/, "");
+}

package/dist-server/vps-container-mcp.js

@@ -14933,6 +14933,25 @@ function date4(params) {
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// shared/image-generation.ts
+function normalizeImageGenerationUrl(value) {
+  const message = "Use an HTTPS API base URL, or HTTP for a local router, without passwords, query parameters or fragments";
+  let url2;
+  try {
+    url2 = new URL(value.trim());
+  } catch {
+    throw new Error(message);
+  }
+  if (value.length > 2048 || url2.username || url2.password || url2.search || url2.hash) throw new Error(message);
+  const host = url2.hostname.toLowerCase();
+  const ipv43 = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(host);
+  const local = host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host === "host.docker.internal" || host === "host.containers.internal" || host === "[::1]" || /^\[f[cd][0-9a-f]{2}:/.test(host) || ipv43 && (Number(ipv43[1]) === 127 || Number(ipv43[1]) === 10 || Number(ipv43[1]) === 192 && Number(ipv43[2]) === 168 || Number(ipv43[1]) === 172 && Number(ipv43[2]) >= 16 && Number(ipv43[2]) <= 31);
+  if (url2.protocol !== "https:" && !(url2.protocol === "http:" && local)) throw new Error(message);
+  if (ipv43 && (Number(ipv43[1]) === 0 || Number(ipv43[1]) === 169 && Number(ipv43[2]) === 254)) throw new Error(message);
+  url2.pathname = url2.pathname.replace(/\/+$/, "").replace(/\/images\/generations$/, "");
+  return url2.toString().replace(/\/+$/, "");
+}
+
 // server/contracts.ts
 var EFFORT_LEVELS = ["none", "low", "medium", "high", "xhigh", "max"];
 
@@ -15133,8 +15152,25 @@ var appConfigSchema = external_exports.object({
    * engine: "elevenlabs" (default; needs a key) or "system" (the Mac's
    * built-in voices, no key). */
   tts: external_exports.object({ key: optionalText, voice: optionalText, provider: external_exports.enum(["elevenlabs", "system"]).optional() }).optional(),
-  /** OpenAI key used only by the in-process avatar image generator. */
-  imageGen: external_exports.object({ key: optionalText }).optional(),
+  /** Avatar provider credentials stay separate; choosing a router never reuses a cloud key. */
+  imageGen: external_exports.object({
+    provider: external_exports.enum(["openai", "xai", "custom"]).optional(),
+    key: optionalText,
+    customApiKey: optionalText,
+    customUrl: external_exports.string().trim().max(2048).transform((value, ctx) => {
+      if (!value) return "";
+      try {
+        return normalizeImageGenerationUrl(value);
+      } catch (error51) {
+        ctx.addIssue({ code: "custom", message: error51.message });
+        return external_exports.NEVER;
+      }
+    }).optional(),
+    customModel: external_exports.string().trim().max(200).refine(
+      (value) => !["\r", "\n", "\0"].some((character) => value.includes(character)),
+      "Use a model ID without control characters"
+    ).optional()
+  }).optional(),
   /** Non-secret profile details shown in the sidebar. */
   profile: external_exports.object({ name: optionalText, email: optionalText }).optional(),
   /** UI language override (BCP-47, lowercase). Empty/absent = follow the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmausbot",
-  "version": "0.1.68",
+  "version": "0.1.69",
   "description": "Run the OpenMausBot server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",