openmausbot 0.1.71 → 0.1.73

package/dist-server/server/vps-computer.js

@@ -35,6 +35,17 @@ const MANAGED_VPS_CONTAINER_NAME = /^openmausbot-vps-[a-z0-9]{1,12}-[a-f0-9]{12}
 const IMAGE_ID = /^sha256:[a-f0-9]{64}$/i;
 const PIDS_LIMIT = 512;
 const SCREENSHOT_PATH = "/tmp/openmausbot-vps-preview.png";
+// The Cua XFCE base includes Pillow in its existing Python environment. Keep
+// this panel-only conversion in the transfer exec: no extra SSH round trip,
+// image rebuild, driver settings change, or second temporary image. Older
+// containers without Pillow can still return the original PNG.
+const SCREENSHOT_TRANSFER = `/opt/venv/bin/python -I -c 'import base64, io, sys
+from PIL import Image
+with Image.open(sys.argv[1]) as image:
+    image.thumbnail((1280, 1280))
+    output = io.BytesIO()
+    image.convert("RGB").save(output, format="JPEG", quality=70)
+sys.stdout.write(base64.b64encode(output.getvalue()).decode("ascii"))' "$1" 2>/dev/null || { base64 < "$1" | tr -d "\\n"; }`;
 const INTERNAL_VIEWER_PORT = 6901;
 const VIEWER_VERSION = "1";
 const lifecycleLocks = new Map();
@@ -60,6 +71,9 @@ const LOCK_ACQUIRE_TIMEOUT_MS = 5_000;
 // pattern as container-computer's screenshotStatusCache, and the same TTL.
 const STATUS_CACHE_TTL_MS = 10_000;
 const statusCache = new Map();
