termdock 1.4.383 → 1.4.384

package/dist/server/agent/integrationStore.js

@@ -1,74 +1,19 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { CollaborationError } from './collaborationProtocol.js';
 import { resolveProfileNativeIdentity } from './nativeProcessIdentity.js';
+import { IntegrationJournal } from './integrationJournal.js';
+export { atomicJson } from './integrationJournal.js';
 export const INTEGRATION_PROTOCOL = 1;
-export const INTEGRATION_OPERATIONS = ['message.send', 'message.read', 'task.read', 'task.create', 'task.configure', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore', 'session.release', 'session.rename', 'session.close'];
+export const INTEGRATION_OPERATIONS = ['message.send', 'message.read', 'task.read', 'task.create', 'task.configure', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore', 'session.release', 'session.rename', 'session.close', 'session.forget', 'session.access'];
 export function integrationError(code, message, status = 400) { throw new CollaborationError(code, message, status); }
-export function atomicJson(file, value) {
-    atomicJsonText(file, JSON.stringify(value));
+const EVENT_PREFIX = Buffer.from('{"type":"event",'), NEWLINE = Buffer.from('\n');
+function positiveInteger(value, name, fallback) {
+    const raw = value ?? (process.env[name] === undefined ? fallback : Number(process.env[name]));
+    if (!Number.isSafeInteger(raw) || raw < 1)
+        integrationError('INVALID_EVENT_STORAGE_CONFIG', `${name} must be a positive safe integer`);
+    return raw;
 }
-function atomicJsonText(file, serialized) {
-    atomicJsonWrite(file, descriptor => fs.writeFileSync(descriptor, serialized));
-}
-function atomicJsonWrite(file, write) {
-    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-    const temporary = `${file}.${process.pid}.tmp`;
-    const descriptor = fs.openSync(temporary, 'w', 0o600);
-    try {
-        fs.fchmodSync(descriptor, 0o600);
-        write(descriptor);
-        fs.fsyncSync(descriptor);
-    }
-    finally {
-        fs.closeSync(descriptor);
-    }
-    fs.renameSync(temporary, file);
-    const directory = fs.openSync(path.dirname(file), 'r');
-    try {
-        fs.fsyncSync(directory);
-    }
-    finally {
-        fs.closeSync(directory);
-    }
-}
-function atomicJsonBuffers(file, parts) {
-    atomicJsonWrite(file, descriptor => {
-        let index = 0, offset = 0;
-        while (index < parts.length) {
-            // Bound vectors below platform IOV_MAX, and handle short writes without
-            // replaying or dropping any byte of the checked JSON document.
-            const vectors = parts.slice(index, index + 512);
-            if (offset)
-                vectors[0] = vectors[0].subarray(offset);
-            let written;
-            try {
-                written = fs.writevSync(descriptor, vectors);
-            }
-            catch (error) {
-                if (error.code === 'EINTR')
-                    continue;
-                throw error;
-            }
-            if (written <= 0)
-                throw new Error('Integration journal write made no progress');
-            while (index < parts.length) {
-                const available = parts[index].length - offset;
-                if (written < available) {
-                    offset += written;
-                    break;
-                }
-                written -= available;
-                index++;
-                offset = 0;
-                if (!written)
-                    break;
-            }
-        }
-    });
-}
-const JSON_OPEN = Buffer.from('{'), JSON_CLOSE = Buffer.from('}'), JSON_COMMA = Buffer.from(','), ARRAY_OPEN = Buffer.from('['), ARRAY_CLOSE = Buffer.from(']'), EVENT_PREFIX = Buffer.from('{"type":"event",'), NEWLINE = Buffer.from('\n');
 const hash = (value) => createHash('sha256').update(value).digest('hex');
 function identifier(value, label) {
     if (typeof value !== 'string' || !/^[a-zA-Z0-9._-]{1,80}$/.test(value))
@@ -115,7 +60,6 @@ export function validatePolicy(value) {
     return structuredClone({ id: value.id, groupId: value.groupId, permissions: value.permissions, launchProfiles: value.launchProfiles });
 }
 export class IntegrationStore {
-    file;
     retention;
     doc = { version: 1, principals: [], events: [], sequences: {}, prunedThrough: {}, sources: {}, consumers: {} };
     listeners = new Set();
@@ -124,27 +68,41 @@ export class IntegrationStore {
     // objects become collectible with their encodings.
     encoded = new WeakMap();
     groupEvents = new Map();
-    constructor(file, retention = 10000) {
-        this.file = file;
+    journal;
+    maxBytes;
+    maxGroupBytes;
+    warnPercent;
+    metadataWarnBytes;
+    eventBytes = 0;
+    groupBytes = new Map();
+    warning = '';
+    rejected = new Map();
+    constructor(file, retention = 10000, options = {}) {
         this.retention = retention;
-        try {
-            const document = JSON.parse(fs.readFileSync(file, 'utf8'));
-            if (document.version !== 1 || !Array.isArray(document.events) || !Array.isArray(document.principals) || !document.sources || !document.consumers || !document.sequences || !document.prunedThrough)
-                throw new Error('Invalid integration journal');
-            this.doc = document;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
+        this.maxBytes = positiveInteger(options.maxBytes, 'TERMDOCK_INTEGRATION_EVENT_MAX_BYTES', 512 * 1024 * 1024);
+        this.maxGroupBytes = positiveInteger(options.maxGroupBytes, 'TERMDOCK_INTEGRATION_EVENT_GROUP_MAX_BYTES', Math.min(this.maxBytes, 128 * 1024 * 1024));
+        this.warnPercent = positiveInteger(options.warnPercent, 'TERMDOCK_INTEGRATION_EVENT_WARN_PERCENT', 80);
+        this.metadataWarnBytes = positiveInteger(options.metadataWarnBytes, 'TERMDOCK_INTEGRATION_METADATA_WARN_BYTES', 16 * 1024 * 1024);
+        const segmentBytes = positiveInteger(options.segmentBytes, 'TERMDOCK_INTEGRATION_EVENT_SEGMENT_BYTES', 1024 * 1024);
+        if (this.warnPercent > 100 || !Number.isSafeInteger(retention) || retention < 1)
+            integrationError('INVALID_EVENT_STORAGE_CONFIG', 'Invalid warning percentage or event retention');
+        this.journal = new IntegrationJournal(file, segmentBytes);
+        this.doc = this.journal.read() ?? this.doc;
+        // Copy every legacy fact before applying the new retention policy. The
+        // original bytes remain in .v1-backup; no source identity/cursor is rebuilt.
+        this.journal.migrate(this.doc, event => this.encode(event));
+        this.eventBytes = this.doc.events.reduce((bytes, event) => bytes + this.encode(event).length + 1, 0);
         this.indexEvents();
+        this.reportCapacity();
     }
     indexEvents() {
         this.groupEvents = new Map();
+        this.groupBytes = new Map();
         for (const event of this.doc.events) {
             const events = this.groupEvents.get(event.group_id) ?? [];
             events.push(event);
             this.groupEvents.set(event.group_id, events);
+            this.groupBytes.set(event.group_id, (this.groupBytes.get(event.group_id) ?? 0) + this.encode(event).length + 1);
         }
     }
     encode(value) {
@@ -158,31 +116,14 @@ export class IntegrationStore {
         return serialized;
     }
     write(next) {
-        const parts = [JSON_OPEN];
-        for (const [index, [key, value]] of Object.entries(next).entries()) {
-            if (index)
-                parts.push(JSON_COMMA);
-            parts.push(Buffer.from(`${JSON.stringify(key)}:`));
-            if (key === 'events') {
-                parts.push(ARRAY_OPEN);
-                for (const [index, event] of next.events.entries()) {
-                    if (index)
-                        parts.push(JSON_COMMA);
-                    parts.push(this.encode(event));
-                }
-                parts.push(ARRAY_CLOSE);
-            }
-            else
-                parts.push(this.encode(value));
-        }
-        parts.push(JSON_CLOSE);
-        if (parts.reduce((bytes, part) => bytes + part.length, 0) > 64 * 1024 * 1024)
-            integrationError('EVENT_STORAGE_FULL', 'Integration journal is full; no event was acknowledged', 503);
-        atomicJsonBuffers(this.file, parts);
+        this.journal.commit(next, event => this.encode(event));
         const eventsChanged = next.events !== this.doc.events;
         this.doc = next;
-        if (eventsChanged)
+        if (eventsChanged) {
+            this.eventBytes = next.events.reduce((bytes, event) => bytes + this.encode(event).length + 1, 0);
             this.indexEvents();
+        }
+        this.reportCapacity();
         for (const listener of this.listeners) {
             try {
                 listener();
@@ -190,8 +131,103 @@ export class IntegrationStore {
             catch { /* Subscription reports its own failure. */ }
         }
     }
+    storageStatus() {
+        return { format: 'segmented-v2', event_bytes: this.eventBytes, max_event_bytes: this.maxBytes,
+            max_group_event_bytes: this.maxGroupBytes,
+            group_usage: [...this.groupBytes].map(([group_id, event_bytes]) => ({ group_id, event_bytes, events: this.groupEvents.get(group_id).length })),
+            metadata_bytes: this.journal.metadataBytes, metadata_warn_bytes: this.metadataWarnBytes,
+            warning_percent: this.warnPercent, segments: this.journal.segmentCount, events: this.doc.events.length,
+            groups: this.groupEvents.size, sources: Object.keys(this.doc.sources).length, consumers: Object.keys(this.doc.consumers).length,
+            state: this.rejected.size || this.eventBytes >= this.maxBytes || [...this.groupBytes.values()].some(bytes => bytes >= this.maxGroupBytes) ? 'full'
+                : this.eventBytes >= this.maxBytes * this.warnPercent / 100 || [...this.groupBytes.values()].some(bytes => bytes >= this.maxGroupBytes * this.warnPercent / 100)
+                    || this.journal.metadataBytes >= this.metadataWarnBytes ? 'warning' : 'ok',
+            last_rejected_event_bytes: this.rejected.size ? Math.max(...this.rejected.values()) : null,
+            blocked_groups: [...this.rejected.keys()],
+            ack_available: true, reclamation: 'confirmed_prefix_only' };
+    }
+    reportCapacity() {
+        const status = this.storageStatus(), warning = status.state === 'ok' ? '' : `${status.state}:${status.metadata_bytes >= this.metadataWarnBytes}`;
+        if (warning && warning !== this.warning)
+            console.warn('[integration-storage]', JSON.stringify(status));
+        this.warning = warning;
+    }
+    reclaim(next) {
+        // Every registered consumer of an active principal protects its unconfirmed
+        // suffix. A group without a consumer has no durable delivery promise yet.
+        const confirmed = new Map();
+        for (const principal of next.principals)
+            if (!principal.revoked) {
+                const prefix = `${principal.id}:${principal.groupId}:`;
+                for (const [key, watermark] of Object.entries(next.consumers))
+                    if (key.startsWith(prefix) && !next.consumerLifecycle?.[key]?.retired_at) {
+                        confirmed.set(principal.groupId, Math.min(confirmed.get(principal.groupId) ?? Infinity, watermark));
+                    }
+            }
+        const counts = new Map(), groupBytes = new Map(), changedGroups = new Set();
+        for (const event of next.events) {
+            counts.set(event.group_id, (counts.get(event.group_id) ?? 0) + 1);
+            groupBytes.set(event.group_id, (groupBytes.get(event.group_id) ?? 0) + this.encode(event).length + 1);
+            if (event.sequence > (this.doc.sequences[event.group_id] ?? 0))
+                changedGroups.add(event.group_id);
+        }
+        let bytes = next.events.reduce((total, event) => total + this.encode(event).length + 1, 0);
+        next.events = next.events.filter(event => {
+            const group = event.group_id, count = counts.get(group);
+            // Never discard facts from the incoming batch to make that batch fit.
+            const safe = Math.min(confirmed.get(group) ?? next.sequences[group], this.doc.sequences[group] ?? 0);
+            if (event.sequence > safe || count <= this.retention && bytes <= this.maxBytes && (!changedGroups.has(group) || groupBytes.get(group) <= this.maxGroupBytes))
+                return true;
+            counts.set(group, count - 1);
+            bytes -= this.encode(event).length + 1;
+            groupBytes.set(group, groupBytes.get(group) - this.encode(event).length - 1);
+            next.prunedThrough[group] = Math.max(next.prunedThrough[group] ?? 0, event.sequence);
+            return false;
+        });
+        if (bytes > this.maxBytes || [...changedGroups].some(group => groupBytes.get(group) > this.maxGroupBytes)) {
+            for (const group of changedGroups)
+                this.rejected.set(group, bytes);
+            this.reportCapacity();
+            integrationError('EVENT_STORAGE_FULL', 'Unconfirmed integration events exceed global/group capacity; consume and ACK existing events or increase TERMDOCK_INTEGRATION_EVENT_MAX_BYTES / TERMDOCK_INTEGRATION_EVENT_GROUP_MAX_BYTES. No source update in this group batch was committed', 503);
+        }
+    }
+    consumerStatus() {
+        return Object.entries(this.doc.consumers).map(([key, sequence]) => {
+            const principal = this.doc.principals.find(p => key.startsWith(`${p.id}:${p.groupId}:`));
+            const group = principal?.groupId, lifecycle = this.doc.consumerLifecycle?.[key];
+            return { principal_id: principal?.id ?? null, group_id: group ?? null,
+                consumer: principal ? key.slice(`${principal.id}:${principal.groupId}:`.length) : key,
+                confirmed_sequence: sequence, latest_sequence: group ? this.doc.sequences[group] ?? 0 : null,
+                lag: group ? (this.doc.sequences[group] ?? 0) - sequence : null,
+                retention_gap: group ? sequence < (this.doc.prunedThrough[group] ?? 0) : null,
+                retired_at: lifecycle?.retired_at ?? null, last_ack_at: lifecycle?.last_ack_at ?? null,
+                protects_events: !!principal && !principal.revoked && !lifecycle?.retired_at };
+        });
+    }
+    retireConsumer(principalId, consumer, expectedSequence, idempotencyKey) {
+        const principal = this.doc.principals.find(p => p.id === principalId);
+        if (!principal)
+            integrationError('INTEGRATION_NOT_FOUND', 'Integration does not exist', 404);
+        const key = this.key(principal, consumer), sequence = this.doc.consumers[key], lifecycle = this.doc.consumerLifecycle?.[key];
+        if (!Number.isSafeInteger(expectedSequence) || expectedSequence < 0 || typeof idempotencyKey !== 'string' || !idempotencyKey.trim() || idempotencyKey.length > 160)
+            integrationError('INVALID_CONSUMER_RETIREMENT', 'An expected sequence and idempotency key are required');
+        if (sequence === undefined)
+            integrationError('EVENT_CONSUMER_NOT_STARTED', 'Consumer has not started');
+        const operation = hash(idempotencyKey);
+        if (lifecycle?.retired_at) {
+            if (lifecycle.retirement_key !== operation || sequence !== expectedSequence)
+                integrationError('EVENT_CONSUMER_RETIRED', 'Consumer was already retired by a different decision', 409);
+            return { retired_at: lifecycle.retired_at, confirmed_sequence: sequence };
+        }
+        if (sequence !== expectedSequence)
+            integrationError('EVENT_CONSUMER_CHANGED', 'Consumer advanced; reread before retiring', 409);
+        const retired_at = Date.now();
+        this.write({ ...this.doc, consumerLifecycle: { ...this.doc.consumerLifecycle,
+                [key]: { ...lifecycle, retired_at, retirement_key: operation } } });
+        return { retired_at, confirmed_sequence: sequence };
+    }
     subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
     policies() { return this.doc.principals.map(({ tokenHash: _, ...principal }) => structuredClone(principal)); }
+    permits(id, permission) { return this.doc.principals.some(p => p.id === id && !p.revoked && p.permissions.includes(permission)); }
     provision(policy) {
         const checked = validatePolicy(policy);
         if (this.doc.principals.some(p => p.id === checked.id))
@@ -254,16 +290,12 @@ export class IntegrationStore {
         }
         if (!next)
             return;
-        const counts = new Map();
-        next.events = next.events.reverse().filter(event => {
-            const count = (counts.get(event.group_id) ?? 0) + 1;
-            counts.set(event.group_id, count);
-            if (count <= this.retention)
-                return true;
-            next.prunedThrough[event.group_id] = Math.max(next.prunedThrough[event.group_id] ?? 0, event.sequence);
-            return false;
-        }).reverse();
+        this.reclaim(next);
+        const changedGroups = new Set(updates.filter(update => this.doc.sources[update.sourceKey] !== update.sourceVersion).map(update => update.event.group_id));
         this.write(next);
+        for (const group of changedGroups)
+            this.rejected.delete(group);
+        this.reportCapacity();
     }
     cursor(group, sequence) { return Buffer.from(JSON.stringify({ v: 1, group, sequence })).toString('base64url'); }
     decode(group, cursor) {
@@ -282,6 +314,8 @@ export class IntegrationStore {
     selectPage(principal, consumer, cursor) {
         this.authorize(principal, 'events.read');
         const key = this.key(principal, consumer), group = principal.groupId;
+        if (this.doc.consumerLifecycle?.[key]?.retired_at)
+            integrationError('EVENT_CONSUMER_RETIRED', 'Administrator retired this consumer; reconcile and explicitly use a new consumer name', 409);
         const floor = this.doc.prunedThrough[group] ?? 0;
         // A new consumer explicitly starts at the earliest retained fact. Existing
         // consumers never silently skip a retention gap.
@@ -316,6 +350,8 @@ export class IntegrationStore {
     ack(principal, consumer, cursor) {
         this.authorize(principal, 'events.read');
         const key = this.key(principal, consumer), sequence = this.decode(principal.groupId, cursor), confirmed = this.doc.consumers[key];
+        if (this.doc.consumerLifecycle?.[key]?.retired_at)
+            integrationError('EVENT_CONSUMER_RETIRED', 'Retired consumers cannot acknowledge', 409);
         if (confirmed === undefined)
             integrationError('EVENT_CONSUMER_NOT_STARTED', 'Subscribe before acknowledging');
         if (sequence < confirmed)
@@ -325,7 +361,8 @@ export class IntegrationStore {
         // Cursor is a cumulative declaration that every preceding event is safely
         // in the bridge inbox. The subscription server separately checks it was sent.
         if (sequence !== confirmed)
-            this.write({ ...this.doc, consumers: { ...this.doc.consumers, [key]: sequence } });
+            this.write({ ...this.doc, consumers: { ...this.doc.consumers, [key]: sequence },
+                consumerLifecycle: { ...this.doc.consumerLifecycle, [key]: { ...this.doc.consumerLifecycle?.[key], last_ack_at: Date.now() } } });
         return { cursor, ack_semantics: 'durable_received' };
     }
     cursorSequence(group, cursor) { return this.decode(group, cursor); }

package/dist/server/agent/registry.js

@@ -286,7 +286,7 @@ export function inferResumeSessionId(agent, argv) {
     }
     const flags = agent.slug === 'opencode' || agent.slug === 'kimi'
         ? ['--session', '-s', '-S']
-        : ['--resume', '-r'];
+        : agent.slug === 'claude' ? ['--resume', '-r', '--session-id'] : ['--resume', '-r'];
     for (let index = 0; index < tail.length; index += 1) {
         const token = tail[index];
         if (flags.includes(token))

package/dist/server/cli.js

@@ -44,7 +44,7 @@ import { runBootChecks, formatBootCheckReport } from './utils/bootCheck.js';
 import { localAccessManager, getLanIPv4Addresses } from './utils/localAccess.js';
 import { OFFICIAL_NPM_REGISTRY, updateTermdockFromOfficialRegistry } from './utils/npmUpdate.js';
 import { DAEMON_START_TIMEOUT_MS, waitForHealth } from './utils/healthProbe.js';
-import { isProcessRunning, STOP_GRACE_MS } from './utils/termdockState.js';
+import { isProcessRunning, readLocalApiCa, STOP_GRACE_MS } from './utils/termdockState.js';
 import { recordSupervisorLost } from './utils/crashForensics.js';
 import { getTermdockVersion } from './utils/version.js';
 import { getSupervisorStatus, signalSupervisorRestart, spawnSupervisor, stopSupervisor, } from './utils/supervisorClient.js';
@@ -1276,7 +1276,7 @@ async function postLocalJson(baseUrl, token, endpoint, payload, timeoutMs = 30_0
     const body = JSON.stringify(payload);
     const isHttps = url.protocol === 'https:';
     const requestImpl = isHttps ? https.request : http.request;
-    const ca = isHttps && fs.existsSync(defaultHttpsCaPath) ? fs.readFileSync(defaultHttpsCaPath) : undefined;
+    const ca = isHttps ? readLocalApiCa(getRunningState(), defaultHttpsCaPath) : undefined;
     return new Promise((resolve, reject) => {
         const req = requestImpl({
             protocol: url.protocol,
@@ -1307,7 +1307,7 @@ async function getLocalJson(baseUrl, token, endpoint, timeoutMs = 30_000, method
     const url = new URL(endpoint, baseUrl);
     const isHttps = url.protocol === 'https:';
     const requestImpl = isHttps ? https.request : http.request;
-    const ca = isHttps && fs.existsSync(defaultHttpsCaPath) ? fs.readFileSync(defaultHttpsCaPath) : undefined;
+    const ca = isHttps ? readLocalApiCa(getRunningState(), defaultHttpsCaPath) : undefined;
     return new Promise((resolve, reject) => {
         const req = requestImpl({
             protocol: url.protocol,
@@ -2471,7 +2471,7 @@ async function runPluginRemove(slug) {
         const url = new URL(`/api/terminal/agent-plugins/${encodeURIComponent(slug)}`, baseUrl);
         const isHttps = url.protocol === 'https:';
         const requestImpl = isHttps ? https.request : http.request;
-        const ca = isHttps && fs.existsSync(defaultHttpsCaPath) ? fs.readFileSync(defaultHttpsCaPath) : undefined;
+        const ca = isHttps ? readLocalApiCa(getRunningState(), defaultHttpsCaPath) : undefined;
         const req = requestImpl({
             protocol: url.protocol,
             hostname: url.hostname,
@@ -3735,6 +3735,7 @@ async function main() {
                         host: options.host ?? DEFAULT_HOST,
                         port: options.port ?? PORT.backend,
                         scheme: result.scheme,
+                        httpsCaPath: https.ca,
                         localUrl: `${result.scheme}://${(options.host ?? DEFAULT_HOST) === '0.0.0.0' ? 'localhost' : (options.host ?? DEFAULT_HOST)}:${options.port ?? PORT.backend}`,
                         lanUrl: state.status === 'active' ? state.url : state.fallbackUrl,
                         onboardingUrl: result.getOnboardingUrl(),
@@ -3763,6 +3764,7 @@ async function main() {
             host: options.host ?? DEFAULT_HOST,
             port: options.port ?? PORT.backend,
             scheme: result.scheme,
+            httpsCaPath: https.ca,
             localUrl: `${result.scheme}://${(options.host ?? DEFAULT_HOST) === '0.0.0.0' ? 'localhost' : (options.host ?? DEFAULT_HOST)}:${options.port ?? PORT.backend}`,
             lanUrl: metadata.lanUrl,
             onboardingUrl: metadata.onboardingUrl,

package/dist/server/entry.js

@@ -522,6 +522,7 @@ export function startServer(options = {}) {
         sessionAttachmentDirectory: path.join(homedir(), '.termdock', 'chat-attachments'),
         restoreSharedSession: restoreSharedFederationSession,
         resolveSessionId: resolveStableFederationSessionId,
+        sessionAccess: () => app.locals.integrationRuntime?.sessionAccess,
         collaborationConnected: (subjectId, rpc) => {
             const channels = collaborationChannels.get(subjectId) ?? new Set();
             channels.add(rpc);
@@ -687,6 +688,7 @@ export function startServer(options = {}) {
             try {
                 const port = options.port ?? DEFAULT_PORT;
                 integration = new IntegrationRuntime({ directory: path.join(homedir(), '.termdock', 'integration-state', String(port)), socketPath: integrationSocketPath(port), adminToken: options.localApiToken,
+                    serviceId: federationServiceId,
                     messages: collaborationStore, taskStore: collaborationTaskStore, tasks: collaborationTasks, peers: collaborationService, sessions: integrationSessionAdapter });
                 await integration.listen();
                 app.locals.integrationRuntime = integration;

package/dist/server/federation/runtime.js

@@ -155,6 +155,7 @@ export async function createFederationRuntime(app, directory, handlers, options
         return Array.isArray(inventory.clientSessions) ? inventory.clientSessions : [];
     }
     async function acceptDuplex(duplex, context = {}) {
+        let sessionClaims;
         let collaborationRpc;
         let unregisterCollaboration;
         const open = (action) => openAccessAllowed(!context.relayed && context.allowOpenAccess === true, isAuthEnabled(), action);
@@ -168,8 +169,21 @@ export async function createFederationRuntime(app, directory, handlers, options
             }
         };
         const allowed = (subjectId, action, sessionId) => {
+            if (sessionClaims) {
+                const access = options.sessionAccess?.();
+                return !!access && (access.allows(sessionClaims, subjectId, action, sessionId)
+                    || !!sessionId && access.allows(sessionClaims, subjectId, action, stableSessionId(sessionId)));
+            }
             if (context.relayed && !relayPasswordConfigured())
                 return false;
+            // Scope-only invitations cannot bypass an integration's exclusive writer.
+            // Full-service maintenance access remains independent of delegated tickets.
+            if (sessionId !== undefined && !store.hasFullServiceAccess({ subjectId, serviceId })) {
+                const access = options.sessionAccess?.(), stable = stableSessionId(sessionId);
+                if (access?.restrictsNativeWriter(sessionId, action)
+                    || stable !== undefined && access?.restrictsNativeWriter(stable, action))
+                    return false;
+            }
             if (open(action) || store.authorize({ subjectId, serviceId, action, sessionId }).allowed)
                 return true;
             // The wire may still carry the transient backend PTY id while the grant
@@ -179,10 +193,13 @@ export async function createFederationRuntime(app, directory, handlers, options
             const stable = stableSessionId(sessionId);
             return stable !== undefined && store.authorize({ subjectId, serviceId, action, sessionId: stable }).allowed;
         };
-        const resources = (subjectId) => mergeShareResources(context.relayed && !relayPasswordConfigured() ? [] : store.listEffective({ subjectId, serviceId }).map(g => g.resources));
+        const grantsFor = (subjectId) => sessionClaims
+            ? (options.sessionAccess?.()?.grant(sessionClaims, subjectId) || []).map(grant => ({ ...grant, serviceId, createdAt: 0 }))
+            : store.listEffective({ subjectId, serviceId });
+        const resources = (subjectId) => mergeShareResources(context.relayed && !relayPasswordConfigured() ? [] : grantsFor(subjectId).map(g => g.resources));
         const androidAllowed = (subjectId, serial, control = false) => full(subjectId) || (control ? androidRouteAccess(resources(subjectId).android, serial) === 'control' : !!androidRouteAccess(resources(subjectId).android, serial));
         const computerAllowed = (subjectId, target) => full(subjectId) || !!computerResource(resources(subjectId), target.host, target.protocol, target.port);
-        const full = (subjectId) => (!context.relayed || relayPasswordConfigured()) && (open() || store.hasFullServiceAccess({ subjectId, serviceId }));
+        const full = (subjectId) => !sessionClaims && (!context.relayed || relayPasswordConfigured()) && (open() || store.hasFullServiceAccess({ subjectId, serviceId }));
         let channel;
         const operations = new Map();
         const sockets = new Map();
@@ -196,7 +213,7 @@ export async function createFederationRuntime(app, directory, handlers, options
             const send = (packet) => channel.send(packet);
             const check = (action, sessionId) => { if (!allowed(subjectId, action, sessionId))
                 throw new Error('AUTHORIZATION_DENIED'); };
-            const attachmentRoot = (head) => attachmentReadRoot(options.sessionAttachmentDirectory, context.relayed && !relayPasswordConfigured() ? [] : store.listEffective({ subjectId, serviceId }), id => options.resolveSessionId?.(id) || id, String(head.method), String(head.path));
+            const attachmentRoot = (head) => attachmentReadRoot(options.sessionAttachmentDirectory, context.relayed && !relayPasswordConfigured() ? [] : grantsFor(subjectId), id => options.resolveSessionId?.(id) || id, String(head.method), String(head.path));
             const httpAllowed = (head) => {
                 if (context.relayed)
                     requireRelayPassword();
@@ -290,6 +307,10 @@ export async function createFederationRuntime(app, directory, handlers, options
                 }
             }
             revokeTimer = setInterval(() => {
+                if (sessionClaims && !options.sessionAccess?.()?.valid(sessionClaims, subjectId)) {
+                    channel?.close();
+                    return;
+                }
                 if (context.relayed && !relayPasswordConfigured()) {
                     duplex.close?.(new Error('TARGET_PASSWORD_REQUIRED'));
                     return;
@@ -321,9 +342,18 @@ export async function createFederationRuntime(app, directory, handlers, options
                         throw new Error('INVALID_ID');
                     if (context.relayed)
                         requireRelayPassword();
+                    if (sessionClaims && !['permissions', 'session-list', 'http', 'upload', 'upload-end', 'ack', 'cancel', 'ws-open', 'ws-data', 'ws-close'].includes(packet.type))
+                        throw new Error('AUTHORIZATION_DENIED');
                     if (collaborationRpc?.accept(packet))
                         continue;
-                    if (packet.type === 'collaboration-connect') {
+                    if (packet.type === 'session-auth') {
+                        const access = options.sessionAccess?.();
+                        if (!access)
+                            throw new Error('SESSION_ACCESS_UNAVAILABLE');
+                        sessionClaims = access.consume(packet.ticket, subjectId);
+                        send({ type: 'result', id: packet.id, serviceId, sessionId: sessionClaims.sessionId });
+                    }
+                    else if (packet.type === 'collaboration-connect') {
                         if (!options.collaborationService || !options.collaborationConnected)
                             throw new Error('COLLABORATION_UPGRADE_REQUIRED');
                         options.collaborationService(subjectId, { type: 'collaboration-service', id: packet.id, action: 'duplex' });
@@ -355,7 +385,7 @@ export async function createFederationRuntime(app, directory, handlers, options
                         if (!origin || !packet.node || typeof packet.node !== 'object')
                             throw new Error('INVALID_COLLABORATION_PEER');
                         // The peer may only touch sessions this device can write to right now.
-                        const sessions = [...new Set(store.listEffective({ subjectId, serviceId })
+                        const sessions = [...new Set(grantsFor(subjectId)
                                 .filter(grant => grant.scope.kind === 'sessions' && grant.actions.includes('session.input'))
                                 .flatMap(grant => grant.scope.kind === 'sessions' ? grant.scope.sessionIds : []))];
                         if (!sessions.length)
@@ -429,7 +459,7 @@ export async function createFederationRuntime(app, directory, handlers, options
                         send({ type: 'result', id: packet.id, ok: true });
                     }
                     else if (packet.type === 'permissions') {
-                        const grants = store.listEffective({ subjectId, serviceId });
+                        const grants = grantsFor(subjectId);
                         send({ type: 'result', id: packet.id, subjectId, serviceId, fullService: full(subjectId), grants, httpWindow: MAX_TRANSFER_WINDOW, binaryChunks: true, relayAuthorizationErrors: true, relaySelfTargetGuard: true, webTransport: options.webTransport?.() });
                     }
                     else if (packet.type === 'session-list') {
@@ -444,7 +474,7 @@ export async function createFederationRuntime(app, directory, handlers, options
                             if (restored)
                                 inventory = await sessionInventory();
                         }
-                        const displayGrants = store.listEffective({ subjectId, serviceId }).filter(grant => grant.actions.some(action => ['session.view', 'session.chat-view', 'session.terminal-view'].includes(action))).reverse().sort((a, b) => b.createdAt - a.createdAt);
+                        const displayGrants = grantsFor(subjectId).filter(grant => grant.actions.some(action => ['session.view', 'session.chat-view', 'session.terminal-view'].includes(action))).reverse().sort((a, b) => b.createdAt - a.createdAt);
                         const seen = new Set();
                         const items = inventory.flatMap(session => {
                             const sessionId = session.backendSessionId;