openmausbot 0.1.63 → 0.1.65

package/dist-server/server/index.js

@@ -117,9 +117,12 @@ import { createGracefulShutdown } from "./graceful-shutdown.js";
 import { acquireDataDirLeaseForProcess } from "./data-dir-lease.js";
 import { describeEdition, editionStatus, loadEnterpriseLayer } from "./enterprise.js";
 import { environmentDescriptor, loadEnvironmentId } from "./environment.js";
+import { createCustomDomainVerifier, normalizeCustomDomain } from "./custom-domain.js";
+import { ProviderAuthSessions } from "./provider-auth-sessions.js";
 import { clearSessionCookie, clientBotPatchViolation, clientGroupPatchViolation, labelFromUserAgent, requestOrigin, requestSource, resolveRequestAuth, parseCookies, serializeSessionCookie, sessionCookieName, } from "./request-auth.js";
 import { cookieMaxAgeSeconds, formatPairingCode, SessionRegistry } from "./sessions.js";
 import { describeBrand, loadBrand } from "./brand.js";
+import { deliverSseFrame } from "./sse-fanout.js";
 import { PHONE_SECRET_PROTOCOL_VERSION, PhoneSecretBridge, PhoneSecretError, PhoneSecretSubmissionRegistry, assertPhoneSecretRequestMatches, phoneSecretOperationId, } from "./phone-secret.js";
 const PORT = Number(process.env.OMB_PORT || process.env.OGB_PORT || 8799);
 const WEBHOOK_PORT = Number(process.env.OMB_WEBHOOK_PORT || PORT + 1);
@@ -169,9 +172,29 @@ const DESKTOP_MANAGED = process.env.OMB_DESKTOP_PARENT === "1";
 let desktopMutationToken = DESKTOP_MANAGED ? "" : undefined;
 let companionMutationToken = DESKTOP_MANAGED ? "" : undefined;
 // Where remote clients reach this server (a proxy's public address); pairing URLs use it.
-const PUBLIC_URL = process.env.OMB_PUBLIC_URL?.trim().replace(/\/+$/, "") || null;
+const FALLBACK_PUBLIC_URL = process.env.OMB_PUBLIC_URL?.trim().replace(/\/+$/, "") || null;
 const cfg = loadConfig();
+const customDomainVerifier = createCustomDomainVerifier({ environmentId: ENVIRONMENT_ID });
+let customDomainRevision = 0;
+function savedCustomDomain() {
+    if (DESKTOP_MANAGED || !cfg.customDomain)
+        return null;
+    try {
+        return normalizeCustomDomain(cfg.customDomain);
+    }
+    catch {
+        return null;
+    }
+}
+function publicUrl() { return savedCustomDomain() ?? FALLBACK_PUBLIC_URL; }
+function customDomainStatus() {
+    return {
+        customDomain: savedCustomDomain(), publicUrl: publicUrl(), fallbackUrl: FALLBACK_PUBLIC_URL,
+        supported: !DESKTOP_MANAGED, appPort: PORT, webhookPort: WEBHOOK_PORT,
+    };
+}
 const registry = new ProviderRegistry(BUILT_IN_DRIVERS);
+const providerAuthSessions = new ProviderAuthSessions();
 await registry.load(instanceConfigs(cfg));
 const bundledSkills = loadBundledSkills();
 const availableSkills = () => mergeSkills(bundledSkills, loadUserSkills(join(DATA_DIR, "skills")));
@@ -521,6 +544,7 @@ function browserIntegration(botId, profile) {
             session,
             encryptionKey: browserEngineEncryptionKey(),
             persistent: profile !== "guest",
+            env: { ...process.env, PATH: augmentedPath() },
         }),
     };
 }
