openmausbot 0.1.63 → 0.1.66

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

@@ -0,0 +1,118 @@
+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();
+    }
+    clearInstance(instanceId) {
+        const flow = this.flows.get(instanceId);
+        if (flow)
+            flow.revoked = true;
+        this.flows.delete(instanceId);
+        // The registry's per-instance disposal owns child teardown.
+    }
+}

package/dist-server/server/proxy-paths.js

@@ -31,6 +31,7 @@ export function resolveProxy(relative) {
  * the smoke test can assert each one actually exists in a packaged layout —
  * the check that would have caught the 0.1.24 breakage. */
 export const SPAWNED_PROXIES = {
+    browser: resolveProxy("browser-proxy"),
     computer: resolveProxy("computer-proxy"),
     permission: resolveProxy("permission-proxy"),
     containerMcp: resolveProxy("container-mcp"),

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) {
@@ -494,8 +511,8 @@ function transcriptBlockStarting(line) {
 }
 const TRANSCRIPT_ATTACHMENT_TAG = /^<attached-(image|file)[\t ]+path="([^"\r\n]*)"(?:[\t ]+name="([^"\r\n]*)")?[\t ]*\/>[\t ]*$/;
 /** Split a stored user message into its display text and attachments for
- * transcript rendering. Prompt-only tags never show in the bubble. */
-export function splitTranscriptAttachments(text) {
+ * transcript rendering. Markdown exports preserve whitespace; bubbles trim it. */
+export function splitTranscriptAttachments(text, trimDisplay = true) {
     const images = [];
     const files = [];
     let display = "";
@@ -555,7 +572,7 @@ export function splitTranscriptAttachments(text) {
             display += text.slice(cursor, wholeLineEnd);
         cursor = wholeLineEnd;
     }
-    return { display: display.trim(), images, files };
+    return { display: trimDisplay ? display.trim() : display, images, files };
 }
 /** Kept for callers outside the desktop bundle that used the old helper. */
 export function splitAttachedImages(text) {
@@ -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");
@@ -15146,6 +15148,7 @@ function resolveProxy(relative) {
   return existsSync2(source) ? source : join3(SERVER_ROOT, `${relative}.js`);
 }
 var SPAWNED_PROXIES = {
+  browser: resolveProxy("browser-proxy"),
   computer: resolveProxy("computer-proxy"),
   permission: resolveProxy("permission-proxy"),
   containerMcp: resolveProxy("container-mcp"),

package/package.json

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