openmausbot 0.1.68 → 0.1.69

package/dist-server/server/drivers/agents-proxy.js

@@ -64,7 +64,7 @@ const WEEKDAYS = [
 const ROUTINE_SCHEDULE_SCHEMA = {
     type: "object",
     additionalProperties: false,
-    description: 'Either {"type":"once","at":RFC3339} for one future run, {"type":"weekly","time":"HH:MM","weekdays":[...]} for chosen days, {"type":"daily","time":"HH:MM"} for every day, or {"type":"interval","every_minutes":15,"starts_at":RFC3339} to repeat from an optional starting point.',
+    description: 'Either {"type":"once","at":RFC3339} for one future run, {"type":"weekly","time":"HH:MM","weekdays":[...]} for chosen days, {"type":"daily","time":"HH:MM"} for every day, or {"type":"interval","every_minutes":15} to repeat. Intervals can optionally be limited with weekdays, window_start + window_end, and ends_at.',
     properties: {
         type: {
             type: "string",
@@ -82,7 +82,7 @@ const ROUTINE_SCHEDULE_SCHEMA = {
         weekdays: {
             type: "array",
             items: { type: "string", enum: WEEKDAYS },
-            description: "Only for type weekly: which days the routine runs, in the computer's local timezone.",
+            description: "For type weekly: required run days. For type interval: optional allowed days. Values use the computer's local timezone.",
         },
         every_minutes: {
             type: "integer",
@@ -94,6 +94,30 @@ const ROUTINE_SCHEDULE_SCHEMA = {
             type: "string",
             description: "Optional for type interval: RFC3339 date-time with an explicit timezone offset that anchors the cadence. Omit to start one interval after confirmation.",
         },
+        window_start: {
+            type: "string",
+            description: "Optional for type interval, together with window_end: local 24-hour HH:MM when runs may begin, inclusive.",
+        },
+        window_end: {
+            type: "string",
+            description: "Optional for type interval, together with window_start: local 24-hour HH:MM when the allowed window ends, exclusive. It must be later on the same day.",
+        },
+        ends_at: {
+            type: "string",
+            description: "Optional for type interval: inclusive RFC3339 date-time cutoff with an explicit timezone offset.",
+        },
+        every_day: {
+            type: "boolean",
+            description: "Only for an interval update: true removes an existing weekday restriction.",
+        },
+        all_day: {
+            type: "boolean",
+            description: "Only for an interval update: true removes an existing time-window restriction.",
+        },
+        never_ends: {
+            type: "boolean",
+            description: "Only for an interval update: true removes an existing end cutoff.",
+        },
     },
     required: ["type"],
 };
@@ -111,7 +135,7 @@ const SHORT_WEEKDAYS = {
 };
 const SUPPORTED_SCHEDULES = 'Supported schedules: {"type":"once","at":"2026-09-01T09:00:00+05:30"} (future RFC3339 with explicit offset), ' +
     '{"type":"weekly","time":"09:00","weekdays":["monday","friday"]}, {"type":"daily","time":"09:00"}, ' +
-    'or {"type":"interval","every_minutes":15}.';
+    'or {"type":"interval","every_minutes":15,"weekdays":["monday","friday"],"window_start":"09:00","window_end":"17:00"}.';
 /** A schedule as the harness accepts it, or a message telling the model
  * exactly what to send instead. Coercion first, error second: models
  * routinely stringify nested objects, say "daily", or shorten weekday
@@ -135,7 +159,7 @@ function normalizeScheduleInput(args) {
         : type === "weekly" || type === "daily"
             ? ["type", "time", "weekdays"]
             : type === "interval"
-                ? ["type", "every_minutes", "everyMinutes", "starts_at", "anchorAt"]
+                ? ["type", "every_minutes", "everyMinutes", "starts_at", "anchorAt", "weekdays", "every_day", "window_start", "window_end", "window", "all_day", "ends_at", "endsAt", "never_ends"]
                 : null;
     // Provider conversions may send unused optional fields as null. Ignore
     // those, but never silently discard an actual scheduling constraint (for
@@ -181,6 +205,16 @@ function normalizeScheduleInput(args) {
         return { schedule: { type: "weekly", time, weekdays: normalized } };
     }
     if (type === "interval") {
+        for (const flag of ["every_day", "all_day", "never_ends"]) {
+            if (raw[flag] != null && typeof raw[flag] !== "boolean") {
+                return { error: `"${flag}" must be true or false.` };
+            }
+        }
+        if (raw.window != null && (!jsonRecord(raw.window)
+            || Object.keys(raw.window).some((key) => key !== "start" && key !== "end")
+            || typeof raw.window.start !== "string" || typeof raw.window.end !== "string")) {
+            return { error: '"window" must contain "start" and "end" in HH:MM, for example {"start":"09:00","end":"17:00"}.' };
+        }
         const rawMinutes = raw.every_minutes ?? raw.everyMinutes;
         const everyMinutes = Number(rawMinutes);
         if (!Number.isInteger(everyMinutes) || everyMinutes < 5 || everyMinutes > 1_440) {
@@ -190,11 +224,68 @@ function normalizeScheduleInput(args) {
         if (rawStart !== undefined && (typeof rawStart !== "string" || !rawStart.trim())) {
             return { error: '"starts_at" must be an RFC3339 date-time with an explicit timezone offset.' };
         }
+        if (raw.every_day === true && Array.isArray(raw.weekdays) && raw.weekdays.length > 0) {
+            return { error: 'Choose interval "weekdays" or "every_day", not both.' };
+        }
+        let intervalWeekdays;
+        if (raw.every_day === true) {
+            intervalWeekdays = null;
+        }
+        else if (raw.weekdays !== undefined) {
+            if (!Array.isArray(raw.weekdays) || raw.weekdays.length === 0) {
+                return { error: 'Interval "weekdays" must contain at least one full weekday name.' };
+            }
+            intervalWeekdays = [];
+            for (const day of raw.weekdays) {
+                const lower = String(day).trim().toLowerCase();
+                const full = WEEKDAYS.includes(lower)
+                    ? lower
+                    : Object.hasOwn(SHORT_WEEKDAYS, lower)
+                        ? SHORT_WEEKDAYS[lower]
+                        : undefined;
+                if (!full)
+                    return { error: `Unsupported weekday "${String(day)}". Use full names: ${WEEKDAYS.join(", ")}.` };
+                if (!intervalWeekdays.includes(full))
+                    intervalWeekdays.push(full);
+            }
+        }
+        const rawWindow = jsonRecord(raw.window) ? raw.window : undefined;
+        const windowStart = raw.window_start ?? rawWindow?.start;
+        const windowEnd = raw.window_end ?? rawWindow?.end;
+        if (raw.all_day === true && (windowStart !== undefined || windowEnd !== undefined)) {
+            return { error: 'Choose window_start + window_end or "all_day", not both.' };
+        }
+        let window;
+        if (raw.all_day === true) {
+            window = null;
+        }
+        else if (windowStart !== undefined || windowEnd !== undefined) {
+            if (typeof windowStart !== "string" || !windowStart.trim() || typeof windowEnd !== "string" || !windowEnd.trim()) {
+                return { error: 'An interval time window needs both "window_start" and "window_end" in 24-hour HH:MM.' };
+            }
+            window = { start: windowStart.trim(), end: windowEnd.trim() };
+        }
+        const rawEnd = raw.ends_at ?? raw.endsAt;
+        if (raw.never_ends === true && rawEnd !== undefined) {
+            return { error: 'Choose "ends_at" or "never_ends", not both.' };
+        }
+        let endsAt;
+        if (raw.never_ends === true)
+            endsAt = null;
+        else if (rawEnd !== undefined) {
+            if (typeof rawEnd !== "string" || !rawEnd.trim()) {
+                return { error: '"ends_at" must be an RFC3339 date-time with an explicit timezone offset.' };
+            }
+            endsAt = rawEnd.trim();
+        }
         return {
             schedule: {
                 type: "interval",
                 everyMinutes,
                 ...(typeof rawStart === "string" ? { anchorAt: rawStart.trim() } : {}),
+                ...(intervalWeekdays !== undefined ? { weekdays: intervalWeekdays } : {}),
+                ...(window !== undefined ? { window } : {}),
+                ...(endsAt !== undefined ? { endsAt } : {}),
             },
         };
     }

package/dist-server/server/drivers/codex-device-auth.js

@@ -45,6 +45,7 @@ function loginFailure(output) {
  * output stays in bounded private memory; only a device URL/code is exposed. */
 export class CodexDeviceAuthController {
     flow = null;
+    command = null;
     disposed = false;
     options;
     constructor(options) { this.options = options; }
@@ -121,12 +122,111 @@ export class CodexDeviceAuthController {
         await this.flow?.stopping;
         if (this.flow?.terminationFailed)
             throw new Error(this.flow.status.message);
+        if (this.command && !await this.stopChild(this.command)) {
+            throw new Error("Codex could not be stopped on this server. Ask the server administrator to stop the account command before trying again.");
+        }
     }
     async dispose() {
         this.disposed = true;
         await this.cancel();
         this.flow = null;
     }
+    /** Remove the ChatGPT sign-in Codex stores for this server account so a
+     * different account can connect. A sign-in in progress is never pulled
+     * away underneath the browser completing it. */
+    async signOut() {
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        if (this.flow?.status.phase === "waiting")
+            throw new Error("Finish or cancel the ChatGPT sign-in in progress before signing out.");
+        await this.flow?.stopping;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        const env = this.options.environment();
+        const home = env.HOME || env.USERPROFILE || homedir();
+        if (!isAbsolute(home) || (env.CODEX_HOME && !isAbsolute(env.CODEX_HOME))) {
+            throw new Error("Use an absolute HOME and CODEX_HOME path for this server's Codex provider before signing out.");
+        }
+        const homeKey = canonicalPath(resolve(env.CODEX_HOME || join(home, ".codex")));
+        if (authenticatingHomes.has(homeKey)) {
+            throw new Error("A ChatGPT sign-in is running for this server account. Finish or cancel it before signing out.");
+        }
+        authenticatingHomes.add(homeKey);
+        try {
+            const before = await this.exec(["login", "status"], env, home);
+            if (before.code === 1 && /^not logged in\b/im.test(before.output))
+                return;
+            if (before.code !== 0 || !/^logged in.*chatgpt\b/im.test(before.output)) {
+                throw new Error("Codex did not confirm a ChatGPT sign-in. Other authentication methods will not be removed; ask the server administrator to check the account.");
+            }
+            const logout = await this.exec(["logout"], env, home);
+            if (logout.code !== 0)
+                throw new Error("Codex could not remove the sign-in on this server. Check the server's Codex installation and try again.");
+            // The command's own report is not enough: confirm with the same status
+            // check that decides whether bots may run on this account.
+            const status = await this.exec(["login", "status"], env, home);
+            if (status.code !== 1 || !/^not logged in\b/im.test(status.output)) {
+                throw new Error("Codex still reports a sign-in on this server. Update Codex and check its login status before trying again.");
+            }
+        }
+        finally {
+            // If the OS cannot stop a command, it may still change credentials.
+            // Keep the home reserved until that exact child actually exits.
+            const child = this.command;
+            if (child && child.exitCode === null && child.signalCode === null) {
+                child.once("close", () => authenticatingHomes.delete(homeKey));
+            }
+            else
+                authenticatingHomes.delete(homeKey);
+        }
+    }
+    /** One bounded, non-interactive Codex command. Its output stays here;
+     * callers see an exit code and a status-line match, never the text. */
+    exec(args, env, cwd) {
+        return new Promise((resolveExec, rejectExec) => {
+            if (this.disposed) {
+                rejectExec(new Error("This provider was removed. Refresh Settings before signing out."));
+                return;
+            }
+            let child;
+            try {
+                child = spawnCli(this.options.cli, args, { env: { ...env, NO_COLOR: "1" }, cwd, stdio: ["pipe", "pipe", "pipe"] });
+            }
+            catch {
+                rejectExec(new Error("Codex could not start on this server. Install or update the configured Codex CLI, then try again."));
+                return;
+            }
+            this.command = child;
+            child.stdin.end();
+            let output = "";
+            const receive = (chunk) => {
+                if (output.length < MAX_OUTPUT)
+                    output += chunk.toString("utf8").slice(0, MAX_OUTPUT - output.length);
+            };
+            child.stdout.on("data", receive);
+            child.stderr.on("data", receive);
+            // A hung CLI must not hold the credential-home lock forever.
+            const timer = setTimeout(() => {
+                void this.stopChild(child).catch(() => false).then((stopped) => {
+                    if (!stopped)
+                        rejectExec(new Error("Codex could not be stopped on this server. Ask the server administrator to stop the account command before trying again."));
+                });
+            }, this.options.startupTimeoutMs ?? 30_000);
+            timer.unref();
+            child.once("error", (error) => {
+                clearTimeout(timer);
+                rejectExec(new Error(error.code === "ENOENT"
+                    ? "Codex is not installed on this server. Run npm install -g @openai/codex@latest on the server, then try again."
+                    : "Codex could not start on this server. Check the configured CLI path and its executable permissions."));
+            });
+            child.once("close", (code) => {
+                clearTimeout(timer);
+                if (this.command === child)
+                    this.command = null;
+                resolveExec({ code, output: stripVTControlCharacters(output) });
+            });
+        });
+    }
     run(flow, args, env, cwd, done, parsePrompt = false) {
         if (flow.status.phase !== "waiting")
             return;
@@ -188,7 +288,7 @@ export class CodexDeviceAuthController {
             else
                 flow.reject(new Error(message ?? "ChatGPT sign-in did not finish."));
         }
-        flow.stopping = this.stopChild(flow).catch(() => false).then((stopped) => {
+        flow.stopping = this.stopChild(flow.child).catch(() => false).then((stopped) => {
             const release = () => authenticatingHomes.delete(flow.homeKey);
             if (stopped) {
                 release();
@@ -206,8 +306,7 @@ export class CodexDeviceAuthController {
         if (phase === "succeeded")
             void this.options.onAuthenticated?.().catch(() => { });
     }
-    async stopChild(flow) {
-        const child = flow.child;
+    async stopChild(child) {
         if (!child || await killCliTree(child, this.options.terminateTimeoutMs ?? 1500))
             return true;
         // A broken CLI may ignore SIGTERM. Do not leave a stale device flow able

package/dist-server/server/drivers/codex-identity.js

@@ -0,0 +1,115 @@
+// Let Codex resolve its effective account, including keyring credentials.
+// Reading auth.json directly can label an API-key or keyring login with an
+// old file's email. Only the protocol's display email leaves this helper.
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { killCliTree, spawnCli } from "../procs.js";
+const MAX_OUTPUT = 16_384;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/** Where this environment's Codex keeps its credentials, or null when the
+ * configured home is not absolute (the login controller refuses those too). */
+export function codexHome(env) {
+    if (env.CODEX_HOME)
+        return isAbsolute(env.CODEX_HOME) ? resolve(env.CODEX_HOME) : null;
+    const home = env.HOME || env.USERPROFILE || homedir();
+    return isAbsolute(home) ? join(home, ".codex") : null;
+}
+/** Read-only account metadata. Unsupported CLIs and uncertain responses stay
+ * unnamed; never fall back to a potentially inactive credential file. */
+export async function codexAccountEmail(cli, env, timeoutMs = 3_000) {
+    const cwd = env.HOME || env.USERPROFILE || homedir();
+    if (!isAbsolute(cwd) || !codexHome(env))
+        return null;
+    return new Promise((resolveEmail) => {
+        let child;
+        try {
+            child = spawnCli(cli, ["app-server"], { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+        }
+        catch {
+            resolveEmail(null);
+            return;
+        }
+        let finishing = false;
+        let buffer = "";
+        let outputBytes = 0;
+        let initialized = false;
+        const finish = async (email) => {
+            if (finishing)
+                return;
+            finishing = true;
+            clearTimeout(timer);
+            let stopped = await killCliTree(child, 1_000);
+            if (!stopped && child.pid) {
+                try {
+                    if (process.platform === "win32")
+                        child.kill("SIGKILL");
+                    else
+                        process.kill(-child.pid, "SIGKILL");
+                }
+                catch {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch { /* already gone */ }
+                }
+                stopped = await killCliTree(child, 1_000);
+            }
+            resolveEmail(stopped ? email : null);
+        };
+        const timer = setTimeout(() => { void finish(null); }, timeoutMs);
+        timer.unref();
+        const send = (message) => {
+            try {
+                child.stdin.write(`${JSON.stringify(message)}\n`);
+            }
+            catch {
+                void finish(null);
+            }
+        };
+        child.stdin.on("error", () => { void finish(null); });
+        child.stderr.resume(); // Do not retain or log raw CLI errors or credentials.
+        child.on("error", () => { void finish(null); });
+        child.on("close", () => { void finish(null); });
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            if (finishing)
+                return;
+            outputBytes += Buffer.byteLength(chunk);
+            if (outputBytes > MAX_OUTPUT) {
+                void finish(null);
+                return;
+            }
+            buffer += chunk;
+            let newline;
+            while (!finishing && (newline = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                if (!line.trim())
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    void finish(null);
+                    return;
+                }
+                if (!initialized && message?.id === 1) {
+                    if (message.error || !message.result) {
+                        void finish(null);
+                        return;
+                    }
+                    initialized = true;
+                    send({ method: "initialized", params: {} });
+                    send({ id: 2, method: "account/read", params: { refreshToken: false } });
+                }
+                else if (initialized && message?.id === 2) {
+                    const account = message.error ? null : message.result?.account;
+                    const email = account?.type === "chatgpt" ? account.email : null;
+                    void finish(typeof email === "string" && email.length <= 254 && EMAIL.test(email) && !/[\p{Cc}\p{Cf}]/u.test(email) ? email : null);
+                }
+            }
+        });
+        send({ id: 1, method: "initialize", params: { clientInfo: { name: "openmausbot", version: "1" } } });
+    });
+}

package/dist-server/server/drivers/codex.js

@@ -24,6 +24,7 @@ import { classifyError, computeBackoff, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
 import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 import { CodexDeviceAuthController } from "./codex-device-auth.js";
+import { codexAccountEmail } from "./codex-identity.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
 const ASTRA_MODEL_ID = "gpt-6-astra";
@@ -1093,11 +1094,15 @@ export const CodexDriver = {
             const authenticated = await new Promise((resolve) => {
                 execCli(config.cli, ["login", "status"], { timeout: 8000, env }, (err, stdout, stderr) => resolve(!err && /^logged in\b/im.test(`${stdout}\n${stderr ?? ""}`)));
             });
+            // Display identity only, so Settings can say whose ChatGPT account the
+            // bots run on; the status command above stays the authority on sign-in.
+            const email = authenticated ? await codexAccountEmail(config.cli, env) : null;
             // childEnv drops OPENAI_API_KEY on purpose — turns run on the ChatGPT login
             return {
                 state: "available",
                 version,
                 authenticated,
+                ...(email ? { account: { email } } : {}),
                 update: codexAstraUpdate(version, models, config.cli),
                 billing: "subscription",
             };
@@ -1114,6 +1119,7 @@ export const CodexDriver = {
             startAuthentication: () => authentication.start(),
             getAuthentication: (flowId) => authentication.get(flowId),
             cancelAuthentication: () => authentication.cancel(),
+            signOut: () => authentication.signOut(),
             snapshot,
             adapter: {
                 provider: DRIVER_KIND,

package/dist-server/server/harness/registry.js

@@ -213,6 +213,8 @@ export class ProviderRegistry {
                             : inst.getAuthentication
                                 ? "device-code" // a code to enter at the provider's page (Codex)
                                 : "browser", // a link and a callback URL (managed engines)
+                        // the browser may remove the stored sign-in to switch accounts
+                        signOut: inst.signOut !== undefined,
                     }
                     : undefined,
                 cli: this.cliByInstance.get(inst.instanceId),

package/dist-server/server/index.js

@@ -21,7 +21,7 @@ import { appendDecision, readDecisions } from "./decision-log.js";
 import { validateBotCwd } from "./bot-cwd.js";
 import { ATTACHMENTS_DIR, attachmentExists, cleanupStaleAttachmentPartials, deleteAttachment, extensionForMime, FILE_MAX_BYTES, IMAGE_MAX_BYTES, readAttachment, saveFile, saveImage, saveImageUpload, validateAttachmentUploadId, } from "./attachments.js";
 import { messageFileDisposition, messageFileDownloadName, messageAttachmentName, messageFileRoots, messageImageTargetAt, messageReferencesFile, openMessageFile, } from "./message-file.js";
-import { avatarGenerationRequestSchema, avatarGenerationStateMatches, generateAvatarImage, snapshotAvatarGenerationState, } from "./avatar-image.js";
+import { avatarGenerationRequestSchema, avatarGenerationStateMatches, generateAvatarImage, avatarImageStatus, snapshotAvatarGenerationState, } from "./avatar-image.js";
 import { fitsOnOneLine, parseBotProfilePatch } from "./bot-profile.js";
 import { groupTurnCwd } from "./room-cwd.js";
 import { RoomTurnDeadline, RoomTurnStallRegistry, roomTurnTimeoutMessage } from "./room-turn-timeout.js";
@@ -54,7 +54,7 @@ import { claimRecallCrossings, recallCrossingLabel } from "./recall-disclosure.j
 const SESSION_READ_MAX_CHARS = 8_000;
 import { promptWithReply, transcriptText } from "./replies.js";
 import { _loadPending, buildDelegationFailurePrompt, buildDelegationRevivalPrompt, DelegationWakeBudget, discardDelegations, drainDelegations, findDelegationReceipt, pendingDelegationInfo, pendingDelegationSnapshot, pendingThreads, queueDelegation, recordDelegationReceipt, releaseDelegationsWaitingOn, summarizeDelegatedActivity } from "./delegations.js";
-import { cancelSteeredMessage, drainSteeredMessages, queuedSteeredMessage, queueSteeredMessage, } from "./steer-queue.js";
+import { cancelSteeredMessage, drainSteeredMessages, onSteeredQueueChange, queuedSteerSnapshot, queuedSteeredMessage, queueSteeredMessage, } from "./steer-queue.js";
 import { cancelChannelMessage, drainChannelMessages, queuedChannelMessage, queueChannelMessage, } from "./channel-queue.js";
 import { acceptedSendMatch, parseSendId, sendFingerprint, SendSequencer, } from "./send-idempotency.js";
 import { EventBus } from "./harness/bus.js";
@@ -1368,6 +1368,7 @@ const publicBot = (bot) => ({
     activeLeafId: store.activeLeaf(bot.threadId),
     tasks: store.tasks(bot.id).map(wireTask),
 });
+const publicBotQueuedMessages = () => queuedSteerSnapshot((botId, threadId) => Boolean(store.taskByThread(botId, threadId)));
 // busyBotId names only the speaker that currently owns the provider process.
 // A room turn is wider: it also includes async setup and every responder still
 // queued behind that speaker. Keep that operation visible for its whole
@@ -1750,6 +1751,7 @@ store.onChange((change) => {
             break;
         case "thread.deleted":
             routines?.forgetRoutineRequestReceiptsForThread(change.threadId);
+            broadcast({ kind: "bot.queued", queues: publicBotQueuedMessages() });
             break;
         case "bot": {
             const bot = store.bot(change.botId);
@@ -1893,6 +1895,7 @@ function broadcast(payload) {
         }
     }
 }
+onSteeredQueueChange(() => broadcast({ kind: "bot.queued", queues: publicBotQueuedMessages() }));
 // ── server-side event folding (upstream's ingestion worker, miniature) ──
 // The canonical stream is the source of truth; the persisted transcript
 // and every client view are projections of it.
@@ -4738,6 +4741,13 @@ const agentRoutine = (routine, latestRun) => {
                     type: "interval",
                     everyMinutes: routine.schedule.everyMinutes,
                     anchorAt: new Date(routine.schedule.anchorAt).toISOString(),
+                    ...(routine.schedule.weekdays === undefined
+                        ? {}
+                        : { weekdays: routine.schedule.weekdays.map((day) => ROUTINE_WEEKDAY_NAMES[day]) }),
+                    ...(routine.schedule.window === undefined ? {} : { window: { ...routine.schedule.window } }),
+                    ...(routine.schedule.endsAt === undefined
+                        ? {}
+                        : { endsAt: new Date(routine.schedule.endsAt).toISOString() }),
                 }
                 : {
                     type: "weekly",
@@ -6790,6 +6800,7 @@ function cliProbeEnvironment() {
         "OMB_COMPOSIO_BROKER_TOKEN",
         "OMB_TTS_KEY",
         "OMB_OPENAI_IMAGE_KEY",
+        "OMB_CUSTOM_IMAGE_KEY",
         "ANTHROPIC_API_KEY",
         "OPENAI_API_KEY",
     ]) {
@@ -6902,7 +6913,7 @@ function configStatus() {
         // the chosen voice is a setting, not a secret; the key is reported the
         // same configured-or-not way as every other credential
         tts: tts.describeVoice(cfg),
-        imageGen: { configured: Boolean(cfg.imageGen?.key) },
+        imageGen: avatarImageStatus(cfg),
         // not a secret — the sidebar shows it
         profile: { name: cfg.profile?.name ?? "", email: cfg.profile?.email ?? "" },
         // not a secret — the settings picker shows it; "" = follow the system
@@ -8732,6 +8743,7 @@ const handleRequest = async (req, res) => {
                 return json(res, 400, { error: "messages must be a non-negative whole number" });
             return json(res, 200, {
                 bots: store.bots.map((bot) => ({ ...publicBot(bot), ...messagePage(bot.threadId, limit) })),
+                botQueuedMessages: publicBotQueuedMessages(),
                 groups: store.groups.map((g) => ({ ...publicGroupState(g), ...messagePage(g.threadId, limit) })),
                 computerControl: Object.fromEntries(store.bots.map((bot) => {
                     const snapshot = computerControl.snapshot(bot.id);
@@ -10024,7 +10036,7 @@ const handleRequest = async (req, res) => {
             if (!parsed.success) {
                 return json(res, 400, { error: `prompt must be at most 400 characters` });
             }
-            const generated = await generateAvatarImage(cfg.imageGen?.key ?? "", existing, parsed.data.prompt);
+            const generated = await generateAvatarImage(cfg, existing, parsed.data.prompt);
             const current = store.bot(existing.id);
             if (!current)
                 return json(res, 404, { error: "no such bot" });
@@ -12005,7 +12017,7 @@ const handleRequest = async (req, res) => {
             const state = await providerAuthSessions.status(authStatus[1], auth.kind === "session" ? auth.session.id : "loopback", url.searchParams.get("flowId") ?? "");
             return json(res, 200, { auth: state });
         }
-        const instanceAction = /^\/api\/instances\/([\w.-]+)\/(refresh-models|install|auth\/start|auth\/complete|auth\/cancel)$/.exec(path);
+        const instanceAction = /^\/api\/instances\/([\w.-]+)\/(refresh-models|install|auth\/start|auth\/complete|auth\/cancel|auth\/sign-out)$/.exec(path);
         if (method === "POST" && instanceAction) {
             if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
                 return json(res, 415, { error: "content-type must be application/json" });
@@ -12038,6 +12050,13 @@ const handleRequest = async (req, res) => {
                     }
                     return json(res, 200, { auth: started });
                 }
+                if (action === "auth/sign-out") {
+                    const instance = registry.get(instanceId);
+                    if (!instance)
+                        return json(res, 404, { error: "unknown instance" });
+                    await providerAuthSessions.signOut(instance, owner);
+                    return json(res, 200, { instances: await describeInstances() });
+                }
                 if (action === "auth/complete") {
                     const body = await readBody(req);
                     const flowId = typeof body?.flowId === "string" ? body.flowId : "";
@@ -12613,6 +12632,8 @@ const handleRequest = async (req, res) => {
                             persisted.tts.key = "";
                         if (persisted.imageGen?.key !== undefined)
                             persisted.imageGen.key = "";
+                        if (persisted.imageGen?.customApiKey !== undefined)
+                            persisted.imageGen.customApiKey = "";
                         saveConfig(persisted);
                         configWriteCommitted = true;
                         syncCredentialEnv(patch);

package/dist-server/server/package-export.js

@@ -100,6 +100,13 @@ export function createBotPackageExport(input) {
                             type: "interval",
                             everyMinutes: routine.schedule.everyMinutes,
                             anchorAt: routine.schedule.anchorAt,
+                            ...(routine.schedule.weekdays === undefined
+                                ? {}
+                                : { weekdays: [...routine.schedule.weekdays] }),
+                            ...(routine.schedule.window === undefined
+                                ? {}
+                                : { window: { ...routine.schedule.window } }),
+                            ...(routine.schedule.endsAt === undefined ? {} : { endsAt: routine.schedule.endsAt }),
                         }
                         : { type: "daily", time: routine.schedule.time, weekdays: [...routine.schedule.weekdays] },
                 durationMinutes: routine.durationMinutes,

package/dist-server/server/provider-auth-sessions.js

@@ -86,6 +86,30 @@ export class ProviderAuthSessions {
             flow.expiresAt = 0;
         }
     }
+    /** Remove the server's stored sign-in for this provider. A login another
+     * admin is still completing must not be pulled away underneath them, and
+     * nobody may start one while the credential is being removed. */
+    async signOut(instance, owner) {
+        if (!instance.signOut)
+            throw failure("Sign-out is unavailable for this provider.", 404);
+        const existing = this.flows.get(instance.instanceId);
+        if (existing && (existing.busy || (existing.owner !== owner && existing.expiresAt > Date.now() && !existing.revoked))) {
+            throw failure("A sign-in is in progress. Finish or cancel it in the browser that started it, or wait for it to expire.", 409);
+        }
+        // Reserve the slot like a starting flow: start() answers 409 until we finish.
+        const flow = { instance, owner, flowId: null, expiresAt: Date.now() + 60_000, busy: true, starting: false, revoked: false };
+        this.flows.set(instance.instanceId, flow);
+        try {
+            // This owner's own leftover flow is theirs to abandon.
+            if (existing)
+                await existing.instance.cancelAuthentication?.();
+            await instance.signOut();
+        }
+        finally {
+            if (this.flows.get(instance.instanceId) === flow)
+                this.flows.delete(instance.instanceId);
+        }
+    }
     revokeOwner(owner) {
         for (const [id, flow] of this.flows) {
             if (flow.owner !== owner)