openmausbot 0.1.75 → 0.1.77

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);