openmausbot 0.1.67 → 0.1.69

package/dist-server/server/drivers/acp/qwen.js

@@ -2,13 +2,109 @@
 // the official pane has no Qwen Cloud catalog; live local hosts land in
 // Custom and are written into ~/.qwen/settings.json modelProviders.
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 const EMPTY = { default: "", options: [] };
 function qwenHome(env) {
-    return join(env.HOME || env.USERPROFILE || homedir(), ".qwen");
+    const home = process.platform === "win32"
+        ? env.USERPROFILE || env.HOME || homedir()
+        : env.HOME || env.USERPROFILE || homedir();
+    return join(home, ".qwen");
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function qwenModelLabel(id, name) {
+    if (!name || name.toLocaleLowerCase().endsWith(id.toLocaleLowerCase()))
+        return id;
+    return `${id} — ${name}`;
+}
+const PROTOCOLS = new Set(["openai", "anthropic", "gemini", "vertex-ai"]);
+function readQwenRoutes(env) {
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(join(qwenHome(env), "settings.json"), "utf8"));
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(settings) || !isRecord(settings.modelProviders))
+        return [];
+    const routes = [];
+    const seen = new Set();
+    const mappings = isRecord(settings.providerProtocol) ? settings.providerProtocol : {};
+    for (const [provider, rows] of Object.entries(settings.modelProviders)) {
+        const protocol = Object.hasOwn(mappings, provider) ? mappings[provider] : provider;
+        if (typeof protocol !== "string" || !PROTOCOLS.has(protocol) || !Array.isArray(rows))
+            continue;
+        for (const row of rows) {
+            if (!isRecord(row) || typeof row.id !== "string")
+                continue;
+            const model = row.id;
+            if (!model.trim())
+                continue;
+            if (row.baseUrl !== undefined && typeof row.baseUrl !== "string")
+                continue;
+            const baseUrl = typeof row.baseUrl === "string" && row.baseUrl ? row.baseUrl : undefined;
+            if (baseUrl) {
+                try {
+                    new URL(baseUrl);
+                }
+                catch {
+                    throw new Error("A Qwen model has an invalid endpoint. Fix its baseUrl in Qwen settings and refresh models.");
+                }
+            }
+            const identity = JSON.stringify([protocol, model, baseUrl ?? null]);
+            if (seen.has(identity))
+                continue;
+            seen.add(identity);
+            if (row.imageOnly === true || row.voiceOnly === true || row.fastOnly === true)
+                continue;
+            routes.push({ id: `${model}(${protocol})`, model, provider, protocol, baseUrl,
+                label: typeof row.name === "string" && row.name ? row.name : model,
+                envKey: typeof row.envKey === "string" ? row.envKey : undefined });
+        }
+    }
+    // Qwen's ACP route identity, from QwenLM/qwen-code acpModelUtils.ts
+    // (Copyright 2025 Qwen Team, Apache-2.0). Never publish endpoints or env keys.
+    const counts = new Map();
+    for (const route of routes)
+        counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
+    for (const route of routes) {
+        if (counts.get(route.id) === 1)
+            continue;
+        const endpoint = route.baseUrl ?? (route.protocol === "openai" ? "https://api.openai.com/v1" : "");
+        let publicEndpoint = null;
+        if (endpoint) {
+            try {
+                const url = new URL(endpoint);
+                url.username = "";
+                url.password = "";
+                url.search = "";
+                url.hash = "";
+                publicEndpoint = url.href;
+            }
+            catch {
+                throw new Error("A Qwen model has an invalid endpoint. Fix its baseUrl in Qwen settings and refresh models.");
+            }
+        }
+        const identity = [route.id, route.label, route.envKey ?? null, route.baseUrl === undefined, publicEndpoint];
+        route.id = `qwen-route:v1:${createHash("sha256").update(JSON.stringify(identity)).digest("base64url").slice(0, 16)}`;
+    }
+    if (new Set(routes.map((route) => route.id)).size !== routes.length) {
+        throw new Error("Qwen has indistinguishable model routes. Give them distinct names, envKey values, or public endpoints in Qwen settings.");
+    }
+    return routes;
+}
+/** Public metadata only. Use Qwen's provider-qualified ACP selectors, not raw model IDs. */
+export function readQwenModelCatalog(env = process.env) {
+    const options = readQwenRoutes(env).map(({ id, model, label, provider }) => ({
+        id, label: qwenModelLabel(model, label), custom: true, provider,
+    }));
+    return { default: options[0]?.id ?? "", options };
 }
 function envKeyFor(hostId) {
     return `OPENMAUSBOT_QWEN_${hostId.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
@@ -68,8 +164,46 @@ export function ensureQwenInjectModel(modelId, env = process.env) {
     return inject.model;
 }
 async function resolveModels(env) {
-    const catalog = await mergeLocalInject(EMPTY, env);
-    return { default: catalog.options[0]?.id ?? "", options: catalog.options };
+    const catalog = await mergeLocalInject(readQwenModelCatalog(env), env);
+    const routes = readQwenRoutes(env);
+    const replacements = new Map();
+    for (const option of catalog.options) {
+        const injected = decodeInjectId(option.id);
+        if (!injected)
+            continue;
+        const endpoint = localHost(injected.host)?.baseUrl;
+        for (const route of routes) {
+            if (route.protocol === "openai" && route.model === injected.model && route.baseUrl === endpoint) {
+                replacements.set(route.id, option.id);
+            }
+        }
+    }
+    const options = catalog.options.filter((option) => !replacements.has(option.id));
+    const preferred = replacements.get(catalog.default) ?? catalog.default;
+    return { default: options.some((option) => option.id === preferred) ? preferred : options[0]?.id ?? "", options };
+}
+export function resolveQwenTurnModel(model, env) {
+    if (!model)
+        return model;
+    const injected = decodeInjectId(model);
+    if (injected)
+        ensureQwenInjectModel(model, env);
+    const routes = readQwenRoutes(env);
+    if (injected) {
+        const route = routes.find((row) => row.protocol === "openai" && row.model === injected.model
+            && row.baseUrl === localHost(injected.host)?.baseUrl);
+        if (!route)
+            throw new Error("Qwen could not configure this local model. Refresh models and select it again.");
+        return route.id;
+    }
+    if (routes.some((route) => route.id === model))
+        return model;
+    const matches = routes.filter((route) => route.model === model);
+    if (matches.length > 1)
+        throw new Error("This Qwen model has multiple providers. Refresh models and select the intended provider again.");
+    if (!matches.length)
+        throw new Error("This Qwen model is no longer configured. Refresh models and select it again.");
+    return matches[0].id;
 }
 const support = {
     driverKind: "qwenAgent",
@@ -77,7 +211,7 @@ const support = {
     access: "custom",
     models: EMPTY,
     resolveModels,
-    resolveTurnModel: (model, env) => (model ? ensureQwenInjectModel(model, env) : model),
+    resolveTurnModel: resolveQwenTurnModel,
     defaultCli: "qwen",
     nativeSource: "qwen.acp",
     loginNote: "Qwen Code CLI is not installed",
@@ -89,7 +223,10 @@ const support = {
         },
         docsUrl: "https://qwenlm.github.io/qwen-code-docs/en/users/overview/",
     },
-    spawnArgs: (_config, turn) => ["--acp", ...(turn.model ? ["-m", turn.model] : [])],
+    // A raw -m only changes the model within the saved provider. ACP switches
+    // the complete route and confirms it before any prompt leaves OMB.
+    spawnArgs: () => ["--acp"],
+    selectModel: { configId: "model" },
     pickAuthMethod: () => null,
     authFailure: "continue",
     isAuthenticated: () => true,

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
@@ -130,6 +154,20 @@ function normalizeScheduleInput(args) {
     if (!jsonRecord(raw))
         return { error: `The schedule must be a JSON object. ${SUPPORTED_SCHEDULES}` };
     const type = typeof raw.type === "string" ? raw.type.trim().toLowerCase() : "";
+    const fields = type === "once"
+        ? ["type", "at"]
+        : type === "weekly" || type === "daily"
+            ? ["type", "time", "weekdays"]
+            : type === "interval"
+                ? ["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
+    // example timezone or a misspelled starts_at) and approve different work.
+    const unsupported = fields && Object.keys(raw).find((key) => raw[key] != null && !fields.includes(key));
+    if (unsupported) {
+        return { error: `Unsupported ${type} schedule field "${unsupported}". Weekly and daily times use the computer's timezone from list_routines. ${SUPPORTED_SCHEDULES}` };
+    }
     if (type === "once") {
         if (typeof raw.at !== "string" || !raw.at.trim()) {
             return { error: `A once schedule needs "at": a future RFC3339 date-time with an explicit offset, for example 2026-09-01T09:00:00+05:30.` };
@@ -167,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) {
@@ -176,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 } : {}),
             },
         };
     }