+const SCREENSHOT_BUDGET_MS = 45_000;
+const SCREENSHOT_CLEANUP_BUDGET_MS = 10_000;
+const pendingScreenshots = new Map();
 const viewerConnections = new Map();
 const desktopTunnels = new Map();
 function containerNamePart(botId) {
@@ -494,6 +508,9 @@ export async function vpsComputerStatus(cfg, botId, runner = defaultRunner) {
     const key = vpsLockKey(cfg, botId);
     const cacheable = runner === defaultRunner && key !== null;
     if (cacheable) {
+        // A capture already checks this exact target. Let it finish instead of
+        // opening another six SSH connections while its readiness check is cold.
+        await pendingScreenshots.get(key)?.catch(() => { });
         const cached = statusCache.get(key);
         if (cached && cached.expiresAt > Date.now())
             return cached.status;
@@ -1042,22 +1059,56 @@ export async function vpsComputerScreenshot(cfg, botId, runner = defaultRunner)
     if (!alias)
         throw Object.assign(new Error("VPS is not configured"), { status: 409 });
     const key = `${alias}:${vpsContainerName(botId)}`;
+    const pending = pendingScreenshots.get(key);
+    if (pending)
+        return pending;
     const cacheable = runner === defaultRunner;
-    return withVpsLifecycleLock(key, async () => {
+    const deadline = Date.now() + SCREENSHOT_BUDGET_MS;
+    const workDeadline = deadline - SCREENSHOT_CLEANUP_BUDGET_MS;
+    let budgetExpired = false;
+    const timeoutError = () => Object.assign(new Error("The VPS screen preview timed out. Retry the preview when the connection recovers."), { status: 504 });
+    // Clamp each command and wait through the runner's termination grace,
+    // rather than racing its promise and releasing the lock before cleanup.
+    const boundedRunner = async (args, options = {}) => {
+        const remaining = workDeadline - Date.now() - COMMAND_TIMEOUT_KILL_GRACE_MS;
+        if (remaining <= 0) {
+            budgetExpired = true;
+            throw timeoutError();
+        }
+        try {
+            const result = await runner(args, { ...options, timeoutMs: Math.min(options.timeoutMs ?? 120_000, remaining) });
+            if (Date.now() >= workDeadline) {
+                budgetExpired = true;
+                throw timeoutError();
+            }
+            return result;
+        }
+        catch (error) {
+            if (Date.now() >= workDeadline - COMMAND_TIMEOUT_KILL_GRACE_MS)
+                budgetExpired = true;
+            throw budgetExpired ? timeoutError() : error;
+        }
+    };
+    const capture = withVpsLifecycleLock(key, async () => {
         // Same shape as containerComputerScreenshot's screenshotStatusCache: the
         // poller runs every few seconds, and re-verifying the whole container
         // between frames multiplied every frame's SSH cost.
         const cached = cacheable ? statusCache.get(key) : undefined;
         const status = cached && cached.expiresAt > Date.now()
             ? cached.status
-            : await computeVpsComputerStatus(cfg, botId, runner);
+            : await computeVpsComputerStatus(cfg, botId, boundedRunner);
+        // Status converts transport errors into displayable state. A deadline is
+        // still a timeout, not evidence that this container became incompatible.
+        if (budgetExpired) {
+            if (cacheable)
+                statusCache.delete(key);
+            throw timeoutError();
+        }
         if (!status.ready) {
             if (cacheable)
                 statusCache.delete(key);
             throw Object.assign(new Error(status.problem ?? "The VPS computer is not ready"), { status: 409 });
         }
-        if (cacheable)
-            statusCache.set(key, { status, expiresAt: Date.now() + STATUS_CACHE_TTL_MS });
         const containerRef = status.container_id ?? status.container_name;
         // The ref goes straight into docker argv, and a cached status is one
         // more step removed from the inspect that produced it — revalidate the
@@ -1065,23 +1116,26 @@ export async function vpsComputerScreenshot(cfg, botId, runner = defaultRunner)
         if (!CONTAINER_ID.test(containerRef) && !CONTAINER_NAME.test(containerRef)) {
             throw Object.assign(new Error("the VPS container reference is malformed"), { status: 409 });
         }
+        let frame;
         try {
-            await runner(vpsDockerArgs(alias, cuaExecArgs(["call", "get_desktop_state", "{}", "--socket", CUA_SOCKET, "--screenshot-out-file", SCREENSHOT_PATH], { container: containerRef })), { timeoutMs: 30_000 });
-            const encoded = (await runner(vpsDockerArgs(alias, [
+            await boundedRunner(vpsDockerArgs(alias, cuaExecArgs(["call", "get_desktop_state", "{}", "--socket", CUA_SOCKET, "--screenshot-out-file", SCREENSHOT_PATH], { container: containerRef })), { timeoutMs: 30_000 });
+            const encoded = (await boundedRunner(vpsDockerArgs(alias, [
                 "exec",
                 "-u",
                 "cua",
                 "-e",
                 "HOME=/home/cua",
                 containerRef,
-                "base64",
-                "-w0",
+                "sh",
+                "-c",
+                SCREENSHOT_TRANSFER,
+                "openmausbot-preview",
                 SCREENSHOT_PATH,
             ]), { timeoutMs: 30_000 })).stdout.trim();
             const checked = wholeScreenshot(Buffer.from(encoded, "base64"));
             if (!checked.ok)
                 throw Object.assign(new Error("Cua Driver returned an incomplete VPS screenshot"), { status: 502 });
-            return { png: encoded, format: checked.mime === "image/jpeg" ? "jpeg" : "png" };
+            frame = { png: encoded, format: checked.mime === "image/jpeg" ? "jpeg" : "png" };
         }
         catch (error) {
             // The failure may mean the world changed (container stopped, link
@@ -1091,9 +1145,24 @@ export async function vpsComputerScreenshot(cfg, botId, runner = defaultRunner)
             throw error;
         }
         finally {
-            await runner(vpsDockerArgs(alias, ["exec", "-u", "cua", containerRef, "rm", "-f", SCREENSHOT_PATH]), {
-                timeoutMs: 10_000,
-            }).catch(() => { });
+            const cleanupMs = Math.min(5_000, deadline - Date.now() - COMMAND_TIMEOUT_KILL_GRACE_MS);
+            if (cleanupMs > 0)
+                await runner(vpsDockerArgs(alias, ["exec", "-u", "cua", containerRef, "rm", "-f", SCREENSHOT_PATH]), {
+                    timeoutMs: cleanupMs,
+                }).catch(() => { });
         }
+        // Start the TTL after transfer and cleanup; a slow but healthy frame must
+        // not return with its own readiness cache already expired.
+        if (cacheable)
+            statusCache.set(key, { status, expiresAt: Date.now() + STATUS_CACHE_TTL_MS });
+        return frame;
     });
+    pendingScreenshots.set(key, capture);
+    try {
+        return await capture;
+    }
+    finally {
+        if (pendingScreenshots.get(key) === capture)
+            pendingScreenshots.delete(key);
+    }
 }

package/dist-server/server/webhook-ingress.js

@@ -70,7 +70,7 @@ function eventName(req) {
         header(req, "x-event-type") ??
         header(req, "ce-type"))?.trim() || undefined;
 }
-export function createWebhookIngressHandler(manager) {
+export function createWebhookIngressHandler(manager, claimRequest) {
     return async (req, res) => {
         const url = new URL(req.url ?? "/", "http://localhost");
         if (req.method === "GET" && url.pathname === "/health") {
@@ -81,7 +81,9 @@ export function createWebhookIngressHandler(manager) {
             return json(res, 404, { error: "Unknown webhook endpoint" });
         if (req.method !== "POST")
             return json(res, 405, { error: "Webhooks accept POST requests" });
+        let release;
         try {
+            release = claimRequest?.();
             const pathSecret = match[2] ? decodeURIComponent(match[2]) : "";
             const secret = pathSecret || bearerSecret(req);
             // Reject bad capability URLs before buffering or parsing attacker input.
@@ -121,6 +123,9 @@ export function createWebhookIngressHandler(manager) {
             }
             return json(res, status, { error: message });
         }
+        finally {
+            release?.();
+        }
     };
 }
 /** The base senders are told to use. Behind a proxy or tunnel the listening
@@ -142,7 +147,7 @@ export function advertisedWebhookBase(raw) {
 export async function listenWebhookIngress(manager, options) {
     const host = options.host ?? "127.0.0.1";
     const advertised = options.publicBaseUrl === undefined ? undefined : advertisedWebhookBase(options.publicBaseUrl);
-    const server = createServer(createWebhookIngressHandler(manager));
+    const server = createServer(createWebhookIngressHandler(manager, options.claimRequest));
     await new Promise((resolve, reject) => {
         const onError = (error) => reject(error);
         server.once("error", onError);

package/dist-server/server/workspace-backup-http.js

@@ -0,0 +1,264 @@
+import { randomUUID } from "node:crypto";
+import { createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { z } from "zod";
+import { WORKSPACE_BACKUP_CLIENT_KEYS } from "../shared/workspace-backup-client.js";
+import { createWorkspaceBackup, stageWorkspaceBackup, commitPendingWorkspaceRestore, MAX_WORKSPACE_BACKUP_UPLOAD_BYTES, removeWorkspaceBackupJob, } from "./workspace-backup.js";
+const PREFIX = "/api/workspace-backup";
+const MAX_UPLOAD_BYTES = MAX_WORKSPACE_BACKUP_UPLOAD_BYTES;
+const MAX_CLIENT_STATE_BYTES = 2 * 1024 ** 2;
+const EXPIRES_MS = 60 * 60_000;
+const passwordSchema = z.string().min(12, "Use a password of at least 12 characters.").max(1024);
+const failure = (message, status = 400) => Object.assign(new Error(message), { status });
+/** Session-only controls remain usable while the workspace is locked. Their
+ * excluded session file is not part of the snapshot or replacement. */
+export function isWorkspaceBackupSessionControl(method, path) {
+    return (method === "GET" && path === "/api/auth/sessions") ||
+        (method === "POST" && path === "/api/auth/logout") ||
+        (method === "DELETE" && /^\/api\/auth\/sessions\/[\w-]+$/.test(path));
+}
+/** All routes remain admin-only in request-auth. Passwords and raw credential
+ * metadata never appear in URLs, responses, logs, or event broadcasts. */
+export function createWorkspaceBackupRoutes(options) {
+    // ponytail: one bounded set per server; transfers expire after an hour.
+    const artifacts = new Map();
+    let operating = false;
+    const json = (res, status, body) => {
+        res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+        res.end(JSON.stringify(body));
+    };
+    const owner = (auth) => auth.kind === "session" ? auth.session.id : "local-owner";
+    const check = (req, auth) => {
+        if (!options.authorized(req, auth))
+            throw failure("Your session changed. Reopen Backups and try again.", 403);
+    };
+    function remove(id, artifact) {
+        if (artifact.path) {
+            try {
+                unlinkSync(artifact.path);
+            }
+            catch { }
+        }
+        if (artifact.kind !== "upload") {
+            try {
+                removeWorkspaceBackupJob(options.dataDir, id);
+            }
+            catch { /* Recovery jobs are deliberately protected. */ }
+        }
+        artifacts.delete(id);
+    }
+    // A crashed process has no in-memory transfer map. Reclaim only its old,
+    // app-named jobs; never safety copies or pending/committed recovery state.
+    function reclaimAbandoned() {
+        const root = join(options.dataDir, ".backups");
+        if (!existsSync(root) || lstatSync(root).isSymbolicLink())
+            return;
+        for (const entry of readdirSync(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !/^[a-f0-9-]{36}$/.test(entry.name))
+                continue;
+            if (statSync(join(root, entry.name)).mtimeMs + EXPIRES_MS > Date.now())
+                continue;
+            try {
+                removeWorkspaceBackupJob(options.dataDir, entry.name);
+            }
+            catch { /* May belong to a recoverable restore. */ }
+        }
+        const uploads = join(root, "uploads");
+        if (!existsSync(uploads) || lstatSync(uploads).isSymbolicLink())
+            return;
+        for (const entry of readdirSync(uploads, { withFileTypes: true })) {
+            if (!entry.isFile() || !/^[a-f0-9-]{36}\.ombbackup$/.test(entry.name))
+                continue;
+            const file = join(uploads, entry.name);
+            if (statSync(file).mtimeMs + EXPIRES_MS <= Date.now()) {
+                try {
+                    unlinkSync(file);
+                }
+                catch { }
+            }
+        }
+    }
+    try {
+        reclaimAbandoned();
+    }
+    catch { /* Temporary-file cleanup must not prevent normal server startup. */ }
+    function expire() {
+        for (const [id, artifact] of artifacts) {
+            if (artifact.expires > Date.now())
+                continue;
+            remove(id, artifact);
+        }
+    }
+    function replacePrevious(auth, kinds) {
+        expire();
+        for (const [id, artifact] of artifacts)
+            if (artifact.owner === owner(auth) && kinds.includes(artifact.kind))
+                remove(id, artifact);
+    }
+    const get = (id, auth, kind) => {
+        expire();
+        const artifact = typeof id === "string" ? artifacts.get(id) : undefined;
+        if (!artifact || artifact.owner !== owner(auth) || artifact.kind !== kind) {
+            throw failure("This backup has expired or belongs to another session. Select the file again.", 404);
+        }
+        return artifact;
+    };
+    async function operate(work) {
+        if (operating)
+            throw failure("Another backup operation is in progress. Wait for it to finish.", 409);
+        operating = true;
+        try {
+            return await work();
+        }
+        finally {
+            operating = false;
+        }
+    }
+    return async (req, res, path, auth) => {
+        if (!path.startsWith(`${PREFIX}/`))
+            return false;
+        res.setHeader("cache-control", "no-store");
+        const method = req.method;
+        try {
+            check(req, auth);
+            if (method === "GET" && path === `${PREFIX}/status`) {
+                json(res, 200, {
+                    ...options.status(),
+                    lastRestoreId: options.restored.restored ? options.restored.id : null,
+                    safetyCopyPath: options.restored.safetyCopyPath ?? null,
+                });
+                return true;
+            }
+            if (method === "POST" && path === `${PREFIX}/client-state`) {
+                const body = z.object({ restoreId: z.string().uuid() }).parse(await options.readBody(req));
+                check(req, auth);
+                if (!options.restored.restored || body.restoreId !== options.restored.id)
+                    throw failure("This restore has not completed. Restart OpenMausBot first.", 409);
+                json(res, 200, { clientState: options.restored.clientState ?? {} });
+                return true;
+            }
+            if (method === "POST" && path === `${PREFIX}/export`) {
+                // Allow the full preference budget plus the JSON envelope/password.
+                const body = z.object({ password: passwordSchema, clientState: z.record(z.string(), z.string()).default({}) }).parse(await options.readBody(req, MAX_CLIENT_STATE_BYTES + 8 * 1024));
+                if (Buffer.byteLength(JSON.stringify(body.clientState)) > MAX_CLIENT_STATE_BYTES)
+                    throw failure("Saved drafts exceed the 2 MB backup preference limit.", 413);
+                const clientState = Object.fromEntries(Object.entries(body.clientState).filter(([key]) => WORKSPACE_BACKUP_CLIENT_KEYS.includes(key)));
+                const result = await operate(() => options.exclusive(async () => {
+                    check(req, auth);
+                    replacePrevious(auth, ["download"]);
+                    if (artifacts.size >= 4)
+                        throw failure("There are already four backup files in progress. Restart or wait an hour before creating another.", 409);
+                    return createWorkspaceBackup(options.dataDir, { password: body.password, clientState, appVersion: options.appVersion });
+                }));
+                try {
+                    check(req, auth);
+                }
+                catch (error) {
+                    removeWorkspaceBackupJob(options.dataDir, result.id);
+                    throw error;
+                }
+                artifacts.set(result.id, { owner: owner(auth), kind: "download", path: result.path, summary: result.summary, expires: Date.now() + EXPIRES_MS });
+                json(res, 200, { id: result.id, filename: `OpenMausBot-${result.summary.createdAt.slice(0, 10)}.ombbackup`, bytes: statSync(result.path).size, summary: result.summary });
+                return true;
+            }
+            const download = /^\/api\/workspace-backup\/download\/([\w-]+)$/.exec(path);
+            if (method === "GET" && download) {
+                const artifact = get(download[1], auth, "download");
+                const file = artifact.path;
+                res.writeHead(200, {
+                    "content-type": "application/octet-stream",
+                    "content-length": statSync(file).size,
+                    "content-disposition": `attachment; filename="OpenMausBot-${artifact.summary.createdAt.slice(0, 10)}.ombbackup"`,
+                    "x-content-type-options": "nosniff",
+                });
+                await pipeline(createReadStream(file), res);
+                return true;
+            }
+            if (method === "POST" && path === `${PREFIX}/upload`) {
+                await operate(async () => {
+                    const length = Number(req.headers["content-length"]);
+                    if (!Number.isSafeInteger(length) || length <= 0 || length > MAX_UPLOAD_BYTES)
+                        throw failure("Select a backup containing no more than 10 GB of workspace data.", 413);
+                    replacePrevious(auth, ["upload", "staged"]);
+                    if (artifacts.size >= 4)
+                        throw failure("There are already four backup files in progress. Restart or wait an hour before uploading another.", 409);
+                    const root = join(options.dataDir, ".backups");
+                    mkdirSync(root, { recursive: true, mode: 0o700 });
+                    if (lstatSync(root).isSymbolicLink())
+                        throw failure("Backup storage must not be a symbolic link.");
+                    const directory = join(root, "uploads");
+                    mkdirSync(directory, { recursive: true, mode: 0o700 });
+                    if (lstatSync(directory).isSymbolicLink())
+                        throw failure("Backup storage must not be a symbolic link.");
+                    const id = randomUUID();
+                    const file = join(directory, `${id}.ombbackup`);
+                    let bytes = 0;
+                    try {
+                        const limit = new Transform({ transform(chunk, _encoding, callback) {
+                                bytes += chunk.length;
+                                callback(bytes > MAX_UPLOAD_BYTES ? failure("The backup is too large.", 413) : null, chunk);
+                            } });
+                        await pipeline(req.iterator({ destroyOnReturn: false }), limit, createWriteStream(file, { flags: "wx", mode: 0o600 }));
+                        if (bytes !== length)
+                            throw failure("The upload was incomplete. Select the file again.");
+                        check(req, auth);
+                        artifacts.set(id, { owner: owner(auth), kind: "upload", path: file, expires: Date.now() + EXPIRES_MS });
+                        json(res, 200, { id });
+                    }
+                    catch (error) {
+                        try {
+                            unlinkSync(file);
+                        }
+                        catch { }
+                        throw error;
+                    }
+                });
+                return true;
+            }
+            if (method === "POST" && path === `${PREFIX}/preview`) {
+                const body = z.object({ id: z.string().uuid(), password: passwordSchema }).parse(await options.readBody(req));
+                const artifact = get(body.id, auth, "upload");
+                const result = await operate(() => stageWorkspaceBackup(options.dataDir, artifact.path, { password: body.password, currentAppVersion: options.appVersion }));
+                try {
+                    check(req, auth);
+                }
+                catch (error) {
+                    removeWorkspaceBackupJob(options.dataDir, result.id);
+                    throw error;
+                }
+                try {
+                    unlinkSync(artifact.path);
+                }
+                catch { }
+                artifacts.delete(body.id);
+                artifacts.set(result.id, { owner: owner(auth), kind: "staged", summary: result.summary, expires: Date.now() + EXPIRES_MS });
+                json(res, 200, { id: result.id, summary: result.summary });
+                return true;
+            }
+            if (method === "POST" && path === `${PREFIX}/restore`) {
+                const body = z.object({ id: z.string().uuid(), confirmation: z.literal("REPLACE") }).parse(await options.readBody(req));
+                get(body.id, auth, "staged");
+                const result = await operate(() => options.exclusive(async () => {
+                    check(req, auth);
+                    return commitPendingWorkspaceRestore(options.dataDir, body.id);
+                }, true));
+                artifacts.delete(body.id);
+                json(res, 200, { ...result, restoreId: body.id });
+                return true;
+            }
+            json(res, 404, { error: "Unknown backup operation." });
+        }
+        catch (error) {
+            if (res.headersSent) {
+                res.destroy();
+                return true;
+            }
+            json(res, error instanceof z.ZodError ? 400 : error.status ?? 400, {
+                error: error instanceof z.ZodError ? error.issues[0]?.message ?? "Invalid backup request." : error instanceof Error ? error.message : "Backup failed.",
+            });
+        }
+        return true;
+    };
+}

package/dist-server/server/workspace-backup-maintenance.js

@@ -0,0 +1,40 @@
+/** A backup owns one quiet workspace. Never interrupt a turn to obtain it. */
+export class WorkspaceBackupMaintenance {
+    active = false;
+    pendingRestore = false;
+    requests = 0;
+    assertAvailable() {
+        if (this.active)
+            throw Object.assign(new Error(this.pendingRestore
+                ? "A workspace restore is ready. Fully quit and reopen OpenMausBot (or restart the hosted server) to finish."
+                : "A workspace backup is in progress. Try again when it finishes."), { status: 503 });
+    }
+    request() {
+        this.assertAvailable();
+        this.requests++;
+        return () => { this.requests--; };
+    }
+    async run(work, hooks, keepLocked = false) {
+        this.assertAvailable();
+        if (this.requests || !hooks.idle())
+            throw Object.assign(new Error("Wait for bot turns, approvals, sign-ins, and computer actions to finish before backing up or restoring."), { status: 409 });
+        this.active = true;
+        let committed = false;
+        try {
+            hooks.pause();
+            await hooks.flush();
+            if (!hooks.idle())
+                throw Object.assign(new Error("The workspace is still finishing background work. Try again shortly."), { status: 409 });
+            const result = await work();
+            committed = keepLocked;
+            this.pendingRestore = keepLocked;
+            return result;
+        }
+        finally {
+            if (!committed) {
+                this.active = false;
+                hooks.resume();
+            }
+        }
+    }
+}

package/dist-server/server/workspace-backup-policy.js

@@ -0,0 +1,28 @@
+import { parseStoredConfig } from "./config.js";
+// Connection sections deliberately stay on the destination as a whole: a
+// restored URL must never redirect an API key retained from that device.
+// Allowlisting ordinary settings also keeps future/unknown auth fields out.
+const PORTABLE_CONFIG_KEYS = [
+    "profile", "language", "budgets", "billing", "rooms", "threads",
+    "localVm", "features", "browserProfiles",
+];
+export function portableWorkspaceConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid workspace configuration in backup.");
+    const config = parseStoredConfig(value);
+    return Object.fromEntries(PORTABLE_CONFIG_KEYS.filter((key) => config[key] !== undefined).map((key) => [key, config[key]]));
+}
+export function restoredWorkspaceConfig(portable, destination) {
+    if (!destination || typeof destination !== "object" || Array.isArray(destination))
+        throw new Error("Invalid destination workspace configuration; connections were not changed.");
+    const merged = { ...destination };
+    for (const key of PORTABLE_CONFIG_KEYS)
+        delete merged[key];
+    return { ...merged, ...portableWorkspaceConfig(portable) };
+}
+/** Exact app-owned authentication paths, not a scan of user document text. */
+export function excludedWorkspaceAuthPath(path) {
+    return /^(?:(?:providers|caddy|chrome-profile|\.agent-browser)(?:\/|$)|workspace-credentials\.json$|browser-engine-key$)/.test(path) ||
+        /^(?:config\.json|webhooks\.json|workspace-credentials\.json|browser-engine-key|sessions\.json|tunnel-account\.json)\.\d+(?:\.[0-9a-f-]+)?\.tmp$/.test(path) ||
+        /^(?:vm-home|vm-homes\/[^/]+)\/\.browser-profiles(?:\/|$)/.test(path);
+}