Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: revoke Eidoverse guest visitor grants when a visit ends (#12494)

[._.]/ Adam Eivyea9df86d0f6b
diff --git a/docs/decisions/2026-09-05-eidoverse-guest-chat.md b/docs/decisions/2026-09-05-eidoverse-guest-chat.md
index 6f141f0675..d0331fc6f4 100644
--- a/docs/decisions/2026-09-05-eidoverse-guest-chat.md
+++ b/docs/decisions/2026-09-05-eidoverse-guest-chat.md
@@ -33,7 +33,7 @@ The resident grants an unused identity `visitor` with generation disabled
before entry. Named admission preserves the source human or CoS in-world handle
when available, adding a bounded numeric suffix for occupied names. Existing
roles and entities are never reused or downgraded. Missing or reserved handles
-retain the opaque guest fallback. Handles travel only in explicit admission
+retain the opaque guest fallback. When a visit ends (leave, session expiry, or a failed admission) the resident clears the guest's role with `grant` `role: null`, since the world has no revoke verb; a failed revoke is logged and retried once at the next admission. Handles travel only in explicit admission
bodies, never status/capability payloads. The renderer's explicit guest protocol ignores an existing browser
login, refuses missing visitor grants and ownerless worlds, and restricts
snapshot/scrollback chat to the visit's admission sequence. Guest debug history
diff --git a/server/services/eidoverseTravel.js b/server/services/eidoverseTravel.js
index 5c082b7751..39e2f829c3 100644
--- a/server/services/eidoverseTravel.js
+++ b/server/services/eidoverseTravel.js
@@ -8,7 +8,7 @@ import { eidoverseChatResultSchema } from '../lib/eidoverseValidation.js';
import { getPeers } from './instances.js';
import { getInstanceFeatures } from './instanceFeatures.js';
import { ensureEidoverseHost } from './eidoverseHost.js';
-import { admitEidoverseGuest, ensureEidoverseWorldConfig, supportsEidoverseGuestEntry, getEidoverseWorldStatus } from './eidoverseWorld.js';
+import { admitEidoverseGuest, revokeEidoverseGuest, ensureEidoverseWorldConfig, supportsEidoverseGuestEntry, getEidoverseWorldStatus } from './eidoverseWorld.js';
import { eidoversePeerId } from '../lib/eidoverseWorldSignals.js';
import { EIDOVERSE_MANAGED_PREFIX } from '../lib/eidoverseWorldDesign.js';
@@ -24,6 +24,7 @@ const closeSession = async (sessions, key) => {
sessions.delete(key);
clearTimeout(session?.timer);
await session?.connection?.close();
+ if (session?.identity) await revokeEidoverseGuest(session.identity);
};
const remember = (sessions, key, session) => {
session.expiresAt = Date.now() + TTL;
diff --git a/server/services/eidoverseTravel.test.js b/server/services/eidoverseTravel.test.js
index b3ead343c2..92ef2938b0 100644
--- a/server/services/eidoverseTravel.test.js
+++ b/server/services/eidoverseTravel.test.js
@@ -2,12 +2,12 @@ import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vites
import express from 'express';
import { once } from 'node:events';
-const mocks = vi.hoisted(() => ({ peers: [], feature: true, protocol: true, connections: [], admission: vi.fn() }));
+const mocks = vi.hoisted(() => ({ peers: [], feature: true, protocol: true, connections: [], admission: vi.fn(), revoke: vi.fn(async () => {}) }));
vi.mock('./instances.js', () => ({ getPeers: async () => mocks.peers }));
vi.mock('./instanceIdentity.js', () => ({ getInstanceId: async () => 'origin-instance', UNKNOWN_INSTANCE_ID: 'unknown' }));
vi.mock('./instanceFeatures.js', () => ({ getInstanceFeatures: async () => ({ features: [{ id: 'eidoverse', enabled: mocks.feature }] }) }));
vi.mock('./eidoverseHost.js', () => ({ ensureEidoverseHost: async () => ({ protocol: 'http', port: 5563, running: true }) }));
-vi.mock('./eidoverseWorld.js', () => ({ ensureEidoverseWorldConfig: async () => ({ human: { name: 'Example Human' }, cos: { id: 'Example Mind' } }), supportsEidoverseGuestEntry: async () => mocks.protocol, getEidoverseWorldStatus: async () => ({ setup: { installed: true, runtimeStatus: 'online', worldDataReady: true }, cos: { enabled: true } }), admitEidoverseGuest: (...args) => mocks.admission(...args) }));
+vi.mock('./eidoverseWorld.js', () => ({ ensureEidoverseWorldConfig: async () => ({ human: { name: 'Example Human' }, cos: { id: 'Example Mind' } }), supportsEidoverseGuestEntry: async () => mocks.protocol, getEidoverseWorldStatus: async () => ({ setup: { installed: true, runtimeStatus: 'online', worldDataReady: true }, cos: { enabled: true } }), admitEidoverseGuest: (...args) => mocks.admission(...args), revokeEidoverseGuest: (...args) => mocks.revoke(...args) }));
import router from '../routes/eidoverseTravelRoutes.js';
import { eidoversePeerId } from '../lib/eidoverseWorldSignals.js';
@@ -38,6 +38,7 @@ beforeEach(() => {
mocks.protocol = true;
destination = { id: 'destination-peer', instanceId: 'destination-instance', address: '127.0.0.1', port: server.address().port, name: 'Example destination', status: 'online', enabled: true };
mocks.peers = [destination, { id: 'origin-peer', instanceId: 'origin-instance', status: 'offline', enabled: true }];
+ mocks.revoke.mockClear();
mocks.admission.mockReset().mockImplementation(async ({ agent }) => {
const messages = [];
const identity = { world: 'example-world', name: 'guest-example', avatar: 'eidoverse/assets/vrms/claude.vrm' };
@@ -121,6 +122,20 @@ describe('registered-peer Eidoverse guest workflow over HTTP', () => {
expect((await post('/chat', { sessionId: admission.sessionId, text: 'x'.repeat(2001) })).status).toBe(400);
await receiveEidoverseLeave('origin-instance', { sessionId: admission.sessionId });
await receiveEidoverseLeave('origin-instance', { sessionId: ticket });
+ expect(mocks.revoke).toHaveBeenCalledTimes(2);
+ expect(mocks.revoke).toHaveBeenCalledWith({ world: 'example-world', name: 'guest-example', avatar: 'eidoverse/assets/vrms/claude.vrm' });
+ });
+
+ it('revokes the guest grant when an unreleased session expires', async () => {
+ vi.useFakeTimers();
+ try {
+ await post('/visit', { agent: true });
+ await vi.advanceTimersByTimeAsync(30 * 60 * 1000 + 1);
+ expect(mocks.revoke).toHaveBeenCalledOnce();
+ expect(mocks.connections.at(-1).close).toHaveBeenCalledOnce();
+ } finally {
+ vi.useRealTimers();
+ }
});
it('omits the name for an older peer with strict admission validation', async () => {
diff --git a/server/services/eidoverseWorld.js b/server/services/eidoverseWorld.js
index 0bb9add55f..79b208fc7d 100644
--- a/server/services/eidoverseWorld.js
+++ b/server/services/eidoverseWorld.js
@@ -2067,8 +2067,9 @@ function normalizeAugmentOperation(operation) {
const id = validEntityId(args.id);
const normalized = { id };
if (args.role !== undefined) {
- if (!['owner', 'builder', 'visitor'].includes(args.role)) {
- throw new ServerError('grant.role must be owner, builder, or visitor.', { status: 400, code: 'EIDOVERSE_ARGUMENT_INVALID' });
+ // null clears the role: the world has no revoke verb (guest revocation).
+ if (args.role !== null && !['owner', 'builder', 'visitor'].includes(args.role)) {
+ throw new ServerError('grant.role must be owner, builder, visitor, or null.', { status: 400, code: 'EIDOVERSE_ARGUMENT_INVALID' });
}
normalized.role = args.role;
}
@@ -2286,8 +2287,43 @@ export async function closeEidoverseWorldConnections() {
return worldLock(() => closeCosPresenceInternal());
}
-export const __resetEidoverseWorldForTests = closeEidoverseWorldConnections;
+export const __resetEidoverseWorldForTests = async () => {
+ pendingGuestRevokes.clear();
+ return closeEidoverseWorldConnections();
+};
+
+// Guest grants whose revoke failed; retried once on the next world-lock acquisition.
+const pendingGuestRevokes = new Map();
+
+/** Strip a guest's role. Caller holds worldLock. A failure is logged and queued for one retry. */
+async function revokeGuestGrant(presence, { world, name }, { verbIntervalMs, retry = false } = {}) {
+ const key = `${world}\0${name}`;
+ if (presence.connection.world !== world) {
+ pendingGuestRevokes.delete(key);
+ return;
+ }
+ await sendPacedVerb(presence.connection, 'grant', { id: name, role: null }, { pacing: presence.pacing, verbIntervalMs }).then(
+ () => pendingGuestRevokes.delete(key),
+ (error) => {
+ console.error(`❌ Eidoverse guest revoke failed${retry ? ' on retry' : ''}: ${error.message}`);
+ if (retry) pendingGuestRevokes.delete(key);
+ else pendingGuestRevokes.set(key, { world, name });
+ },
+ );
+}
+
+/** Remove a departed guest's visitor role so repeated visits cannot accumulate grants. */
+export async function revokeEidoverseGuest(identity) {
+ if (!identity?.name || !identity.world) return;
+ return worldLock(async () => {
+ const presence = await ensureCosPresenceInternal();
+ await revokeGuestGrant(presence, identity);
+ }).catch((error) => {
+ pendingGuestRevokes.set(`${identity.world}\0${identity.name}`, { world: identity.world, name: identity.name });
+ console.error(`❌ Eidoverse guest revoke failed: ${error.message}`);
+ });
+}
/** Guest admission happens through the owner before any guest joins. */
export async function admitEidoverseGuest({ agent = false, name, verbIntervalMs } = {}) {
@@ -2300,6 +2336,7 @@ export async function admitEidoverseGuest({ agent = false, name, verbIntervalMs
const desiredName = validIdentity(name, '');
const usableName = desiredName && scrubSecretTokens(desiredName) === desiredName
&& presence.snapshot?.state?.roles;
+ for (const pending of [...pendingGuestRevokes.values()]) await revokeGuestGrant(presence, pending, { verbIntervalMs, retry: true });
const baseName = usableName ? desiredName : `guest-${randomUUID()}`;
let id = baseName;
for (let suffix = 2; presence.connection.hasIdentity(id); suffix += 1) {
@@ -2315,11 +2352,14 @@ export async function admitEidoverseGuest({ agent = false, name, verbIntervalMs
const connection = createWorldConnection({ world: identity.world, id, avatar: identity.avatar, agent: true, guest: true });
return connection.waitForSnapshot().then(async (snapshot) => {
if (snapshot.yourRights?.role !== 'visitor' || snapshot.yourRights?.gen || snapshot.yourRights?.open) {
- await connection.close();
throw new ServerError('The world did not confirm visitor access.', { status: 409, code: 'EIDOVERSE_GUEST_ROLE_INVALID' });
}
return { identity, connection };
- }).catch((error) => connection.close().then(() => { throw error; }));
+ }).catch(async (error) => {
+ await connection.close();
+ await revokeGuestGrant(presence, identity, { verbIntervalMs });
+ throw error;
+ });
});
}
diff --git a/server/services/eidoverseWorld.runtime.test.js b/server/services/eidoverseWorld.runtime.test.js
index c4d69a1eea..b873330753 100644
--- a/server/services/eidoverseWorld.runtime.test.js
+++ b/server/services/eidoverseWorld.runtime.test.js
@@ -149,7 +149,9 @@ vi.mock('ws', () => {
}
if (message.type === 'verb') {
const state = mocks.worlds.get(this.world);
- if (message.verb === 'grant') {
+ if (message.verb === 'grant' && message.args.role === null) {
+ delete state.roles[message.args.id];
+ } else if (message.verb === 'grant') {
state.roles[message.args.id] = {
...(state.roles[message.args.id] || {}),
...(message.args.role ? { role: message.args.role } : {}),
@@ -1303,6 +1305,28 @@ it('admits a visitor before joining and exposes only new live chat to both guest
});
+it('revokes a departed guest role, retries a failed revoke once, and revokes on failed admission', async () => {
+ await world.ensureEidoverseWorldPresence();
+ const roles = mocks.worlds.get('portos').roles;
+ const guest = await world.admitEidoverseGuest({ agent: true, name: 'Example Explorer' });
+ expect(roles['Example Explorer']).toMatchObject({ role: 'visitor' });
+ await guest.connection.close();
+ await world.revokeEidoverseGuest(guest.identity);
+ expect(roles['Example Explorer']).toBeUndefined();
+
+ const browser = await world.admitEidoverseGuest({ name: 'Example Browser' });
+ mocks.rejectVerb = 'grant';
+ mocks.rejectedVerb = false;
+ const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+ await world.revokeEidoverseGuest(browser.identity);
+ expect(error).toHaveBeenCalled();
+ error.mockRestore();
+ await world.admitEidoverseGuest({ name: 'Example Next' });
+ const revokes = mocks.sent.filter((entry) => entry.verb === 'grant' && entry.args.id === 'Example Browser' && entry.args.role === null);
+ expect(revokes.length).toBeGreaterThanOrEqual(2);
+ expect(roles['Example Browser']).toBeUndefined();
+});
+
it('keeps occupied identities intact and disambiguates repeated browser admissions', async () => {
await world.ensureEidoverseWorldPresence();
const roles = mocks.worlds.get('portos').roles;