@@ -1658,6 +1682,7 @@ function messageWindow(threadId, messageId, limit) {
 }
 const sseClients = new Set();
 sessions.onSessionRevoked((sessionId) => {
+    providerAuthSessions.revokeOwner(sessionId);
     for (const client of sseClients) {
         if (client.sessionId !== sessionId)
             continue;
@@ -1720,10 +1745,9 @@ function broadcast(payload) {
     for (const client of [...sseClients]) {
         if (!wants(client, kind))
             continue;
-        try {
-            client.res.write(client.admin ? frame : clientFrame);
-        }
-        catch {
+        // Screen frames are replaceable and durable events are not: see
+        // ./sse-fanout.ts for the backpressure/bound decision this makes.
+        if (deliverSseFrame(client, kind, client.admin ? frame : clientFrame) === "disconnected") {
             sseClients.delete(client);
         }
     }
@@ -6573,6 +6597,7 @@ function persistMcpServers(next) {
 /** Rebuild the provider fleet after a config change so new keys take
  * effect without a server restart (kills any in-flight turns). */
 async function reloadProviders() {
+    providerAuthSessions.clear();
     // Every provider process is about to die. Revoke all turn capabilities in
     // one synchronous step before the first teardown await, including room/task
     // threads that are not a bot's default DM.
@@ -6716,6 +6741,12 @@ const handleRequest = async (req, res) => {
         if (method === "GET" && path === "/.well-known/openmausbot/environment") {
             return json(res, 200, environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED }));
         }
+        const domainCheck = /^\/\.well-known\/openmausbot\/domain-check\/([a-f0-9]{64})$/.exec(path);
+        if (method === "GET" && domainCheck) {
+            res.setHeader("cache-control", "no-store");
+            const challenge = customDomainVerifier.challenge(domainCheck[1]);
+            return json(res, challenge ? 200 : 404, challenge ?? { error: "No active domain check." });
+        }
         if (method === "POST" && path === "/api/auth/pair") {
             // JSON only: a cross-site HTML form cannot send this content type
             // without a preflight, so a stray unused code cannot be planted as a
@@ -6803,7 +6834,7 @@ const handleRequest = async (req, res) => {
             const scopes = Array.isArray(requested) ? requested.filter((v) => v === "admin" || v === "client") : undefined;
             const opened = sessions.openPairing({ label: typeof body?.label === "string" ? body.label : undefined, scopes });
             const origin = requestOrigin(req);
-            const base = PUBLIC_URL ?? (auth.kind === "session" && origin ? origin : null);
+            const base = publicUrl() ?? (auth.kind === "session" && origin ? origin : null);
             const code = formatPairingCode(opened.code);
             return json(res, 200, {
                 id: opened.id,
@@ -6816,7 +6847,42 @@ const handleRequest = async (req, res) => {
             });
         }
         if (method === "GET" && path === "/api/auth/pairing")
-            return json(res, 200, { pairings: sessions.openPairings(), publicUrl: PUBLIC_URL });
+            return json(res, 200, { pairings: sessions.openPairings(), publicUrl: publicUrl() });
+        // Admin-only via request-auth's default deny. Connecting a domain only
+        // changes future pairing links; DNS, proxy setup, webhooks and all existing
+        // sessions remain untouched. The tunnel/deployment URL is kept as fallback.
+        if (path === "/api/settings/custom-domain") {
+            res.setHeader("cache-control", "no-store");
+            if (method === "GET")
+                return json(res, 200, customDomainStatus());
+            if (method === "POST" || method === "DELETE") {
+                if (DESKTOP_MANAGED)
+                    return json(res, 409, { error: "Custom domains are configured on a self-hosted OpenMausBot server, not the desktop companion." });
+                if (!/^application\/json\b/i.test(String(req.headers["content-type"] ?? ""))) {
+                    return json(res, 415, { error: "content-type must be application/json" });
+                }
+                if (method === "DELETE") {
+                    saveConfig({ customDomain: "" });
+                    cfg.customDomain = "";
+                    customDomainRevision++;
+                    return json(res, 200, customDomainStatus());
+                }
+                const body = await readBody(req, 4096);
+                if (typeof body?.domain !== "string")
+                    return json(res, 400, { error: "Enter your domain name." });
+                const revision = customDomainRevision;
+                const verified = await customDomainVerifier.verify(body.domain);
+                if (auth.kind === "session" && !sessions.isLive(auth.session.id)) {
+                    return json(res, 401, { error: "Your session ended. Sign in again before connecting a domain." });
+                }
+                if (revision !== customDomainRevision)
+                    return json(res, 409, { error: "Domain settings changed during verification. Try again." });
+                saveConfig({ customDomain: verified.origin });
+                cfg.customDomain = verified.origin;
+                customDomainRevision++;
+                return json(res, 200, customDomainStatus());
+            }
+        }
         m = path.match(/^\/api\/auth\/pairing\/([\w-]+)$/);
         if (m && method === "DELETE") {
             const cancelled = sessions.cancelPairing(m[1]);
@@ -8019,7 +8085,12 @@ const handleRequest = async (req, res) => {
         }
         // ── events stream ──
         if (method === "GET" && path === "/api/events") {
-            const client = { res, admin: auth.scopes.includes("admin"), screens: url.searchParams.get("screens") !== "off" };
+            const client = {
+                res,
+                admin: auth.scopes.includes("admin"),
+                screens: url.searchParams.get("screens") !== "off",
+                backpressured: false,
+            };
             if (auth.kind === "session")
                 client.sessionId = auth.session.id;
             res.writeHead(200, {
@@ -11170,6 +11241,12 @@ const handleRequest = async (req, res) => {
             resetPathCache();
             return json(res, 200, { instances: await registry.describe() });
         }
+        const authStatus = /^\/api\/instances\/([\w.-]+)\/auth\/status$/.exec(path);
+        if (method === "GET" && authStatus) {
+            res.setHeader("cache-control", "no-store");
+            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);
         if (method === "POST" && instanceAction) {
             if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
@@ -11177,6 +11254,9 @@ const handleRequest = async (req, res) => {
             }
             const instanceId = instanceAction[1];
             const action = instanceAction[2];
+            const owner = auth.kind === "session" ? auth.session.id : "loopback";
+            if (action.startsWith("auth/"))
+                res.setHeader("cache-control", "no-store");
             try {
                 if (action === "refresh-models") {
                     if (!(await registry.refreshModels(instanceId)))
@@ -11189,10 +11269,16 @@ const handleRequest = async (req, res) => {
                     return json(res, 200, { instances: await registry.describe() });
                 }
                 if (action === "auth/start") {
-                    const auth = await registry.startAuthentication(instanceId);
-                    if (!auth)
-                        return json(res, 404, { error: "account setup is unavailable" });
-                    return json(res, 200, { auth });
+                    const instance = registry.get(instanceId);
+                    if (!instance)
+                        return json(res, 404, { error: "unknown instance" });
+                    const started = await providerAuthSessions.start(instance, owner);
+                    // Revocation can arrive while the CLI is obtaining a device code.
+                    if (auth.kind === "session" && !sessions.isLive(auth.session.id)) {
+                        providerAuthSessions.revokeOwner(owner);
+                        return json(res, 401, { error: "Your session ended. Start a new sign-in." });
+                    }
+                    return json(res, 200, { auth: started });
                 }
                 if (action === "auth/complete") {
                     const body = await readBody(req);
@@ -11200,20 +11286,16 @@ const handleRequest = async (req, res) => {
                     const callbackUrl = typeof body?.callbackUrl === "string" ? body.callbackUrl : "";
                     if (!flowId || !callbackUrl)
                         return json(res, 400, { error: "flowId and callbackUrl are required" });
-                    if (!(await registry.completeAuthentication(instanceId, flowId, callbackUrl))) {
-                        return json(res, 404, { error: "account setup is unavailable" });
-                    }
+                    await providerAuthSessions.complete(instanceId, owner, flowId, callbackUrl);
                     return json(res, 200, { ok: true });
                 }
-                if (!(await registry.cancelAuthentication(instanceId))) {
-                    return json(res, 404, { error: "account setup is unavailable" });
-                }
+                const body = await readBody(req, 4096);
+                await providerAuthSessions.cancel(instanceId, owner, typeof body?.flowId === "string" ? body.flowId : "");
                 return json(res, 200, { ok: true });
             }
             catch (error) {
-                const status = error && typeof error === "object" && error.status === 409
-                    ? 409
-                    : 500;
+                const requestedStatus = error && typeof error === "object" ? error.status : undefined;
+                const status = typeof requestedStatus === "number" && [400, 401, 404, 409, 413, 415].includes(requestedStatus) ? requestedStatus : 500;
                 return json(res, status, { error: error instanceof Error ? error.message : String(error) });
             }
         }

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

@@ -0,0 +1,111 @@
+const failure = (message, status) => Object.assign(new Error(message), { status });
+export class ProviderAuthSessions {
+    flows = new Map();
+    async start(instance, owner) {
+        if (!instance.startAuthentication)
+            throw failure("Account setup is unavailable for this provider.", 404);
+        const existing = this.flows.get(instance.instanceId);
+        if (existing && (existing.busy || (existing.owner !== owner && existing.expiresAt > Date.now()))) {
+            throw failure("A sign-in is already in progress. Finish or cancel it in the browser that started it, or wait for it to expire.", 409);
+        }
+        // Reopening Settings may resume the same owner's flow. Keep its ownership
+        // if the driver's retry fails, rather than orphaning a still-running CLI.
+        const resuming = existing && existing.owner === owner && existing.expiresAt > Date.now() && !existing.revoked;
+        const flow = resuming ? existing : { instance, owner, flowId: null, expiresAt: Date.now() + 15 * 60_000, busy: false, starting: false, revoked: false };
+        flow.busy = true;
+        flow.starting = true;
+        this.flows.set(instance.instanceId, flow);
+        try {
+            const result = await instance.startAuthentication();
+            if (flow.revoked || this.flows.get(instance.instanceId) !== flow) {
+                await instance.cancelAuthentication?.();
+                throw failure("Sign-in cancelled because the session or provider changed.", 409);
+            }
+            flow.flowId = result.flowId;
+            const expiry = Date.parse(result.expiresAt ?? "");
+            if (Number.isFinite(expiry))
+                flow.expiresAt = expiry;
+            if (result.phase === "succeeded")
+                this.flows.delete(instance.instanceId);
+            return result;
+        }
+        catch (error) {
+            if ((!resuming || flow.revoked) && this.flows.get(instance.instanceId) === flow)
+                this.flows.delete(instance.instanceId);
+            throw error;
+        }
+        finally {
+            flow.busy = false;
+            flow.starting = false;
+        }
+    }
+    owned(instanceId, owner, flowId) {
+        const flow = this.flows.get(instanceId);
+        if (!flowId || !flow || flow.revoked || flow.owner !== owner || flow.flowId !== flowId) {
+            throw failure("This sign-in is no longer available in this browser. Start a new sign-in.", 404);
+        }
+        if (flow.busy)
+            throw failure("The sign-in is still being updated. Try again shortly.", 409);
+        return flow;
+    }
+    async status(instanceId, owner, flowId) {
+        const flow = this.owned(instanceId, owner, flowId);
+        if (!flow.instance.getAuthentication)
+            throw failure("Sign-in status is unavailable for this provider.", 404);
+        const status = await flow.instance.getAuthentication(flowId);
+        if (flow.revoked)
+            throw failure("This sign-in session ended.", 404);
+        // Keep the terminal result available to its owner, but release the slot so
+        // another admin need not wait fifteen minutes after success or cancellation.
+        if (status.phase !== "waiting")
+            flow.expiresAt = 0;
+        return status;
+    }
+    async complete(instanceId, owner, flowId, callbackUrl) {
+        const flow = this.owned(instanceId, owner, flowId);
+        if (!flow.instance.completeAuthentication)
+            throw failure("This provider does not use a callback URL.", 400);
+        flow.busy = true;
+        try {
+            await flow.instance.completeAuthentication(flowId, callbackUrl);
+            if (this.flows.get(instanceId) === flow)
+                this.flows.delete(instanceId);
+        }
+        finally {
+            flow.busy = false;
+        }
+    }
+    async cancel(instanceId, owner, flowId) {
+        const flow = this.owned(instanceId, owner, flowId);
+        flow.busy = true;
+        try {
+            await flow.instance.cancelAuthentication?.();
+        }
+        finally {
+            flow.busy = false;
+            flow.expiresAt = 0;
+        }
+    }
+    revokeOwner(owner) {
+        for (const [id, flow] of this.flows) {
+            if (flow.owner !== owner)
+                continue;
+            flow.revoked = true;
+            // A pending start owns its eventual cancellation. Keep the reservation
+            // until it finishes so another browser cannot race into this auth home.
+            if (flow.starting)
+                continue;
+            flow.busy = true;
+            void Promise.resolve().then(() => flow.instance.cancelAuthentication?.()).catch(() => { }).finally(() => {
+                if (this.flows.get(id) === flow)
+                    this.flows.delete(id);
+            });
+        }
+    }
+    clear() {
+        for (const flow of this.flows.values())
+            flow.revoked = true;
+        // Called when disposing the provider fleet, which owns child teardown.
+        this.flows.clear();
+    }
+}

package/dist-server/server/sse-fanout.js

@@ -0,0 +1,53 @@
+// Per-client delivery decision for the SSE broadcast fan-out in index.ts.
+// Pulled into its own file — not just its own function — because index.ts
+// starts the real HTTP server as an import-time side effect (see the bottom
+// of index.ts: `server.listen(...)` runs unconditionally on import), so it
+// can never be imported from a plain unit test. This one function has no
+// dependency on that module and can be driven directly with a fake response.
+/** Past this many buffered bytes, the client isn't draining on any useful
+ * timeframe: cut it loose rather than let Node's per-connection write buffer
+ * grow without bound. Its own EventSource reconnects and replays via
+ * Last-Event-ID (server/index.ts's existing replayBuffer/cursorSeq). */
+// ponytail: fixed byte bound, not adaptive. Retune from real writableLength
+// telemetry (see the audit's validation step) if it trips too eager or late.
+export const SSE_MAX_BUFFERED_BYTES = 4 * 1024 * 1024;
+/** One client's fate for one frame.
+ *
+ * Screen captures are replaceable: once a client is backpressured, skip them
+ * until it drains, since the next capture supersedes whatever was dropped.
+ * Durable events (messages, bot/group state, config, ...) are never
+ * silently dropped here — they're written regardless of the backpressure
+ * flag. The only way a durable event goes missing is the bound below, which
+ * disconnects the client outright so its next reconnect replays what it
+ * missed instead of silently losing it. */
+export function deliverSseFrame(client, kind, frame) {
+    if (client.res.writableLength > SSE_MAX_BUFFERED_BYTES) {
+        try {
+            client.res.end();
+        }
+        catch {
+            /* already gone */
+        }
+        return "disconnected";
+    }
+    if (client.backpressured && kind === "screen")
+        return "dropped";
+    try {
+        if (!client.res.write(frame) && !client.backpressured) {
+            // write() returns false as soon as buffered bytes pass the socket's
+            // 16 KB highWaterMark, which a single screen frame clears on its own —
+            // so this says "hasn't drained yet", not "is a slow client". Without
+            // the drain listener the flag latches on for the life of the
+            // connection and screen streaming never resumes. One listener per
+            // transition into backpressure, never one per frame.
+            client.backpressured = true;
+            client.res.once("drain", () => {
+                client.backpressured = false;
+            });
+        }
+        return "sent";
+    }
+    catch {
+        return "disconnected";
+    }
+}

package/dist-server/src/lib/composer-attachments.js

@@ -88,6 +88,20 @@ const DOCUMENT_MIMES = {
     odp: "application/vnd.oasis.opendocument.presentation",
 };
 const ACCEPTED_DOCUMENT_MIMES = new Set(Object.values(DOCUMENT_MIMES));
+const AUDIO_MIMES_BY_EXTENSION = {
+    opus: "audio/opus",
+    ogg: "audio/ogg",
+    mp3: "audio/mpeg",
+    m4a: "audio/mp4",
+    aac: "audio/aac",
+    wav: "audio/wav",
+    flac: "audio/flac",
+    webm: "audio/webm",
+};
+const ACCEPTED_AUDIO_MIMES = new Set([
+    ...Object.values(AUDIO_MIMES_BY_EXTENSION),
+    "audio/x-m4a", "audio/x-wav", "audio/wave", "audio/x-flac",
+]);
 export function documentMime(file) {
     const declared = file.type.split(";", 1)[0].trim().toLowerCase();
     if (ACCEPTED_DOCUMENT_MIMES.has(declared))
@@ -257,11 +271,14 @@ export async function imageAttachmentFromFile(file, optimistic) {
         ...(optimistic?.previewUrl ? { previewUrl: optimistic.previewUrl } : {}),
     };
 }
-/** Copy a supported document into the private attachment store. The prompt
+/** Copy a supported document or audio file into the private attachment store. The prompt
  * then carries the same durable path for the local agent and paired phones,
  * instead of exposing an arbitrary Finder path to the companion route. */
 export async function fileAttachmentFromFile(file) {
-    const mime = documentMime(file);
+    const declared = file.type.split(";", 1)[0].trim().toLowerCase();
+    const extension = file.name.split(".").at(-1)?.toLowerCase() ?? "";
+    const mime = documentMime(file) ??
+        (ACCEPTED_AUDIO_MIMES.has(declared) ? declared : AUDIO_MIMES_BY_EXTENSION[extension]);
     if (!mime)
         return null;
     if (file.size > FILE_MAX_BYTES) {
@@ -666,7 +683,7 @@ export async function intakeFiles(_files, _opts) {
     const rejectedNames = results.flatMap((result) => result.rejectedNames);
     const uploadErrors = results.flatMap((result) => result.uploadError ? [result.uploadError] : []);
     const pathless = rejectedNames.length
-        ? `${rejectedNames.join(", ")} — that file has no path on disk. Save it first, then attach it from Finder.`
+        ? `Unable to attach ${rejectedNames.join(", ")}. Choose a supported image, document, or audio file.`
         : null;
     const failed = uploadErrors.length ? uploadErrors.join("; ") : null;
     return {

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

@@ -15086,6 +15086,8 @@ var defaultModelSelectionSchema = external_exports.object({
   effort: external_exports.enum(EFFORT_LEVELS).optional()
 });
 var appConfigSchema = external_exports.object({
+  /** Verified by the dedicated domain endpoint, never a generic config patch. */
+  customDomain: external_exports.string().optional(),
   defaultModelSelection: defaultModelSelectionSchema.optional(),
   /** CLI-only launch preferences. Never enable remote access implicitly. */
   cliStartup: external_exports.object({
@@ -15129,7 +15131,7 @@ var appConfigSchema = external_exports.object({
 var storedAppConfigSchema = appConfigSchema.extend({
   browserProfiles: storedBrowserProfilesSchema.optional()
 });
-var appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true });
+var appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true });
 var jsonObjectSchema = external_exports.record(external_exports.string(), external_exports.json());
 var DATA_DIR = process.env.OMB_DATA_DIR ?? join2(homedir2(), ".openmausbot");
 var LEGACY_DATA_DIR = join2(homedir2(), ".opengrokbot");

package/package.json

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