openmausbot 0.1.90 → 0.1.92

package/dist-server/server/routes/bot-memory.js

@@ -41,6 +41,7 @@ export function createBotMemoryRoutes(deps) {
     return async ({ req, res, url, path, method, auth, json, readBody }) => {
         /** scratch for route matches, shared by every `path.match` below */
         let m = null;
+        const write = (botId, change) => deps.ownersWrite ? deps.ownersWrite(auth, botId, change) : change();
         m = path.match(/^\/api\/bots\/([\w-]+)\/memory$/);
         if (m && method === "GET") {
             if (!deps.bot(m[1]))
@@ -49,7 +50,9 @@ export function createBotMemoryRoutes(deps) {
                 const overview = memoryOverview(m[1]);
                 // `text` and `truncated` ride along one release for clients of the
                 // old whole-file shape; the panel reads the file through /memory/file
-                return json(res, 200, { ...overview, text: readMemoryDoc(m[1], MEMORY_INDEX).text, truncated: overview.index.truncated });
+                const review = deps.lendingReview?.needed(m[1]);
+                return json(res, 200, { ...overview, text: readMemoryDoc(m[1], MEMORY_INDEX).text, truncated: overview.index.truncated,
+                    ...(review ? { lendingReview: review } : {}) });
             }
             catch (error) {
                 return replyMemoryError(res, error);
@@ -65,7 +68,8 @@ export function createBotMemoryRoutes(deps) {
             if (!parsed.success)
                 return json(res, 400, { error: "text must be a string" });
             try {
-                const { doc } = journalMemoryWrite(m[1], MEMORY_INDEX, parsed.data.text, { actor: "person", via: "api" });
+                const botId = m[1];
+                const { doc } = write(botId, () => journalMemoryWrite(botId, MEMORY_INDEX, parsed.data.text, { actor: "person", via: "api" }));
                 return json(res, 200, { ok: true, hash: doc.hash, truncated: memoryCapacity(doc.text).truncated });
             }
             catch (error) {
@@ -76,6 +80,24 @@ export function createBotMemoryRoutes(deps) {
                 return replyMemoryError(res, error);
             }
         }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/reviewed$/);
+        if (m && method === "POST" && deps.lendingReview) {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            if (!deps.lendingReview.owner(auth)) {
+                return json(res, 403, { error: "Only the owner of this Cloud can review this bot's memory, from one of their own devices." });
+            }
+            // Bound to what the owner was shown: the token names the files exactly
+            // as the panel read them. Anything changed since is shown again.
+            const parsed = z.object({ token: z.string().regex(/^[a-f0-9]{64}$/) }).safeParse(await readBody(req));
+            if (!parsed.success)
+                return json(res, 400, { error: "token is required: the lendingReview token the Memory panel was shown" });
+            if (!deps.lendingReview.accept(m[1], parsed.data.token)) {
+                return json(res, 409, { error: "This bot's memory changed since you looked. Review it again.", code: "changed",
+                    lendingReview: deps.lendingReview.needed(m[1]) });
+            }
+            return json(res, 200, { ok: true, lendingReview: false });
+        }
         m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/file$/);
         if (m && method === "GET") {
             if (!deps.bot(m[1]))
@@ -96,11 +118,12 @@ export function createBotMemoryRoutes(deps) {
             if (!parsed.success)
                 return json(res, 400, { error: "text must be a string; path and expectedHash are optional strings" });
             try {
-                const { doc, entry } = journalMemoryWrite(m[1], parsed.data.path, parsed.data.text, {
+                const botId = m[1];
+                const { doc, entry } = write(botId, () => journalMemoryWrite(botId, parsed.data.path, parsed.data.text, {
                     actor: "person",
                     via: "ui",
                     expectedHash: parsed.data.expectedHash,
-                });
+                }));
                 return json(res, 200, { ok: true, ...doc, entry: entry ? journalEntryForClient(m[1], entry) : null, overview: memoryOverview(m[1]) });
             }
             catch (error) {
@@ -112,7 +135,8 @@ export function createBotMemoryRoutes(deps) {
                 return json(res, 404, { error: "no such bot" });
             const file = url.searchParams.get("path") ?? "";
             try {
-                const entry = journalMemoryDelete(m[1], file, { actor: "person", via: "ui" });
+                const botId = m[1];
+                const entry = write(botId, () => journalMemoryDelete(botId, file, { actor: "person", via: "ui" }));
                 return json(res, 200, { ok: true, path: file, entry: entry ? journalEntryForClient(m[1], entry) : null, overview: memoryOverview(m[1]) });
             }
             catch (error) {
@@ -134,7 +158,8 @@ export function createBotMemoryRoutes(deps) {
             if (!deps.bot(m[1]))
                 return json(res, 404, { error: "no such bot" });
             await flushMemoryJournal(m[1]);
-            const result = revertMemoryChange(m[1], m[2]);
+            const botId = m[1], changeId = m[2];
+            const result = write(botId, () => revertMemoryChange(botId, changeId));
             if (!result.ok)
                 return json(res, result.status, { error: result.error });
             return json(res, 200, { ok: true, ...result.doc, entry: result.entry ? journalEntryForClient(m[1], result.entry) : null, overview: memoryOverview(m[1]) });

package/dist-server/server/routes/decider.js

@@ -0,0 +1,19 @@
+import { PASS } from "./table.js";
+const MAX_KEY_LENGTH = 512;
+export function createDeciderRoutes(deps) {
+    return async ({ req, res, path, method, json, readBody }) => {
+        if (path !== "/api/decider/test" || method !== "POST")
+            return PASS;
+        const body = await readBody(req, 8192);
+        if (body?.key !== undefined && typeof body.key !== "string")
+            return json(res, 400, { error: "key must be a string" });
+        const draft = typeof body?.key === "string" ? body.key.trim() : "";
+        if (draft.length > MAX_KEY_LENGTH)
+            return json(res, 400, { error: "That does not look like an API key." });
+        res.setHeader("cache-control", "no-store");
+        const result = await deps.decider.testKey(draft ? { key: draft } : {});
+        if (result.ok)
+            return json(res, 200, { ok: true, latencyMs: result.latencyMs });
+        return json(res, 200, { ok: false, reason: result.reason, ...(result.status ? { status: result.status } : {}) });
+    };
+}

package/dist-server/server/routes/desktop-viewer.js

@@ -0,0 +1,194 @@
+// Only the RFB WebSocket crosses the container boundary. The viewer page is
+// bundled with the app: serving container-controlled JavaScript on the app's
+// origin would give a bot access to the person's authenticated workspace.
+import { createHash } from "node:crypto";
+import { request, ServerResponse } from "node:http";
+import { Socket } from "node:net";
+import { isSameOrigin } from "../request-auth.js";
+import { PASS } from "./table.js";
+const ROUTE = /^\/api\/desktop-viewer\/(local\/(?:shared|bot-[a-f0-9]{64}|pool-\d+)|vps\/[\w-]+)(\/websockify)?$/;
+const HANDSHAKE_MS = 10_000;
+const RECHECK_MS = 5_000;
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+export function desktopViewerUrl(target, threadId) {
+    const params = new URLSearchParams({ target, ...(threadId ? { threadId } : {}) });
+    return `/desktop-viewer#${params}`;
+}
+export function createDesktopViewer(deps) {
+    const upgrades = new Map();
+    let stopped = false;
+    /** Run upgrades through the very same authentication, hosted-workspace and
+     * maintenance gates as HTTP. Only this route can detach the response socket. */
+    function attach(server, handle) {
+        server.on("upgrade", (req, socket, head) => {
+            if (stopped || !(socket instanceof Socket)) {
+                socket.destroy();
+                return;
+            }
+            const res = new ServerResponse(req);
+            res.assignSocket(socket);
+            // Rejected upgrades end this socket; do not let HTTP clients pool it.
+            res.setHeader("connection", "close");
+            socket.on("error", () => socket.destroy());
+            res.once("finish", () => socket.end(() => socket.destroy()));
+            let path;
+            try {
+                path = new URL(req.url ?? "", "http://localhost").pathname;
+            }
+            catch {
+                res.writeHead(400).end();
+                return;
+            }
+            if (!ROUTE.exec(path)?.[2]) {
+                res.writeHead(404).end();
+                return;
+            }
+            // Keep reading while auth/inspection awaits, so a closed tab's FIN is
+            // observed. Bound and preserve any eagerly sent WebSocket bytes.
+            const upgrade = { socket, head, release: () => socket.off("data", buffer), close: () => socket.destroy() };
+            const buffer = (data) => {
+                if (upgrade.head.length + data.length > 64 * 1024)
+                    socket.destroy();
+                else
+                    upgrade.head = Buffer.concat([upgrade.head, data]);
+            };
+            socket.on("data", buffer);
+            socket.once("end", () => socket.destroy());
+            socket.once("close", () => { upgrade.release(); upgrades.delete(req); });
+            upgrades.set(req, upgrade);
+            const timeout = setTimeout(() => socket.destroy(), HANDSHAKE_MS);
+            timeout.unref();
+            socket.once("close", () => clearTimeout(timeout));
+            void handle(req, res).catch(() => {
+                if (!res.headersSent)
+                    res.writeHead(500).end();
+                else
+                    socket.destroy();
+            }).finally(() => clearTimeout(timeout));
+        });
+    }
+    const route = async ({ req, res, path, method, auth, json }) => {
+        const match = ROUTE.exec(path);
+        if (!match)
+            return PASS;
+        res.setHeader("cache-control", "private, no-store");
+        if (method !== "GET")
+            return json(res, 405, { error: "method not allowed" });
+        // Also enforce at this boundary; the central gate defaults these paths
+        // to admin, like the existing Local VM status and control endpoints.
+        if (!auth.scopes.includes("admin") || !isSameOrigin(req))
+            return json(res, 403, { error: "forbidden" });
+        const target = deps.target(match[1]);
+        if (!target)
+            return json(res, 404, { error: "Desktop not found" });
+        const upgrade = upgrades.get(req);
+        if (upgrade && auth.kind === "session")
+            upgrade.owner = auth.session.id;
+        let connection;
+        try {
+            connection = await target.resolve();
+        }
+        catch (error) {
+            const status = error && typeof error === "object" && "status" in error ? error.status : 502;
+            return json(res, typeof status === "number" && status >= 400 && status < 600 ? status : 502, { error: "The desktop is not available. Open it again from OpenMausBot." });
+        }
+        // Inspection may outlive a closed tab or the handshake deadline.
+        if (res.destroyed || upgrade?.socket.destroyed)
+            return;
+        const live = () => deps.live(auth) && deps.target(match[1])?.key === target.key && (connection.live?.() ?? true);
+        if (!live())
+            return json(res, 401, { error: "Viewer access expired" });
+        if (!Number.isInteger(connection.port) || connection.port < 1 || connection.port > 65535) {
+            return json(res, 409, { error: "The desktop viewer is not available." });
+        }
+        if (!match[2])
+            return json(res, 200, { password: connection.password });
+        if (!upgrade)
+            return json(res, 426, { error: "WebSocket upgrade required" });
+        const key = req.headers["sec-websocket-key"];
+        if (req.headers.upgrade?.toLowerCase() !== "websocket" || req.headers["sec-websocket-version"] !== "13"
+            || typeof key !== "string" || !/^[A-Za-z0-9+/]{22}==$/.test(key)) {
+            return json(res, 400, { error: "Invalid WebSocket handshake" });
+        }
+        // Fixed host and path, port from an inspected managed container. Never
+        // forward cookies, bearer tokens, query parameters or forwarded headers.
+        const upstream = request({
+            hostname: "127.0.0.1", port: connection.port, path: "/websockify",
+            headers: { Upgrade: "websocket", Connection: "Upgrade", "Sec-WebSocket-Key": key, "Sec-WebSocket-Version": "13" },
+        });
+        const { socket } = upgrade;
+        let peer;
+        let recheck;
+        const release = connection.retain?.();
+        let closed = false;
+        const timeout = setTimeout(() => fail(), HANDSHAKE_MS);
+        timeout.unref();
+        upgrade.close = () => {
+            if (closed)
+                return;
+            closed = true;
+            release?.();
+            clearTimeout(timeout);
+            clearInterval(recheck);
+            upstream.destroy();
+            peer?.destroy();
+            socket.destroy();
+        };
+        const fail = () => {
+            if (closed)
+                return;
+            if (peer || socket.destroyed) {
+                upgrade.close();
+                return;
+            }
+            if (!res.headersSent && !socket.destroyed)
+                json(res, 502, { error: "Could not connect to the desktop viewer" });
+            upstream.destroy();
+        };
+        socket.once("close", upgrade.close);
+        upstream.once("error", fail);
+        upstream.once("response", (answer) => { answer.resume(); fail(); });
+        upstream.once("upgrade", (answer, remote, remoteHead) => {
+            const accept = createHash("sha1").update(key + WS_GUID).digest("base64");
+            if (!live() || socket.destroyed || answer.headers["sec-websocket-accept"] !== accept
+                || answer.headers.upgrade?.toLowerCase() !== "websocket") {
+                remote.destroy();
+                fail();
+                return;
+            }
+            clearTimeout(timeout);
+            peer = remote;
+            remote.once("error", upgrade.close);
+            remote.once("close", upgrade.close);
+            upgrade.release();
+            res.detachSocket(socket);
+            socket.write(`HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`);
+            if (remoteHead.length)
+                socket.write(remoteHead);
+            if (upgrade.head.length)
+                remote.write(upgrade.head);
+            upgrade.head = Buffer.alloc(0);
+            socket.pipe(remote).pipe(socket);
+            connection.touch?.();
+            recheck = setInterval(() => {
+                if (!live())
+                    upgrade.close();
+                else
+                    connection.touch?.();
+            }, RECHECK_MS);
+            recheck.unref();
+        });
+        upstream.end();
+    };
+    return {
+        route, attach,
+        closeForOwner: (owner) => { for (const upgrade of upgrades.values())
+            if (upgrade.owner === owner)
+                upgrade.close(); },
+        closeAll: () => {
+            stopped = true;
+            for (const upgrade of upgrades.values())
+                upgrade.close();
+        },
+    };
+}

package/dist-server/server/routine-requests.js

@@ -468,7 +468,7 @@ function normalizedOperation(manager, botId, validated, now) {
         ...(validated.forBot ? { forBot: validated.forBot } : {}),
     };
 }
-function asSchedule(schedule, now) {
+export function asSchedule(schedule, now) {
     if (schedule.type === "cron")
         return { ...schedule };
     if (schedule.type === "once")

package/dist-server/server/routines.js

@@ -1293,7 +1293,7 @@ export class RoutineManager {
                         ? run.groupId
                             ? this.options.createGoalTask?.(run.groupId, run.routineName) ?? null
                             : null
-                        : this.options.createTask(run.botId, run.routineName, run.triggerSource === "webhook");
+                        : this.options.createTask(run.botId, run.routineName, run.triggerSource === "webhook", run.routineId);
                 if (!task) {
                     this.failRun(run, run.target === "room-goal"
                         ? "Could not create a room task for this goal"

package/dist-server/server/sessions.js

@@ -72,9 +72,18 @@ const sessionSchema = z.object({
     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(),
+    /** A browser sign-in (PairingCode `browser`): accepted only as its browser's cookie, never as a bearer token. */
+    cookieOnly: z.literal(true).optional(),
+    /** Whose OMB Cloud a browser sign-in signed in to (its PairingCode `owner`). */
+    owner: z.string().max(254).optional(),
 });
 const fileSchema = z.object({ version: z.literal(1), sessions: z.array(sessionSchema) });
 const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/** A device's name as the sessions list shows it: what a client sent, less
+ * control and bidirectional-formatting characters. */
+function deviceLabel(value) {
+    return (value ?? "").replace(/[\p{Cc}\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/gu, "").trim();
+}
 function sameDigest(a, b) {
     const left = Buffer.from(a, "hex");
     const right = Buffer.from(b, "hex");
@@ -130,6 +139,8 @@ function publicSession(record) {
     };
     if (record.email)
         view.email = record.email;
+    if (record.owner)
+        view.owner = record.owner;
     return view;
 }
 export class SessionRegistry {
@@ -144,6 +155,8 @@ export class SessionRegistry {
     options;
     openMarker;
     closed = false;
+    /** Set on an OMB Cloud home (requireAdmin): only admin scope, anywhere. */
+    adminOnly = null;
     // No parameter properties: the server runs this file under Node's
     // strip-only TypeScript mode, which only erases types.
     constructor(options) {
@@ -252,6 +265,20 @@ export class SessionRegistry {
         for (const listener of this.onRevoked)
             listener(sessionId);
     }
+    /** From now on no pairing window, sign-in or session without admin scope
+     * is opened, redeemed, issued or accepted; `refusal` says why (an OMB
+     * Cloud home is personal: server/cloud-owner.ts). Sessions stored without
+     * it stop authenticating; the caller revokes them. */
+    requireAdmin(refusal) {
+        this.adminOnly = refusal;
+    }
+    personal(scopes) {
+        return this.adminOnly !== null && !scopes.includes("admin");
+    }
+    refusePersonal(scopes) {
+        if (this.personal(scopes))
+            throw Object.assign(new Error(this.adminOnly), { status: 403, code: "cloud_personal" });
+    }
     // ── pairing ────────────────────────────────────────────────────────────
     openPairing(input = {}) {
         this.prune();
@@ -259,6 +286,7 @@ export class SessionRegistry {
         const code = generatePairingCode();
         const credential = generatePairingCredential();
         const scopes = input.scopes?.length ? [...new Set(input.scopes)] : [...SCOPES];
+        this.refusePersonal(scopes);
         const pairing = {
             id: randomUUID(),
             codeHash: sha256(code),
@@ -267,6 +295,7 @@ export class SessionRegistry {
             label: (input.label ?? "").trim().slice(0, 80),
             createdAt: now,
             expiresAt: now + (input.ttlMs ?? PAIRING_CODE_TTL_MS),
+            ...(input.browser ? { browser: true, ...(input.owner ? { owner: input.owner } : {}) } : {}),
         };
         this.pairings.push(pairing);
         return { id: pairing.id, code, credential, expiresAt: pairing.expiresAt };
@@ -275,6 +304,17 @@ export class SessionRegistry {
         this.prune();
         return this.pairings.map((p) => ({ id: p.id, label: p.label, scopes: [...p.scopes], createdAt: p.createdAt, expiresAt: p.expiresAt }));
     }
+    /** What a browser sign-in's page shows before anything is redeemed: whose
+     * Cloud it signs in to. Only a browser sign-in's 256-bit credential can
+     * match, so this consumes nothing and counts toward no lockout. */
+    previewBrowserSignIn(credential) {
+        this.prune();
+        if (!isPairingCredential(credential))
+            return null;
+        const presented = sha256(credential);
+        const pairing = this.pairings.find((p) => p.browser === true && sameDigest(p.credentialHash, presented));
+        return pairing ? { owner: pairing.owner ?? null, expiresAt: pairing.expiresAt } : null;
+    }
     cancelPairing(id) {
         const before = this.pairings.length;
         this.pairings = this.pairings.filter((p) => p.id !== id);
@@ -313,7 +353,8 @@ export class SessionRegistry {
      * the lockout (an IP); `label` names the device in the sessions list. */
     /** `label` is what the client asked to be called; the code's own label
      * (set by whoever minted it) comes next; `fallbackLabel` (derived from the
-     * user agent) last. */
+     * user agent) last. `browser`: this is a browser sign-in (PairingCode
+     * `browser`), which redeems only a window opened for one. */
     exchange(input) {
         this.prune();
         const now = this.now();
@@ -323,8 +364,9 @@ export class SessionRegistry {
         const presented = isPairingCredential(input.code)
             ? sha256(input.code)
             : sha256(normalizePairingCode(input.code));
+        const browser = input.browser === true;
         const attemptId = typeof input.attemptId === "string" && /^[\w-]{8,64}$/.test(input.attemptId) ? input.attemptId : null;
-        const replay = attemptId ? this.replays.find((r) => r.attemptId === attemptId && sameDigest(r.codeHash, presented)) : undefined;
+        const replay = attemptId ? this.replays.find((r) => r.attemptId === attemptId && r.browser === browser && sameDigest(r.codeHash, presented)) : undefined;
         if (replay)
             return replay.result;
         const lock = this.lockState(input.source);
@@ -332,31 +374,35 @@ export class SessionRegistry {
             const seconds = Math.ceil(lock.retryAfterMs / 1000);
             return { ok: false, status: 429, error: `too many failed pairing attempts from your address; try again in ${seconds}s` };
         }
-        const index = this.pairings.findIndex((p) => sameDigest(p.codeHash, presented) || sameDigest(p.credentialHash, presented));
+        const index = this.pairings.findIndex((p) => (p.browser === true) === browser &&
+            (sameDigest(p.credentialHash, presented) || (!p.browser && sameDigest(p.codeHash, presented))));
         if (index < 0) {
             this.recordFailure(input.source);
             return { ok: false, status: 401, error: "pairing code is wrong or has expired; create a new one on the server" };
         }
         const [pairing] = this.pairings.splice(index, 1); // single use
         this.failures.delete(input.source);
+        if (this.personal(pairing.scopes))
+            return { ok: false, status: 403, error: this.adminOnly };
         const token = `omb_sess_${randomBytes(32).toString("base64url")}`;
         const record = {
             id: randomUUID(),
             tokenHash: sha256(token),
-            label: (input.label.trim() || pairing.label || input.fallbackLabel?.trim() || "Unnamed device").slice(0, 80),
+            label: (deviceLabel(input.label) || deviceLabel(pairing.label) || deviceLabel(input.fallbackLabel) || "Unnamed device").slice(0, 80),
             scopes: [...pairing.scopes],
             createdAt: now,
             lastSeenAt: now,
             // The absolute cap applies from the first term, so a TTL configured
             // longer than the cap does not hand out a session the cap forbids.
             expiresAt: now + Math.min(SESSION_TTL_MS, SESSION_MAX_AGE_MS),
+            ...(pairing.browser ? { cookieOnly: true, ...(pairing.owner ? { owner: pairing.owner } : {}) } : {}),
         };
         this.sessions.push(record);
         this.lastSeenWrites.set(record.id, now); // the exchange itself was the first sighting
         this.persist();
         const result = { ok: true, token, session: publicSession(record) };
         if (attemptId)
-            this.replays.push({ codeHash: presented, attemptId, result, expiresAt: now + EXCHANGE_REPLAY_MS });
+            this.replays.push({ codeHash: presented, attemptId, browser, result, expiresAt: now + EXCHANGE_REPLAY_MS });
         return result;
     }
     /** A session from a verified account sign-in (server/account-signin.ts)
@@ -372,13 +418,14 @@ export class SessionRegistry {
         return this.issueAccount({ label: "Hosted workspace", email: input.email, userId: `portal:${input.grant}`, scopes: input.scopes }, "portal");
     }
     issueAccount(input, membershipAuthority) {
+        this.refusePersonal(input.scopes);
         this.prune();
         const now = this.now();
         const token = `omb_sess_${randomBytes(32).toString("base64url")}`;
         const record = {
             id: randomUUID(),
             tokenHash: sha256(token),
-            label: (input.label.trim() || "Unnamed device").slice(0, 80),
+            label: (deviceLabel(input.label) || "Unnamed device").slice(0, 80),
             scopes: [...new Set(input.scopes)],
             createdAt: now,
             lastSeenAt: now,
@@ -457,7 +504,7 @@ export class SessionRegistry {
         const hash = sha256(token);
         const now = this.now();
         const record = this.sessions.find((s) => sameDigest(s.tokenHash, hash));
-        if (!record || record.expiresAt <= now)
+        if (!record || record.expiresAt <= now || this.personal(record.scopes))
             return null;
         const lastWrite = this.lastSeenWrites.get(record.id) ?? 0;
         if (now - lastWrite >= LAST_SEEN_WRITE_INTERVAL_MS) {
@@ -493,7 +540,7 @@ export class SessionRegistry {
     /** Still valid right now (prunes expiry first). */
     isLive(sessionId) {
         this.prune();
-        return this.sessions.some((s) => s.id === sessionId);
+        return this.sessions.some((s) => s.id === sessionId && !this.personal(s.scopes));
     }
     list() {
         this.prune();
@@ -529,6 +576,6 @@ export class SessionRegistry {
         this.tickets.delete(hash);
         const now = this.now();
         const record = this.sessions.find((s) => s.id === entry.sessionId);
-        return record && record.expiresAt > now ? record : null;
+        return record && record.expiresAt > now && !this.personal(record.scopes) ? record : null;
     }
 }