openmausbot 0.1.65 → 0.1.67

package/dist-server/proxy-paths.js

@@ -8,7 +8,9 @@ function resolveProxy(relative) {
   return existsSync(source) ? source : join(SERVER_ROOT, `${relative}.js`);
 }
 var SPAWNED_PROXIES = {
+  browser: resolveProxy("browser-proxy"),
   computer: resolveProxy("computer-proxy"),
+  localComputer: resolveProxy("local-computer-proxy"),
   permission: resolveProxy("permission-proxy"),
   containerMcp: resolveProxy("container-mcp"),
   vpsContainerMcp: resolveProxy("vps-container-mcp"),

package/dist-server/server/account-signin.js

@@ -0,0 +1,103 @@
+// Sign in with your email on a hosted server. The emailed code comes from the
+// OpenMausBot control plane (the account service the desktop companion and
+// `openmausbot login` already use), and this server decides who is welcome
+// with an allow-list its owner controls. The result is an ordinary local
+// session, the same thing a pairing code produces, so every gate applies.
+//
+// Why through the control plane rather than a mail provider per server: a
+// self-hoster then needs no email credentials at all; the code arrives from
+// accounts.openmausbot.com. The exchange happens server-side, so a browser
+// only ever talks to this server, and a server with an empty allow-list does
+// not expose the routes.
+import { resolveCompanionControlPlaneURL } from "../electron/companion-account-service.mjs";
+import { ControlPlaneError, createControlPlaneClient, normalizeAccountEmail } from "../electron/control-plane-client.mjs";
+export const ADMIN_EMAILS_ENV = "OMB_SIGNIN_EMAILS";
+export const MEMBER_EMAILS_ENV = "OMB_SIGNIN_MEMBER_EMAILS";
+/** Commas, spaces or newlines between entries; case does not matter. */
+export function parseAllowList(value) {
+    return (value ?? "")
+        .split(/[,\s]+/)
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+}
+export function allowedScopes(rawEmail, list) {
+    const email = rawEmail.trim().toLowerCase();
+    if (!email.includes("@"))
+        return null;
+    const matches = (entry) => (entry.startsWith("@") ? email.endsWith(entry) && email.length > entry.length : entry === email);
+    if (list.admins.some(matches))
+        return ["admin", "client"];
+    if (list.members.some(matches))
+        return ["client"];
+    return null;
+}
+export function signInEnabled(list) {
+    return list.admins.length + list.members.length > 0;
+}
+const NOT_WELCOME = { ok: false, status: 403, error: "this email is not on this server's sign-in list; ask the server's owner to add it" };
+export function createEmailSignIn(options) {
+    const env = options.env ?? process.env;
+    const allow = () => (typeof options.allow === "function" ? options.allow() : options.allow);
+    let client = options.client ?? null;
+    const controlPlane = () => {
+        if (client)
+            return client;
+        const url = resolveCompanionControlPlaneURL({ isPackaged: true, environment: env });
+        if (!url)
+            throw new Error("OMB_CONTROL_PLANE_URL is set but is not an https address");
+        client = createControlPlaneClient({ baseURL: url, fetchImpl: options.fetchImpl });
+        return client;
+    };
+    return {
+        enabled: () => signInEnabled(allow()),
+        async start(rawEmail) {
+            const email = normalizeAccountEmail(rawEmail);
+            if (!email)
+                return { ok: false, status: 400, error: "enter a valid email address" };
+            if (!allowedScopes(email, allow()))
+                return NOT_WELCOME;
+            try {
+                await controlPlane().requestOTP(email);
+            }
+            catch (error) {
+                return unavailable(error);
+            }
+            return { ok: true };
+        },
+        async verify(rawEmail, code) {
+            const email = normalizeAccountEmail(rawEmail);
+            if (!email || !allowedScopes(email, allow()))
+                return NOT_WELCOME;
+            let verified;
+            try {
+                verified = await controlPlane().verifyOTP(email, code);
+            }
+            catch (error) {
+                // The client refuses a malformed code before any request (status 0);
+                // the control plane's own "invalid_otp" is a wrong or expired code.
+                if (error instanceof ControlPlaneError && error.code === "invalid_otp" && !error.status) {
+                    return { ok: false, status: 400, error: "enter the 8-digit code from the email" };
+                }
+                if (error instanceof ControlPlaneError && error.status === 429) {
+                    return { ok: false, status: 429, error: "too many attempts; wait a minute and request a new code" };
+                }
+                if (error instanceof ControlPlaneError && (error.status === 400 || error.status === 401 || error.status === 403)) {
+                    return { ok: false, status: 401, error: "that code is wrong or has expired; request a new one" };
+                }
+                return unavailable(error);
+            }
+            // The account session on the control plane has done its job.
+            void controlPlane()
+                .signOut(verified.accountToken)
+                .catch(() => undefined);
+            const scopes = allowedScopes(verified.user.email, allow());
+            if (!scopes)
+                return NOT_WELCOME;
+            return { ok: true, email: verified.user.email, userId: verified.user.id, scopes };
+        },
+    };
+}
+function unavailable(error) {
+    const detail = error instanceof ControlPlaneError ? `${error.code}${error.status ? ` (${error.status})` : ""}` : error instanceof Error ? error.message : String(error);
+    return { ok: false, status: 502, error: `the sign-in service could not be reached (${detail}); try again in a moment` };
+}

package/dist-server/server/attachments.js

@@ -27,6 +27,26 @@ const activePartials = new Set();
 const uploadLocks = new Map();
 let reservedAttachmentBytes = 0;
 const STREAM_RESERVATION_INCREMENT_BYTES = 1024 * 1024;
+/** Cached total of on-disk bytes that count against the quota: committed
+ * attachments plus any partial file this process did not itself write (a
+ * crash leftover, until it is cleaned up). `null` means a fresh scan is needed
+ * after cold start or a cleanup failure. Every normal commit
+ * and delete after that updates it in place instead of rescanning, which is
+ * what makes reservation growth O(1) rather than O(directory size).
+ *
+ * This is single-process, in-memory state: it does not see files another
+ * process adds or removes in ATTACHMENTS_DIR. That is an accepted limit
+ * (the app runs one server per data dir; uploadLocks already assumes the
+ * same), not a design gap this fix covers. */
+let committedAttachmentBytes = null;
+// An async link can finish while another upload invalidates or refreshes the
+// cache. Its bytes must not be added again if a scan may already include it.
+let attachmentAccountingVersion = 0;
+/** Force a fresh disk total and invalidate any in-flight commit's snapshot. */
+function invalidateAttachmentAccounting() {
+    committedAttachmentBytes = null;
+    attachmentAccountingVersion += 1;
+}
 /** Mimes the endpoint accepts, mapped to the extension stored on disk.
  * Sniffing is not attempted — a lie here only changes the filename. */
 const IMAGE_MIMES = {
@@ -88,7 +108,10 @@ export function validateAttachmentUploadId(value) {
     }
     return normalized;
 }
-function attachmentUsageAndCleanup(now = Date.now()) {
+/** The one full directory walk. Run from cold or invalidated accounting,
+ * or from an explicit cleanup sweep — never
+ * from the per-reservation hot path, which is what made PERF-03 quadratic. */
+function scanAttachmentUsageAndCleanup(now = Date.now()) {
     ensureAttachmentsDir();
     let bytes = 0;
     let removed = 0;
@@ -117,10 +140,62 @@ function attachmentUsageAndCleanup(now = Date.now()) {
     }
     return { bytes, removed };
 }
-/** Remove only abandoned temporary uploads. Active partials are protected
- * even if a very slow request crosses the age threshold. */
+/** Return cached usage, initializing it from disk after cold start or
+ * invalidation. Reservations must use this rather than trusting a cold cache. */
+function committedBytes() {
+    if (committedAttachmentBytes === null) {
+        committedAttachmentBytes = scanAttachmentUsageAndCleanup().bytes;
+        attachmentAccountingVersion += 1;
+    }
+    return committedAttachmentBytes;
+}
+/** A newly committed file (saveFile/saveImage success path only — never the
+ * idempotent-retry branches, which reuse bytes already counted) adds to the
+ * cache. If accounting changed during an async link, a scan may already have
+ * counted that file. Let the next reservation rescan instead of adding twice. */
+function addCommittedBytes(delta, version = attachmentAccountingVersion) {
+    if (version !== attachmentAccountingVersion || committedAttachmentBytes === null) {
+        invalidateAttachmentAccounting();
+        return;
+    }
+    committedAttachmentBytes += delta;
+}
+/** Remove only abandoned temporary uploads, and refresh the cached usage
+ * total from the same fresh scan. Outside accounting recovery, this is the
+ * only full directory walk after start-up; nothing on the upload path calls it
+ * per byte or per chunk anymore, so callers that want stale partials
+ * reclaimed promptly should invoke it on their own schedule. */
 export function cleanupStaleAttachmentPartials(now = Date.now()) {
-    return attachmentUsageAndCleanup(now).removed;
+    const { bytes, removed } = scanAttachmentUsageAndCleanup(now);
+    committedAttachmentBytes = bytes;
+    attachmentAccountingVersion += 1;
+    return removed;
+}
+/** Delete a committed attachment (e.g. a generated image whose owning
+ * message/turn was retired) and keep the quota cache in sync. Every caller
+ * outside this module that removes a file saveImage/saveFile created must
+ * route through here instead of a raw unlink, or the cache will overcount
+ * forever and eventually reject uploads that should fit. */
+export function deleteAttachment(path) {
+    try {
+        // Only bother sizing it if the cache is already warm — if it isn't, the
+        // eventual first scan just won't see this file, which is correct.
+        const size = committedAttachmentBytes !== null ? statSync(path).size : 0;
+        unlinkSync(path);
+        if (committedAttachmentBytes !== null) {
+            committedAttachmentBytes = Math.max(0, committedAttachmentBytes - size);
+        }
+    }
+    catch {
+        // Already gone, or never existed — nothing to reconcile.
+    }
+}
+/** Test-only: force the next quota check to rescan the directory instead of
+ * trusting the cache. Needed because tests mutate ATTACHMENTS_DIR directly
+ * (truncateSync, rmSync, writeFileSync) to simulate quota states, which the
+ * cache can't observe. */
+export function __resetAttachmentAccountingForTests() {
+    invalidateAttachmentAccounting();
 }
 /** A retry owns the same UUID namespace as the interrupted attempt. Once it
  * holds that UUID's in-process lock, any inactive partial with the prefix is
@@ -136,7 +211,14 @@ function cleanupAttachmentPartialsForUpload(uploadId) {
         if (activePartials.has(path))
             continue;
         try {
+            // Only bother sizing it if the cache is already warm — if it isn't,
+            // the eventual first scan runs after this unlink and simply never
+            // sees the file, so there is nothing to reconcile.
+            const size = committedAttachmentBytes !== null ? statSync(path).size : 0;
             unlinkSync(path);
+            if (committedAttachmentBytes !== null) {
+                committedAttachmentBytes = Math.max(0, committedAttachmentBytes - size);
+            }
         }
         catch {
             // A concurrent cleanup already removed the abandoned attempt.
@@ -152,7 +234,7 @@ class AttachmentReservation {
         this.reserveAtLeast(bytes, bytes);
     }
     reserveAtLeast(required, preferred) {
-        const used = attachmentUsageAndCleanup().bytes;
+        const used = committedBytes();
         const available = ATTACHMENTS_MAX_BYTES - used - reservedAttachmentBytes;
         if (available < required) {
             throw statusError(507, `attachments storage is full (limit ${ATTACHMENTS_MAX_BYTES} bytes)`);
@@ -199,15 +281,34 @@ async function withUploadLock(uploadId, operation) {
             uploadLocks.delete(uploadId);
     }
 }
+/** Every committed attachment name is `${uuid}${extension}` for one of these
+ * fixed extensions — saveFile/saveImage never write any other suffix — so
+ * whether a given upload ID is already committed, and under which content
+ * type, can be answered with a handful of direct stats instead of a scan
+ * over every file in the directory. */
+const KNOWN_ATTACHMENT_EXTENSIONS = Array.from(new Set([...Object.values(IMAGE_MIMES), ...Object.values(FILE_MIMES)]));
+/** Missing or unreadable candidates count as absent here; the atomic link
+ * still detects a collision if a file exists when an upload commits. */
+function statSizeIfFile(path) {
+    try {
+        const stat = statSync(path);
+        return stat.isFile() ? stat.size : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Find an idempotent retry without listing the directory, rejecting an ID
+ * already committed under a different accepted content type. */
 function committedPathForUpload(uploadId, extension) {
     ensureAttachmentsDir();
-    const exact = `${uploadId}${extension}`;
-    for (const entry of readdirSync(ATTACHMENTS_DIR, { withFileTypes: true })) {
-        if (!entry.isFile() || PARTIAL_NAME.test(entry.name))
+    const exactPath = join(ATTACHMENTS_DIR, `${uploadId}${extension}`);
+    if (statSizeIfFile(exactPath) !== null)
+        return exactPath;
+    for (const other of KNOWN_ATTACHMENT_EXTENSIONS) {
+        if (other === extension)
             continue;
-        if (entry.name === exact)
-            return join(ATTACHMENTS_DIR, entry.name);
-        if (entry.name.startsWith(`${uploadId}.`)) {
+        if (statSizeIfFile(join(ATTACHMENTS_DIR, `${uploadId}${other}`)) !== null) {
             throw statusError(409, "uploadId was already used for another content type");
         }
     }
@@ -317,6 +418,7 @@ export async function saveFile(chunks, originalName, mime, options = {}) {
         let file;
         let bytes = 0;
         let closed = false;
+        let partialCleanupFailed = false;
         try {
             file = await open(partialPath, "wx", 0o600);
             for await (const value of chunks) {
@@ -343,7 +445,9 @@ export async function saveFile(chunks, originalName, mime, options = {}) {
             await file.close();
             closed = true;
             try {
+                const accountingVersion = attachmentAccountingVersion;
                 await link(partialPath, path);
+                addCommittedBytes(bytes, accountingVersion);
                 await unlink(partialPath);
             }
             catch (error) {
@@ -359,11 +463,15 @@ export async function saveFile(chunks, originalName, mime, options = {}) {
         catch (error) {
             if (file && !closed)
                 await file.close().catch(() => undefined);
-            await unlink(partialPath).catch(() => undefined);
+            await unlink(partialPath).catch(() => { partialCleanupFailed = true; });
             throw error;
         }
         finally {
             activePartials.delete(partialPath);
+            // A leftover partial was excluded from the cache while active. Rescan
+            // after releasing it so a retry cannot subtract bytes never counted.
+            if (partialCleanupFailed)
+                invalidateAttachmentAccounting();
             reservation.release();
         }
     });
@@ -397,10 +505,12 @@ export function saveImage(bytes, mime, requestedUploadId) {
     const path = join(ATTACHMENTS_DIR, name);
     const partialPath = join(ATTACHMENTS_DIR, `.openmaus-upload-${id}-${randomUUID()}.partial`);
     activePartials.add(partialPath);
+    let partialCleanupFailed = false;
     try {
         writeFileSync(partialPath, bytes, { mode: 0o600, flag: "wx" });
         try {
             linkSync(partialPath, path);
+            addCommittedBytes(bytes.byteLength);
         }
         catch (error) {
             if (error.code !== "EEXIST")
@@ -418,12 +528,14 @@ export function saveImage(bytes, mime, requestedUploadId) {
             unlinkSync(partialPath);
         }
         catch {
-            // The successful path already removed it, or the write never created it.
+            partialCleanupFailed = true;
         }
         throw error;
     }
     finally {
         activePartials.delete(partialPath);
+        if (partialCleanupFailed)
+            invalidateAttachmentAccounting();
         reservation.release();
     }
 }

package/dist-server/server/browser-engine-release.js

@@ -1,37 +1,39 @@
 // The pinned agent-browser release the harness downloads for the bots'
 // browser (docs/plans/browser-engine.md). Digests were computed from the
-// official GitHub assets on 2026-09-06, except the explicitly versioned Windows
+// official GitHub assets on 2026-09-08, except the explicitly versioned Windows
 // vendor build below. Update pins through a reviewed native end-to-end run.
 // The Dockerfile retains the official Linux version.
-export const AGENT_BROWSER_VERSION = "0.36.0";
+export const AGENT_BROWSER_VERSION = "0.37.0";
 const RELEASES = new Map([
     [
         "darwin-arm64",
-        { target: "darwin-arm64", asset: "agent-browser-darwin-arm64", sha256: "b2106ab39db0838e7b1772f7f26f760518de56d09053150c56f9dddf15af997d", bytes: 12363200 },
+        { target: "darwin-arm64", asset: "agent-browser-darwin-arm64", sha256: "da5a2b4ef7be8ba279b1258c542c33877f480b1951d0d94de607fc1528edd380", bytes: 12429360 },
     ],
     [
         "darwin-x64",
-        { target: "darwin-x64", asset: "agent-browser-darwin-x64", sha256: "45d9ac061a7d72e61eaff905326e2e19365f4dadb12142ea2f2d76d84689c708", bytes: 13510280 },
+        { target: "darwin-x64", asset: "agent-browser-darwin-x64", sha256: "f402c96350ffd2adc68d0e5e4d83aa49cf7735fef29882a8866be36cc2fc67e9", bytes: 13588296 },
     ],
     [
         "linux-arm64",
-        { target: "linux-arm64", asset: "agent-browser-linux-arm64", sha256: "aeb556addca3903601a433de1acad3ace1c9c61d170084bf58d875884599a990", bytes: 12442720 },
+        { target: "linux-arm64", asset: "agent-browser-linux-arm64", sha256: "0315a8c4f7bf167cc5fd5eeaea79009b0e6b5d2ae8b3057bf6f96be978483426", bytes: 12507840 },
     ],
     [
         "linux-musl-arm64",
-        { target: "linux-musl-arm64", asset: "agent-browser-linux-musl-arm64", sha256: "1ca7e003c9cb185f174fc81e51a609db27c77e3bfe00a0edff60688f8cd14f88", bytes: 12297000 },
+        { target: "linux-musl-arm64", asset: "agent-browser-linux-musl-arm64", sha256: "db67c0e84e0668c052c2cbdca325c57f896e309c3723755dcdd65b700f8a2b52", bytes: 12369352 },
     ],
     [
         "linux-musl-x64",
-        { target: "linux-musl-x64", asset: "agent-browser-linux-musl-x64", sha256: "a20cc2a5202a48f5820372803dedbcd5f556dff7a89421f1b0f2612962b10718", bytes: 13995728 },
+        { target: "linux-musl-x64", asset: "agent-browser-linux-musl-x64", sha256: "5cff3bc7b2486867aba2901f92c9ce6029bd2a37951630d9feec1c5b3fee402e", bytes: 14092888 },
     ],
     [
         "linux-x64",
-        { target: "linux-x64", asset: "agent-browser-linux-x64", sha256: "56d15181e51e00213f907fcf39707cfc76bfa804ff20f5a9373661c73f96de5e", bytes: 14156776 },
+        { target: "linux-x64", asset: "agent-browser-linux-x64", sha256: "78e0c5a14a7fa1f3d1ae2acdbdcc94a047b435b998a8c505fcc49d7fa4935a49", bytes: 14253776 },
     ],
     [
         "win32-x64",
         {
+            // Upstream 0.37.0 still lacks PR #1781's Windows cold-start fix.
+            // Retain the native-verified revision until its replacement is tested.
             target: "win32-x64", version: "0.36.0-omb.1",
             asset: "agent-browser-win32-x64-0.36.0-omb.1.exe",
             url: "https://github.com/milind-soni/OpenMausBot/releases/download/browser-engine-v0.36.0-omb.1/agent-browser-win32-x64-0.36.0-omb.1.exe",