openmausbot 0.1.76 → 0.1.77

package/dist-server/server/message-file.js

@@ -326,6 +326,10 @@ function mimeFor(path) {
         case ".jpeg": return "image/jpeg";
         case ".gif": return "image/gif";
         case ".webp": return "image/webp";
+        case ".mp4": return "video/mp4";
+        case ".m4v": return "video/x-m4v";
+        case ".webm": return "video/webm";
+        case ".mov": return "video/quicktime";
         case ".doc": return "application/msword";
         case ".docx": return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
         case ".xls": return "application/vnd.ms-excel";

package/dist-server/server/provider-key-check.js

@@ -31,6 +31,8 @@ function modelIds(body) {
     return ids;
 }
 export async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 10_000) {
+    if (!input.key.trim())
+        return { ok: false, reason: "rejected" };
     let url;
     try {
         url = new URL(providerModelsUrl(input.provider, input.url));
@@ -41,6 +43,10 @@ export async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 10_
     if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url.hostname))) {
         return { ok: false, reason: "unexpected" };
     }
+    const authenticate = input.provider === "openaiCompat"
+        && url.origin === "https://openrouter.ai" && url.pathname === "/api/v1/models";
+    if (authenticate)
+        url.pathname = "/api/v1/key";
     const headers = input.provider === "anthropic"
         ? { "x-api-key": input.key, "anthropic-version": "2023-06-01" }
         : { authorization: `Bearer ${input.key}` };
@@ -55,7 +61,18 @@ export async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 10_
         if (!response.ok)
             return { ok: false, reason: "unexpected", status: response.status };
         const body = await response.json().catch(() => null);