@@ -500,7 +605,29 @@ function routineAction(value) {
 }
 function routineFields(args) {
     const fields = {};
-    if (args.clear_timeout === true && typeof args.timeout_minutes === "number") {
+    // list_routines returns the harness names. Accept those when a model
+    // copies back a definition, as we already do for interval fields.
+    if (args.run_on != null && args.runOn != null && args.run_on !== args.runOn) {
+        return { fields, error: "Choose one run_on destination; run_on and runOn disagree." };
+    }
+    if (args.timeout_minutes != null && args.timeoutMinutes != null && args.timeout_minutes !== args.timeoutMinutes) {
+        return { fields, error: "Choose one timeout_minutes limit; timeout_minutes and timeoutMinutes disagree." };
+    }
+    const runOn = args.run_on ?? args.runOn;
+    const timeoutMinutes = args.timeout_minutes ?? args.timeoutMinutes;
+    if (runOn != null && runOn !== "maus" && runOn !== "cloud") {
+        return { fields, error: 'run_on must be "maus" or "cloud".' };
+    }
+    if (timeoutMinutes != null && (typeof timeoutMinutes !== "number" || !Number.isInteger(timeoutMinutes) || timeoutMinutes < 5 || timeoutMinutes > 240)) {
+        return { fields, error: "timeout_minutes must be a whole number from 5 to 240. Use clear_timeout to remove a limit." };
+    }
+    if (args.continuity != null && typeof args.continuity !== "boolean") {
+        return { fields, error: "continuity must be true or false." };
+    }
+    if (args.clear_timeout != null && typeof args.clear_timeout !== "boolean") {
+        return { fields, error: "clear_timeout must be true or false." };
+    }
+    if (args.clear_timeout === true && timeoutMinutes != null) {
         return { fields, error: "Choose timeout_minutes or clear_timeout, not both." };
     }
     if (typeof args.name === "string")
@@ -513,12 +640,12 @@ function routineFields(args) {
             return { fields, error: normalized.error };
         fields.schedule = normalized.schedule;
     }
-    if (typeof args.run_on === "string")
-        fields.runOn = args.run_on;
+    if (runOn != null)
+        fields.runOn = runOn;
     if (args.clear_timeout === true)
         fields.timeoutMinutes = null;
-    else if (typeof args.timeout_minutes === "number")
-        fields.timeoutMinutes = args.timeout_minutes;
+    else if (timeoutMinutes != null)
+        fields.timeoutMinutes = timeoutMinutes;
     if (typeof args.continuity === "boolean")
         fields.continuity = args.continuity;
     return { fields };

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" } } });
+    });
+}