-        return { ok: true, models: modelIds(body) };
+        if (!body || typeof body !== "object")
+            return { ok: false, reason: "unexpected", status: response.status };
+        if (authenticate) {
+            const data = body.data;
+            if (!data || typeof data !== "object" || Array.isArray(data)
+                || typeof data.is_free_tier !== "boolean") {
+                return { ok: false, reason: "unexpected", status: response.status };
+            }
+            // /key also returns account and usage details; none belong in this verdict.
+            return { ok: true, check: "authentication", models: [] };
+        }
+        return { ok: true, check: "models", models: modelIds(body) };
     }
     catch {
         return { ok: false, reason: "unreachable" };

package/dist-server/server/request-auth.js

@@ -157,6 +157,11 @@ export const CLIENT_ALLOW = [
     { methods: ["GET"], path: /^\/api\/auth\/session$/ },
     { methods: ["POST"], path: /^\/api\/auth\/stream-ticket$/ },
     { methods: ["POST"], path: /^\/api\/auth\/logout$/ },
+    // Own outbound desktop connector, additionally bound to a private secret.
+    // Only honoured while features.sharedComputers is on (see requiredScope):
+    // with the feature off these paths are as unlisted as any other, so a
+    // client session is refused exactly the way an unknown route refuses it.
+    { methods: ["POST"], path: /^\/api\/shared-computers\/(?:connect|[\w-]+\/(?:poll|lease|result|disconnect))$/, feature: "sharedComputers" },
     // liveness, identity, the stream
     { methods: ["GET"], path: /^\/api\/health$/ },
     { methods: ["GET"], path: /^\/api\/edition$/ },
@@ -218,9 +223,11 @@ export const CLIENT_ALLOW = [
     // configured-or-not booleans; the handler strips the few identifying fields for clients
     { methods: ["GET"], path: /^\/api\/config$/ },
 ];
-export function requiredScope(method, path) {
+export function requiredScope(method, path, features = {}) {
     const upper = method.toUpperCase();
     for (const rule of CLIENT_ALLOW) {
+        if (rule.feature && features[rule.feature] !== true)
+            continue;
         if (rule.path.test(path) && rule.methods.includes(upper))
             return "client";
     }
@@ -299,7 +306,7 @@ export function resolveRequestAuth(req, options) {
     if (session && via) {
         if (via === "cookie" && !isSameOrigin(req))
             return deny(403, "forbidden: cross-origin request");
-        const needed = requiredScope(method, path);
+        const needed = requiredScope(method, path, options.features ?? {});
         if (!session.scopes.includes(needed)) {
             return deny(403, `forbidden: this session lacks the ${needed} scope`);
         }
@@ -311,6 +318,11 @@ export function resolveRequestAuth(req, options) {
             options.sessions.renew(session.id);
         return { auth: { kind: "session", session, via, scopes: session.scopes }, status: 401, error: "" };
     }
+    // A removed email member must not become the loopback owner merely because
+    // their now-invalid cookie or bearer was presented to a local address.
+    if (via) {
+        return deny(401, "unauthorized: this session has expired or was revoked; pair this device again");
+    }
     const proxied = isProxied(req);
     const loopback = !proxied && isLoopbackHost(headerValue(req.headers.host)) && isAllowedOrigin(headerValue(req.headers.origin));
     if (loopback) {
@@ -330,9 +342,6 @@ export function resolveRequestAuth(req, options) {
         }
         return { auth: { kind: "loopback", scopes: LOOPBACK_SCOPES }, status: 401, error: "" };
     }
-    if (via) {
-        return deny(401, "unauthorized: this session has expired or was revoked; pair this device again");
-    }
     if (proxied) {
         return deny(403, "forbidden: this request came through a proxy (pair this device to use the server remotely)");
     }

package/dist-server/server/sessions.js

@@ -9,9 +9,10 @@
 // endpoint, because EventSource cannot set headers. Failed exchanges are
 // counted per source: five in a minute lock that source out for ten.
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
 export const SCOPES = ["admin", "client"];
 export const PAIRING_CODE_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
 export const PAIRING_CODE_LENGTH = 12;
@@ -69,6 +70,8 @@ const sessionSchema = z.object({
     /** Set when the session came from an account sign-in rather than a code. */
     userId: z.string().max(256).optional(),
     email: z.string().max(320).optional(),
+    /** Set only by the internal verified-portal issuance path, never by email or pairing input. */
+    membershipAuthority: z.literal("portal").optional(),
 });
 const fileSchema = z.object({ version: z.literal(1), sessions: z.array(sessionSchema) });
 const sha256 = (value) => createHash("sha256").update(value).digest("hex");
@@ -127,14 +130,29 @@ export class SessionRegistry {
     lastSeenWrites = new Map();
     now;
     options;
+    openMarker;
+    closed = false;
     // No parameter properties: the server runs this file under Node's
     // strip-only TypeScript mode, which only erases types.
     constructor(options) {
         this.options = options;
         this.now = options.now ?? Date.now;
-        this.load();
+        this.openMarker = `${options.file}.open`;
+        const unclean = existsSync(this.openMarker);
+        try {
+            mkdirSync(dirname(options.file), { recursive: true, mode: 0o700 });
+            // Establish the guard before accepting any persisted bearer. Even if
+            // every subsequent write fails, an unclean restart will see this marker.
+            writeFileAtomic(this.openMarker, "Session registry is open.\n", { mode: 0o600 });
+            this.syncDirectory();
+        }
+        catch {
+            throw new Error("Could not establish safe session storage.");
+        }
+        this.load(!unclean);
+        this.revalidateEmailSessions();
     }
-    load() {
+    load(restoreAccounts) {
         if (!existsSync(this.options.file))
             return;
         let raw;
@@ -146,18 +164,50 @@ export class SessionRegistry {
         }
         const parsed = fileSchema.safeParse(raw);
         if (parsed.success)
-            this.sessions = parsed.data.sessions;
+            this.sessions = parsed.data.sessions.filter(session => restoreAccounts || (session.email === undefined && session.userId === undefined));
+    }
+    syncDirectory() {
+        // Windows does not expose directory fsync. The open marker still guards
+        // normal process crashes; no stronger power-loss guarantee is claimed.
+        if (process.platform === "win32")
+            return;
+        const fd = openSync(dirname(this.options.file), "r");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
     }
     /** Atomic write, owner-only, directory owner-only. */
     persist() {
+        if (this.closed)
+            throw new Error("Session registry is closed.");
         const dir = dirname(this.options.file);
         mkdirSync(dir, { recursive: true, mode: 0o700 });
-        const tmp = `${this.options.file}.${process.pid}.tmp`;
-        writeFileSync(tmp, JSON.stringify({ version: 1, sessions: this.sessions }, null, 2) + "\n", { mode: 0o600 });
-        chmodSync(tmp, 0o600);
-        renameSync(tmp, this.options.file);
+        writeFileAtomic(this.options.file, JSON.stringify({ version: 1, sessions: this.sessions }, null, 2) + "\n", { mode: 0o600 });
+        this.syncDirectory();
+    }
+    /** Call after HTTP/stream shutdown. A failed close leaves the open marker,
+     * so account sessions require fresh sign-in after restart. Paired devices
+     * remain durable. Never remove the marker before the reduced set is saved. */
+    close() {
+        if (this.closed)
+            return;
+        try {
+            this.revalidateEmailSessions();
+            this.persist();
+            unlinkSync(this.openMarker);
+            this.closed = true;
+            // A marker deletion lost on power failure causes extra sign-in only;
+            // the session file and its rename were fsynced before removal.
+        }
+        catch {
+            throw new Error("Could not safely close session storage.");
+        }
     }
     prune() {
+        this.revalidateEmailSessions();
         const now = this.now();
         this.pairings = this.pairings.filter((p) => p.expiresAt > now);
         this.replays = this.replays.filter((r) => r.expiresAt > now);
@@ -293,6 +343,16 @@ export class SessionRegistry {
     /** A session from a verified account sign-in (server/account-signin.ts)
      * rather than a pairing code: same token, same term, same gates. */
     issue(input) {
+        return this.issueAccount(input);
+    }
+    /** Internal hosted-bridge seam: call only after consuming a verified,
+     * workspace-bound PKCE grant. No HTTP route accepts this marker as input. */
+    issuePortal(input) {
+        if (!/^[A-Za-z0-9_-]{43}$/.test(input.grant) || !input.email)
+            throw new Error("A verified portal identity is required");
+        return this.issueAccount({ label: "Hosted workspace", email: input.email, userId: `portal:${input.grant}`, scopes: input.scopes }, "portal");
+    }
+    issueAccount(input, membershipAuthority) {
         this.prune();
         const now = this.now();
         const token = `omb_sess_${randomBytes(32).toString("base64url")}`;
@@ -309,6 +369,8 @@ export class SessionRegistry {
             record.userId = input.userId;
         if (input.email)
             record.email = input.email;
+        if (membershipAuthority)
+            record.membershipAuthority = membershipAuthority;
         this.sessions.push(record);
         this.lastSeenWrites.set(record.id, now);
         this.persist();
@@ -326,9 +388,53 @@ export class SessionRegistry {
         this.failures.delete(source);
     }
     // ── sessions ───────────────────────────────────────────────────────────
+    /** Email membership is live, not a thirty-day grant. Losing any issued
+     * scope revokes the token and its streams; signing in again obtains the
+     * new role. Promotions never widen existing credentials. Pairing sessions
+     * have no email and remain independent of the hosted sign-in list. */
+    revalidateEmailSessions() {
+        if (this.closed)
+            throw new Error("Session registry is closed.");
+        const eligible = this.sessions.filter(session => session.email !== undefined && !(this.options.portalMembership && session.membershipAuthority === "portal"));
+        if (!eligible.length)
+            return;
+        let resolveScopes = this.options.emailScopes;
+        try {
+            if (this.options.emailScopesSnapshot)
+                resolveScopes = this.options.emailScopesSnapshot();
+        }
+        catch {
+            resolveScopes = undefined; // Never fall back to stale membership after a failed snapshot.
+        }
+        const revoked = eligible.filter((session) => {
+            try {
+                const allowed = resolveScopes?.(session.email);
+                return !allowed || session.scopes.some((scope) => !allowed.includes(scope));
+            }
+            catch {
+                return true; // missing or unreadable membership must fail closed
+            }
+        });
+        if (!revoked.length)
+            return;
+        const ids = new Set(revoked.map((session) => session.id));
+        this.sessions = this.sessions.filter((session) => !ids.has(session.id));
+        for (const session of revoked)
+            this.forget(session.id);
+        try {
+            this.persist();
+        }
+        catch {
+            // Revocation stays effective in memory and streams close. The boot
+            // marker prevents old account bearers from reviving after an unclean
+            // restart, even if membership is later restored and all writes failed.
+            console.error("Could not persist email session revocation.");
+        }
+    }
     authenticate(token) {
         if (!token)
             return null;
+        this.revalidateEmailSessions();
         const hash = sha256(token);
         const now = this.now();
         const record = this.sessions.find((s) => sameDigest(s.tokenHash, hash));
@@ -349,6 +455,7 @@ export class SessionRegistry {
      * Nothing expired is revived. Writes at most once per half-term, so it
      * adds nothing to the last-seen traffic. Returns whether it renewed. */
     renew(sessionId) {
+        this.revalidateEmailSessions();
         const record = this.sessions.find((s) => s.id === sessionId);
         const now = this.now();
         if (!record || record.expiresAt <= now)

package/dist-server/server/shared-computer-control.js

@@ -0,0 +1,24 @@
+/** A local desktop call competes with ordinary bot turns for the same screen.
+ * Leases expire if Electron crashes; human takeover always wins renewal. */
+export class SharedComputerControl {
+    leases = new Map();
+    resources;
+    held;
+    constructor(resources, held) { this.resources = resources; this.held = held; }
+    acquire(id) {
+        const owner = { threadId: `shared:${id}`, generation: id };
+        if (this.held() || !this.resources.claim("computer:host", owner)) {
+            this.release(id);
+            throw Object.assign(new Error("This computer is in use locally or held by a person. Wait, then observe it again before acting."), { status: 409 });
+        }
+        clearTimeout(this.leases.get(id));
+        this.leases.set(id, setTimeout(() => this.release(id), 40_000));
+    }
+    release(id) {
+        clearTimeout(this.leases.get(id));
+        this.leases.delete(id);
+        this.resources.release({ threadId: `shared:${id}`, generation: id });
+    }
+    close() { for (const id of this.leases.keys())
+        this.release(id); }
+}

package/dist-server/server/shared-computers.js

@@ -0,0 +1,131 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+const folder = z.object({ id: z.string().uuid(), name: z.string().min(1).max(120), write: z.boolean() }).strict();
+export const sharedComputerRegistration = z.object({
+    id: z.string().uuid(), name: z.string().min(1).max(120), environmentId: z.string().uuid(),
+    folders: z.array(folder).max(20), terminal: z.boolean(), computer: z.boolean(),
+}).strict();
+export const sharedComputerOperation = z.object({
+    computer_id: z.string().uuid(),
+    action: z.enum(["list_files", "read_file", "write_file", "run_command", "computer_tools", "computer_call"]),
+    folder_id: z.string().uuid().optional(), path: z.string().max(2048).optional(),
+    content: z.string().max(350_000).optional(), encoding: z.enum(["utf8", "base64"]).optional(),
+    expected_sha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+    command: z.string().max(8000).optional(), tool_name: z.string().max(100).optional(),
+    arguments: z.record(z.string(), z.unknown()).optional(),
+}).strict();
+const failure = (message, status = 409) => Object.assign(new Error(message), { status });
+/** In-memory rendezvous only. Authority over local resources stays on the
+ * desktop. Restart/disconnect NEVER replays an operation with an unknown outcome. */
+export class SharedComputers {
+    computers = new Map();
+    sessionLive;
+    constructor(sessionLive) { this.sessionLive = sessionLive; }
+    register(registration, owner, secret) {
+        if (!/^[a-f0-9]{64}$/.test(secret))
+            throw failure("Invalid computer credential", 400);
+        const old = this.computers.get(registration.id);
+        if (old) {
+            this.authorize(registration.id, owner, secret);
+            old.registration = registration;
+            old.seen = Date.now();
+        }
+        else {
+            // Reap dead devices before applying the bounded registration limit.
+            for (const [id, entry] of this.computers)
+                if (!this.online(entry) && entry.jobs.size === 0)
+                    this.computers.delete(id);
+            if (this.computers.size >= 20)
+                throw failure("Too many shared computers");
+            this.computers.set(registration.id, { registration, owner, secret, seen: Date.now(), jobs: new Map() });
+        }
+    }
+    online(entry) { return this.sessionLive(entry.owner) && Date.now() - entry.seen < 40_000; }
+    authorize(id, owner, secret) {
+        const entry = this.computers.get(id);
+        if (!entry || entry.owner !== owner || !this.sessionLive(owner) || !/^[a-f0-9]{64}$/.test(secret) || !timingSafeEqual(Buffer.from(secret), Buffer.from(entry.secret)))
+            throw failure("Shared computer is disconnected or not authorized", 403);
+        return entry;
+    }
+    list() { return [...this.computers.values()].filter(entry => this.online(entry)).map(entry => entry.registration); }
+    async poll(id, owner, secret) {
+        const entry = this.authorize(id, owner, secret);
+        if (entry.wake)
+            throw failure("A computer poll is already running");
+        entry.seen = Date.now();
+        const next = () => {
+            for (const job of entry.jobs.values()) {
+                if (!job.active()) {
+                    this.finish(entry, job, failure("The requesting turn ended"));
+                    continue;
+                }
+                if (!job.sent) {
+                    job.sent = true;
+                    return { id: job.id, operation: job.operation };
+                }
+            }
+            return null;
+        };
+        const queued = next();
+        if (queued)
+            return queued;
+        await new Promise(resolve => {
+            const timer = setTimeout(() => { entry.wake = undefined; resolve(); }, 20_000);
+            entry.wake = () => { clearTimeout(timer); entry.wake = undefined; resolve(); };
+        });
+        this.authorize(id, owner, secret);
+        entry.seen = Date.now();
+        return next();
+    }
+    liveJob(id, owner, secret, jobId) {
+        const entry = this.authorize(id, owner, secret);
+        entry.seen = Date.now();
+        const job = entry.jobs.get(jobId);
+        return job?.sent === true && job.active();
+    }
+    complete(id, owner, secret, jobId, result) {
+        const entry = this.authorize(id, owner, secret);
+        const job = entry.jobs.get(jobId);
+        if (!job || !job.sent)
+            throw failure("This computer operation expired; it will not be replayed");
+        this.finish(entry, job, job.active() ? null : failure("The requesting turn ended"), result);
+    }
+    disconnect(id, owner, secret) {
+        const entry = this.authorize(id, owner, secret);
+        this.computers.delete(id);
+        entry.wake?.();
+        for (const job of entry.jobs.values())
+            this.finish(entry, job, failure("Computer disconnected. An in-flight action may have completed; inspect before retrying."));
+    }
+    request(operation, active) {
+        const entry = this.computers.get(operation.computer_id);
+        if (!entry || !this.online(entry))
+            return Promise.reject(failure("This shared computer is offline. Keep its desktop app open; do not substitute files on the server."));
+        if (entry.jobs.size >= 1)
+            return Promise.reject(failure("This shared computer is busy. Wait for its current action to finish."));
+        if (!active())
+            return Promise.reject(failure("The requesting turn ended", 401));
+        return new Promise((resolve, reject) => {
+            const id = randomUUID();
+            const job = { id, operation, active, sent: false, resolve, reject, timer: setTimeout(() => this.finish(entry, job, failure("Computer action timed out. Its outcome is unknown; inspect before retrying.")), 45_000) };
+            entry.jobs.set(id, job);
+            entry.wake?.();
+        });
+    }
+    close() {
+        for (const entry of this.computers.values()) {
+            entry.wake?.();
+            for (const job of entry.jobs.values())
+                this.finish(entry, job, failure("Workspace stopped. Inspect any in-flight action before retrying."));
+        }
+        this.computers.clear();
+    }
+    finish(entry, job, error, result) {
+        clearTimeout(job.timer);
+        entry.jobs.delete(job.id);
+        if (error)
+            job.reject(error);
+        else
+            job.resolve(result);
+    }
+}

package/dist-server/server/steer-queue.js

@@ -71,6 +71,7 @@ export function queueSteeredMessage(botId, threadId, text, options = {}) {
         sendId: options.sendId,
         reason: options.reason,
         unattended: options.unattended,
+        peerAsk: options.peerAsk,
     };
     saveChatFollowup({ id, kind: "bot", ownerId: botId, threadId, payload: item });
     entry.items.push(item);
@@ -132,6 +133,7 @@ export function drainSteeredMessages(store, run, isBlocked) {
                 replyToId: item.replyToId,
                 sendId: item.sendId,
                 queueId: item.messageId,
+                peerAsk: item.peerAsk,
             }));
         }
         const last = appended.at(-1);

package/dist-server/server/store.js

@@ -378,15 +378,27 @@ export class Store {
             // bots.json write. Revoke it before schedulers, listeners, or HTTP can
             // start any new work.
             if (b.approvalGrant !== undefined) {
-                b.approvalMode = "ask";
-                b.autoApprove = false;
-                delete b.approvalGrant;
-                for (const task of b.tasks ?? []) {
-                    if (task.approvalMode === "full" || task.approvalMode === "custom") {
-                        task.approvalMode = "ask";
-                        task.autoApprove = false;
+                const threadOnly = b.approvalGrant.threadOnly === true;
+                if (threadOnly) {
+                    // A crash may land between saving the target and clearing its
+                    // journal. Revoke that target only, never unrelated threads.
+                    const target = b.tasks?.find(task => task.threadId === b.approvalGrant?.threadId);
+                    if (target) {
+                        target.approvalMode = "ask";
+                        target.autoApprove = false;
                     }
                 }
+                if (!threadOnly) {
+                    b.approvalMode = "ask";
+                    b.autoApprove = false;
+                    for (const task of b.tasks ?? []) {
+                        if (task.approvalMode === "full" || task.approvalMode === "custom") {
+                            task.approvalMode = "ask";
+                            task.autoApprove = false;
+                        }
+                    }
+                }
+                delete b.approvalGrant;
                 botsMigrated = true;
             }
             const avatar = botAvatarProfile(b);
@@ -1617,6 +1629,7 @@ export class Store {
         return {
             ...bot,
             threadId: task.threadId,
+            approvalGrant: bot.approvalGrant?.threadOnly && bot.approvalGrant.threadId !== threadId ? undefined : bot.approvalGrant,
             modelSelection: structuredClone(task.modelSelection ?? bot.modelSelection),
             resumeCursors: structuredClone(task.resumeCursors),
             approvalMode: task.approvalMode ?? (task.autoApprove === undefined ? bot.approvalMode : undefined),

package/dist-server/server/team-computers.js

@@ -0,0 +1,108 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.js";
+export const teamComputerCreate = z.object({
+    name: z.string().trim().min(1).max(60).refine(value => [...value].every(character => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127)),
+    acknowledgeCost: z.literal(true),
+    // Clients may keep this id across a lost create response. It is not a Box id.
+    requestId: z.string().uuid(),
+}).strict();
+export const teamComputerAssignment = z.object({
+    section: z.string().trim().max(60).nullable(),
+    acknowledgeSharedAccess: z.literal(true),
+}).strict();
+const entrySchema = z.object({
+    id: z.string().uuid(), name: teamComputerCreate.shape.name,
+    section: z.string().trim().max(60).nullable(), createdAt: z.number().finite().nonnegative(),
+    problem: z.string().max(500).optional(),
+}).strict();
+const fileSchema = z.object({ version: z.literal(1), environmentId: z.string().uuid(), computers: z.array(entrySchema).max(100) }).strict();
+export const teamComputerOwner = (id) => `computer_${id}`;
+const failure = (message, status = 409) => Object.assign(new Error(message), { status });
+/** One server writer owns the data directory. Persist identity before any
+ * provider call; failed/retried creates always retain the same Box journal key.
+ * Invalid or foreign restored state is never silently reset to an empty pool. */
+export class TeamComputers {
+    entries = [];
+    problem;
+    file;
+    environmentId;
+    constructor(file, environmentId) {
+        this.file = file;
+        this.environmentId = environmentId;
+        try {
+            if (!existsSync(file))
+                return;
+            const stat = lstatSync(file);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 100_000)
+                throw new Error("unsafe registry file");
+            const saved = fileSchema.parse(JSON.parse(readFileSync(file, "utf8")));
+            if (saved.environmentId !== environmentId)
+                throw new Error("registry belongs to another workspace; its computers were not transferred");
+            if (new Set(saved.computers.map(entry => entry.id)).size !== saved.computers.length)
+                throw new Error("duplicate computer identity");
+            const sections = saved.computers.flatMap(entry => entry.section === null ? [] : [entry.section]);
+            if (new Set(sections).size !== sections.length)
+                throw new Error("a team has more than one computer");
+            this.entries = saved.computers;
+        }
+        catch (error) {
+            this.problem = `Team computer registry could not be loaded: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    list() {
+        if (this.problem)
+            throw failure(this.problem, 503);
+        return this.entries.map(entry => ({ ...entry }));
+    }
+    get(id) { return this.list().find(entry => entry.id === id); }
+    forSection(section) {
+        return this.list().find(entry => entry.section !== null && entry.section === (section?.trim() || ""));
+    }
+    forBot(bot) {
+        // Explicit destinations are permissions, not suggestions. Only Auto inherits.
+        return bot.computer === undefined && bot.cloudBackend !== "vps" ? this.forSection(bot.section) : undefined;
+    }
+    create(name, id = randomUUID()) {
+        const entries = this.list();
+        const existing = entries.find(entry => entry.id === id);
+        if (existing) {
+            if (existing.name !== name)
+                throw failure("This creation id already names a different computer");
+            return existing;
+        }
+        if (entries.length >= 100)
+            throw failure("This workspace has reached its team computer limit");
+        const entry = entrySchema.parse({ id, name, section: null, createdAt: Date.now() });
+        this.save([...entries, entry]);
+        return { ...entry };
+    }
+    assign(id, section) {
+        section = entrySchema.shape.section.parse(section);
+        const entry = this.get(id);
+        if (!entry)
+            throw failure("No such team computer", 404);
+        if (entry.section !== null && section !== null && section !== entry.section)
+            throw failure("Unassign this computer before moving it to another team");
+        if (section !== null && this.list().some(other => other.id !== id && other.section === section))
+            throw failure("This team already has a computer; unassign it first");
+        return this.patch(id, { section });
+    }
+    setProblem(id, problem) {
+        return this.patch(id, { problem: problem?.slice(0, 500) });
+    }
+    patch(id, patch) {
+        const entries = this.list();
+        const entry = entries.find(candidate => candidate.id === id);
+        if (!entry)
+            throw failure("No such team computer", 404);
+        const next = entrySchema.parse({ ...entry, ...patch });
+        this.save(entries.map(candidate => candidate.id === id ? next : candidate));
+        return { ...next };
+    }
+    save(entries) {
+        writeFileAtomic(this.file, JSON.stringify({ version: 1, environmentId: this.environmentId, computers: entries }), { mode: 0o600 });
+        this.entries = entries;
+    }
+}