termdock 1.4.233 → 1.4.234

package/dist/server/agent/collaborationService.js

@@ -0,0 +1,275 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { CollaborationError } from './collaborationProtocol.js';
+import { COLLAB_NAME_FORBIDDEN } from './collaborationPrompt.js';
+import { remoteSession, validateCollaborationNode } from './collaborationPeerTransport.js';
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const address = (id) => { if (!id.startsWith('remote:'))
+    return null; const parts = id.slice(7).split(':'); if (parts.length !== 2)
+    throw new Error('INVALID_SESSION'); return { origin: decodeURIComponent(parts[0]), id: decodeURIComponent(parts[1]) }; };
+const local = (origin, id) => { const a = address(id); return a?.origin === origin ? a.id : id; };
+const mapRoles = (value, map) => value && Object.fromEntries(Object.entries(value).map(([id, item]) => [map(id), item]));
+function mapGroup(group, map) {
+    return { ...group, sessionIds: group.sessionIds.map(map), roles: mapRoles(group.roles, map), roleVersions: mapRoles(group.roleVersions, map),
+        instructions: group.instructions && { ...group.instructions, updatedBy: map(group.instructions.updatedBy) } };
+}
+/** Sole owner of peer discovery and group replication. UI and CLI call the same
+ * local API. Pairing grants collaboration directory/group management only, never
+ * generic HTTP, filesystem access or an Agent's credentials. */
+export class CollaborationService {
+    options;
+    document = { version: 1, peers: [], offers: [] };
+    clients = new Map();
+    observations = new Map();
+    inFlight;
+    timer;
+    stopped = false;
+    constructor(options) {
+        this.options = options;
+        try {
+            const data = JSON.parse(readFileSync(options.file, 'utf8'));
+            if (data.version !== 1 || !Array.isArray(data.peers) || data.peers.length > 64 || !Array.isArray(data.offers))
+                throw new Error('INVALID_DIRECTORY');
+            for (const peer of data.peers)
+                validateCollaborationNode(peer);
+            if (data.origin)
+                validateCollaborationNode({ ...options.node(), origin: data.origin });
+            this.document = data;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    persist() {
+        mkdirSync(dirname(this.options.file), { recursive: true, mode: 0o700 });
+        const temp = `${this.options.file}.${process.pid}.tmp`;
+        writeFileSync(temp, JSON.stringify(this.document), { mode: 0o600 });
+        renameSync(temp, this.options.file);
+    }
+    node(origin = this.document.origin) { if (!origin)
+        throw new Error('COLLABORATION_ORIGIN_REQUIRED'); const node = { ...this.options.node(), origin }; validateCollaborationNode(node); return node; }
+    setOrigin(origin) { this.node(origin); if (this.document.origin && this.document.origin !== origin)
+        throw new Error('COLLABORATION_ORIGIN_MISMATCH'); this.document.origin = origin; }
+    remember(node) {
+        validateCollaborationNode(node);
+        if (node.serviceId === this.options.node().serviceId || node.origin === this.document.origin)
+            throw new Error('CANNOT_PAIR_SELF');
+        const old = this.document.peers.find(peer => peer.serviceId === node.serviceId || peer.origin === node.origin);
+        if (old && (old.serviceId !== node.serviceId || old.origin !== node.origin || old.caFingerprint256 !== node.caFingerprint256))
+            throw new Error('PEER_IDENTITY_CHANGED');
+        if (!old) {
+            if (this.document.peers.length >= 63)
+                throw new Error('PEER_LIMIT');
+            this.document.peers.push(node);
+        }
+        this.persist();
+    }
+    invite(origin) {
+        this.setOrigin(origin);
+        const code = randomBytes(32).toString('base64url'), expiresAt = Date.now() + 10 * 60_000;
+        this.document.offers = this.document.offers.filter(offer => offer.expiresAt > Date.now()).slice(-15);
+        this.document.offers.push({ hash: hash(code), expiresAt });
+        this.persist();
+        return { version: 1, node: this.node(), code, expiresAt, scope: 'collaboration-directory-and-groups' };
+    }
+    async accept(origin, invitation) {
+        if (invitation?.version !== 1 || !/^[A-Za-z0-9_-]{43}$/.test(invitation.code) || !Number.isFinite(invitation.expiresAt) || invitation.expiresAt <= Date.now())
+            throw new Error('PAIRING_EXPIRED_OR_INVALID');
+        validateCollaborationNode(invitation.node);
+        this.setOrigin(origin);
+        const rpc = await this.options.connect(invitation.node);
+        try {
+            await rpc.request({ type: 'collaboration-service', action: 'pair', code: invitation.code, node: this.node() });
+            this.remember(invitation.node);
+            void this.refresh();
+            return { ok: true, peer: invitation.node };
+        }
+        finally {
+            rpc.close();
+        }
+    }
+    receive(subject, packet) {
+        if (packet.action === 'pair') {
+            if (typeof packet.code !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(packet.code))
+                throw new Error('PAIRING_EXPIRED_OR_INVALID');
+            const codeHash = hash(packet.code);
+            const offer = this.document.offers.find(item => item.hash === codeHash && item.expiresAt > Date.now());
+            const node = packet.node;
+            validateCollaborationNode(node);
+            if (!offer || node.serviceId !== subject || offer.acceptedBy && offer.acceptedBy !== subject)
+                throw new Error('PAIRING_EXPIRED_OR_INVALID');
+            if (offer.acceptedBy && !this.document.peers.some(peer => peer.serviceId === subject))
+                throw new Error('PAIRING_REVOKED');
+            offer.acceptedBy = subject;
+            this.remember(node);
+            void this.refresh();
+            return { ok: true };
+        }
+        const peer = this.document.peers.find(node => node.serviceId === subject);
+        if (!peer)
+            throw new Error('COLLABORATION_PAIRING_REQUIRED');
+        if (packet.action === 'directory')
+            return this.snapshot(peer.origin);
+        if (packet.action === 'group') {
+            const canonical = packet.group;
+            if (!canonical?.sessionIds?.some(id => address(id)?.origin === peer.origin) && !this.document.replicas?.[canonical?.id]?.includes(peer.origin))
+                throw new Error('GROUP_SENDER_NOT_MEMBER');
+            this.merge(canonical, packet.nodes);
+            return { ok: true };
+        }
+        throw new Error('COLLABORATION_OPERATION_UNSUPPORTED');
+    }
+    nodes() { return [...new Map([...this.options.transport.registeredNodes(), ...this.document.peers, this.node()].map(node => [node.origin, node])).values()]; }
+    snapshot(peerOrigin) {
+        const origin = this.node().origin;
+        return { sessions: this.options.sessions(), groups: this.options.store.federationSnapshot().groups
+                .filter(group => group.federated && (group.sessionIds.some(id => address(id)?.origin === peerOrigin) || this.document.replicas?.[group.id]?.includes(peerOrigin)))
+                .map(group => mapGroup(group, id => address(id) ? id : remoteSession(origin, id))), nodes: this.nodes() };
+    }
+    merge(canonical, nodes) {
+        if (!canonical || typeof canonical.id !== 'string' || !canonical.id.startsWith('cross-') || !Array.isArray(canonical.sessionIds)
+            || canonical.sessionIds.length < 2 || canonical.sessionIds.length > 500 || typeof canonical.name !== 'string' || !canonical.name.trim() || COLLAB_NAME_FORBIDDEN.test(canonical.name)
+            || !Number.isFinite(canonical.updatedAt) || canonical.updatedAt > Date.now() + 60_000 || !Array.isArray(nodes) || nodes.length > 65)
+            throw new Error('INVALID_GROUP');
+        for (const node of nodes) {
+            validateCollaborationNode(node);
+            const trusted = this.document.peers.find(peer => peer.serviceId === node.serviceId || peer.origin === node.origin);
+            if (trusted && (trusted.serviceId !== node.serviceId || trusted.origin !== node.origin || trusted.caFingerprint256 !== node.caFingerprint256))
+                throw new Error('PEER_IDENTITY_CHANGED');
+        }
+        const self = this.node(), own = nodes.find(node => node.serviceId === self.serviceId);
+        if (!own || own.origin !== self.origin || own.caFingerprint256 !== self.caFingerprint256)
+            throw new Error('LOCAL_NODE_MISMATCH');
+        const existing = this.options.store.getGroup(canonical.id);
+        if ((this.document.departed?.[canonical.id] ?? -1) >= canonical.updatedAt)
+            return;
+        if (!canonical.sessionIds.some(id => address(id)?.origin === self.origin)) {
+            (this.document.departed ??= {})[canonical.id] = canonical.updatedAt;
+            this.options.store.dropFederatedReplica(canonical.id, canonical.updatedAt);
+            this.persist();
+            return;
+        }
+        const origins = [...new Set([...(this.document.replicas?.[canonical.id] ?? []), ...canonical.sessionIds.map(id => address(id)?.origin).filter((origin) => !!origin)])];
+        if (JSON.stringify(origins) !== JSON.stringify(this.document.replicas?.[canonical.id])) {
+            (this.document.replicas ??= {})[canonical.id] = origins;
+            this.persist();
+        }
+        const localIds = new Set(this.options.sessions().map(s => s.sessionId));
+        const incoming = { ...mapGroup(canonical, id => local(self.origin, id)), federated: true };
+        for (const id of incoming.sessionIds) {
+            const remote = address(id);
+            if (remote ? !nodes.some(node => node.origin === remote.origin) : !localIds.has(id) && !existing?.sessionIds.includes(id))
+                throw new Error('GROUP_MEMBER_UNAVAILABLE');
+        }
+        incoming.remoteSessions = incoming.sessionIds.filter(id => address(id)).map(id => {
+            const a = address(id);
+            const observed = this.observations.get(nodes.find(node => node.origin === a.origin).serviceId)?.sessions.find(s => s.sessionId === a.id);
+            return { ...observed, sessionId: id, name: observed?.name ?? a.id, cwd: observed?.cwd ?? '', status: 'offline', currentTask: '', capability: observed?.capability ?? '', updatedAt: observed?.updatedAt ?? 0,
+                serviceOrigin: a.origin, serviceLabel: a.origin, backendSessionId: null, agentNativeSessionId: null, agent: observed?.agent ?? null };
+        });
+        this.options.store.mergeFederatedGroup(incoming);
+        const saved = this.options.store.getGroup(incoming.id);
+        if (saved && !saved.deleted && saved.updatedAt === incoming.updatedAt)
+            this.options.transport.configure(saved.id, self.origin, nodes);
+    }
+    start() { this.timer = setInterval(() => { void this.refresh(); }, 2000); this.timer.unref(); void this.refresh(); }
+    close() { this.stopped = true; clearInterval(this.timer); for (const rpc of this.clients.values())
+        void rpc.then(client => client.close()).catch(() => { }); this.clients.clear(); }
+    async client(peer) {
+        let pending = this.clients.get(peer.serviceId);
+        if (pending && (await pending).closed) {
+            this.clients.delete(peer.serviceId);
+            pending = undefined;
+        }
+        if (!pending) {
+            pending = this.options.connect(peer);
+            this.clients.set(peer.serviceId, pending);
+        }
+        try {
+            return await pending;
+        }
+        catch (error) {
+            this.clients.delete(peer.serviceId);
+            throw error;
+        }
+    }
+    refresh() {
+        if (this.stopped || !this.document.origin)
+            return Promise.resolve();
+        return this.inFlight ??= Promise.all(this.document.peers.map(async (peer) => {
+            try {
+                const client = await this.client(peer);
+                const data = await client.request({ type: 'collaboration-service', action: 'directory' });
+                if (!Array.isArray(data.sessions) || data.sessions.length > 5000 || !Array.isArray(data.groups))
+                    throw new Error('INVALID_DIRECTORY');
+                const sessions = data.sessions.filter((s) => s && typeof s.sessionId === 'string' && !s.sessionId.startsWith('remote:'));
+                this.observations.set(peer.serviceId, { sessions, checkedAt: Date.now() });
+                for (const group of data.groups)
+                    this.merge(group, data.nodes);
+                for (const group of this.options.store.federationSnapshot().groups.filter(g => g.federated && (g.sessionIds.some(id => address(id)?.origin === peer.origin) || this.document.replicas?.[g.id]?.includes(peer.origin)))) {
+                    const canonical = mapGroup(group, id => address(id) ? id : remoteSession(this.node().origin, id));
+                    const nodes = this.nodes();
+                    if (canonical.sessionIds.some(id => !nodes.some(node => node.origin === address(id)?.origin)))
+                        continue;
+                    this.merge(canonical, nodes);
+                    await client.request({ type: 'collaboration-service', action: 'group', group: canonical, nodes });
+                }
+            }
+            catch (error) {
+                this.observations.set(peer.serviceId, { sessions: this.observations.get(peer.serviceId)?.sessions ?? [], checkedAt: Date.now(), error: error instanceof Error ? error.message.slice(0, 240) : 'PEER_UNAVAILABLE' });
+            }
+        })).then(() => { }).finally(() => { this.inFlight = undefined; });
+    }
+    directory() {
+        const known = new Set(this.document.peers.map(peer => peer.origin));
+        const missing = [...new Set(this.options.store.list().flatMap(group => group.sessionIds.map(id => address(id)?.origin).filter((origin) => !!origin && !known.has(origin))))];
+        const services = this.document.peers.map(peer => {
+            const observed = this.observations.get(peer.serviceId);
+            return { origin: peer.origin, serviceId: peer.serviceId, label: peer.origin,
+                connected: !!observed && !observed.error && Date.now() - observed.checkedAt < 15_000, error: observed?.error ?? (!observed ? 'CONNECTING' : undefined) };
+        });
+        return { protocolVersion: 2, sessions: this.document.peers.flatMap(peer => (this.observations.get(peer.serviceId)?.sessions ?? []).map(session => ({ ...session,
+                sessionId: remoteSession(peer.origin, session.sessionId), backendSessionId: null, agentNativeSessionId: null, serviceOrigin: peer.origin, serviceLabel: peer.origin,
+                serviceConnected: services.find(s => s.origin === peer.origin).connected, serviceCheckedAt: this.observations.get(peer.serviceId)?.checkedAt }))),
+            services: [...services, ...missing.map(origin => ({ origin, label: origin, connected: false, error: '两端服务尚未配对；请使用 td collab transport invite / accept 完成一次授权' }))] };
+    }
+    async save(input) {
+        const existing = input.id ? this.options.store.getGroup(input.id) : null;
+        if (input.id && (!existing || existing.deleted))
+            throw new Error('GROUP_NOT_FOUND');
+        if (existing && input.expectedUpdatedAt !== existing.updatedAt)
+            throw new CollaborationError('GROUP_CHANGED', '协作组已变化，请刷新后重试', 409);
+        if (typeof input.name !== 'string' || !input.name.trim() || COLLAB_NAME_FORBIDDEN.test(input.name) || !Array.isArray(input.sessionIds) || input.sessionIds.some(id => typeof id !== 'string') || new Set(input.sessionIds).size < 2)
+            throw new Error('INVALID_GROUP');
+        if (!input.sessionIds.some(id => address(id)) && !existing?.federated) {
+            if (input.sessionIds.some(id => !this.options.sessions().some(s => s.sessionId === id) && !existing?.sessionIds.includes(id)))
+                throw new Error('GROUP_MEMBER_UNAVAILABLE');
+            return { group: this.options.store.save(input) };
+        }
+        if (!this.document.origin)
+            throw new Error('COLLABORATION_PAIRING_REQUIRED');
+        await this.refresh();
+        if (existing && this.options.store.getGroup(existing.id)?.updatedAt !== existing.updatedAt)
+            throw new Error('GROUP_CHANGED');
+        if (!input.sessionIds.some(id => !address(id)))
+            throw new Error('GROUP_MUST_INCLUDE_LOCAL_MEMBER');
+        const available = new Set([...this.options.sessions(), ...this.directory().sessions.filter(s => s.serviceConnected)].map(s => s.sessionId));
+        if (!Array.isArray(input.sessionIds) || input.sessionIds.some(id => !available.has(id) && !existing?.sessionIds.includes(id)))
+            throw new Error('GROUP_MEMBER_UNAVAILABLE');
+        const group = { ...existing, id: existing?.federated ? existing.id : `cross-${randomBytes(16).toString('hex')}`, name: input.name,
+            sessionIds: [...new Set(input.sessionIds)], createdAt: existing?.createdAt ?? Date.now(), updatedAt: Math.max(Date.now(), (existing?.updatedAt ?? 0) + 1), federated: true };
+        const canonical = mapGroup(group, id => address(id) ? id : remoteSession(this.node().origin, id));
+        if (canonical.sessionIds.some(id => !this.nodes().some(node => node.origin === address(id)?.origin)))
+            throw new Error('COLLABORATION_PAIRING_REQUIRED');
+        // Promotion transfers history atomically to the federated group id.
+        if (existing && !existing.federated) {
+            const promoted = this.options.store.promoteGroup(existing.id, { ...group, remoteSessions: [] }, existing.updatedAt);
+            canonical.updatedAt = promoted.updatedAt;
+        }
+        this.merge(canonical, this.nodes());
+        void this.refresh();
+        return { group: this.options.store.getGroup(group.id), synchronization: 'background' };
+    }
+}

package/dist/server/agent/collaborationStore.js

@@ -404,6 +404,16 @@ export class CollaborationStore {
         const messages = this.document.messages.filter((message) => ids.has(message.groupId));
         return { groups, messages, transportDiagnostics: Object.fromEntries(messages.flatMap((message) => this.document.transport?.[message.id] ? [[message.id, this.document.transport[message.id]]] : [])) };
     }
+    /** Drop only this replica after its last local member leaves; never broadcast
+     * a global deletion of the group that still exists on other services. */
+    dropFederatedReplica(id, updatedAt) {
+        const group = this.getGroup(id);
+        if (!group?.federated || group.updatedAt > updatedAt)
+            return;
+        this.document.groups = this.document.groups.filter(item => item.id !== id);
+        this.document.messages = this.document.messages.filter(item => item.groupId !== id);
+        this.persist();
+    }
     mergeFederatedGroup(group) {
         validateFederatedGroup(group);
         const existing = this.getGroup(group.id);

package/dist/server/entry.js

@@ -1,6 +1,7 @@
+import { CollaborationService } from './agent/collaborationService.js';
 import { X509Certificate } from 'node:crypto';
 import { CollaborationPeerTransport, connectCollaborationRpc } from './agent/collaborationPeerTransport.js';
-import { collaborationStore, deliverPeerCollaboration, collaborationLocalActivity } from './routes/terminal.js';
+import { collaborationStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions } from './routes/terminal.js';
 import { setPushTargetPeerId } from './notifications/pushService.js';
 import { desktopDirectTargets } from './federation/desktopTargets.js';
 import { createOpenAccessRouter } from './federation/openAccess.js';
@@ -407,6 +408,7 @@ export function startServer(options = {}) {
         runtimeMonitor,
     });
     const { server, scheme } = createServerForApp(app, options);
+    let collaborationService;
     let collaborationTransport;
     let entrySubjectAllowed = (_subjectId) => false;
     let routeInvitations;
@@ -445,6 +447,11 @@ export function startServer(options = {}) {
     const federation = createFederationRuntime(app, path.join(homedir(), '.termdock', 'federation'), {
         terminal: handleTerminalWebSocket, control: handleControlWebSocket,
     }, {
+        collaborationService: (subjectId, packet) => {
+            if (!collaborationService)
+                throw new Error('COLLABORATION_UNAVAILABLE');
+            return collaborationService.receive(subjectId, packet);
+        },
         collaborationExchange: (subjectId, packet) => {
             if (!collaborationTransport)
                 throw new Error('COLLABORATION_UNAVAILABLE');
@@ -516,6 +523,12 @@ export function startServer(options = {}) {
             }
             catch { /* System TLS trust remains required. */ }
         app.locals.collaborationNode = { serviceId: runtime.serviceId, ...(caFingerprint256 ? { caFingerprint256 } : {}) };
+        collaborationService = new CollaborationService({ file: path.join(homedir(), '.termdock', 'federation', 'collaboration-services.json'),
+            store: collaborationStore, transport: collaborationTransport, node: () => app.locals.collaborationNode,
+            sessions: collaborationDirectorySessions, connect: peer => connectCollaborationRpc(runtime.identity, peer) });
+        app.locals.collaborationService = collaborationService;
+        collaborationService.start();
+        server.once('close', () => collaborationService?.close());
         collaborationTransport.start();
         server.once('close', () => collaborationTransport?.close());
         entrySubjectAllowed = subjectId => runtime.store.authorize({ subjectId, serviceId: runtime.serviceId, action: 'authorization.manage' }).allowed;

package/dist/server/federation/runtime.js

@@ -251,7 +251,12 @@ export async function createFederationRuntime(app, directory, handlers, options
                 try {
                     if (packet.id.length > 128)
                         throw new Error('INVALID_ID');
-                    if (packet.type === 'collaboration-exchange') {
+                    if (packet.type === 'collaboration-service') {
+                        if (!options.collaborationService)
+                            throw new Error('COLLABORATION_UPGRADE_REQUIRED');
+                        send({ type: 'result', id: packet.id, ...options.collaborationService(subjectId, packet) });
+                    }
+                    else if (packet.type === 'collaboration-exchange') {
                         if (!options.collaborationExchange)
                             throw new Error('COLLABORATION_UNAVAILABLE');
                         send({ type: 'result', id: packet.id, ...options.collaborationExchange(subjectId, packet) });

package/dist/server/routes/terminal.js

@@ -1,4 +1,3 @@
-import { assertPeerRegistrationAuthority } from '../agent/collaborationPeerTransport.js';
 import { progressRoutes } from '../notifications/progressRoutes.js';
 import { ensureNodePty } from '../utils/ensureNodePty.js';
 import { PtySpawnBackoff, PtySpawnDeferredError } from '../utils/ptySpawnBackoff.js';
@@ -39,7 +38,7 @@ import { isTmuxRecoveryCandidate } from '../utils/tmuxRecoveryCandidate.js';
 import { AutomationStore, normalizeAutomationSchedule } from '../agent/automationStore.js';
 import { buildBracketedSubmitBytes, canDeliverPromptToAgent } from '../agent/promptDelivery.js';
 import { collaborationRoutes } from '../agent/collaborationRoutes.js';
-import { COLLAB_LIMITS, extrasFromBody } from '../agent/collaborationProtocol.js';
+import { extrasFromBody } from '../agent/collaborationProtocol.js';
 import { CollaborationStore } from '../agent/collaborationStore.js';
 import { COLLAB_NAME_FORBIDDEN, formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
 import { ambiguousIdMessage } from '../agent/collaborationProtocol.js';
@@ -5476,24 +5475,19 @@ router.delete('/operations/automations/:automationId', (req, res) => {
         return res.status(404).json({ error: '自动任务不存在' });
     res.status(204).send();
 });
-// Authenticated desktop connections exchange only collaboration data; no peer credentials
-// or arbitrary remote URLs are accepted by the server.
-router.get('/operations/collaboration-federation', (req, res) => {
-    res.json({ protocolVersion: 2, serverTransport: req.app.locals.collaborationNode, limits: COLLAB_LIMITS, ...collaborationStore.federationSnapshot(),
-        sessions: globalSessionState.sessions.map(orchestrationSessionSnapshot) });
+// The old native/browser relay may still poll after a CLI-only upgrade. It
+// receives a fast, explicit refusal and cannot duplicate the server worker.
+router.all(['/operations/collaboration-federation', '/operations/collaboration-peers'], (_req, res) => {
+    res.status(410).json({ code: 'CLIENT_RELAY_REMOVED', error: '协作由服务端处理，请重新加载服务页面' });
 });
-router.post('/operations/collaboration-peers', (req, res) => {
-    try {
-        assertPeerRegistrationAuthority(req);
-        if (!req.app.locals.collaborationTransport)
-            return res.status(503).json({ error: 'COLLABORATION_UNAVAILABLE' });
-        req.app.locals.collaborationTransport.configure(req.body.groupId, req.body.localOrigin, req.body.nodes);
-        res.json({ ok: true });
-    }
-    catch (error) {
-        res.status(400).json({ error: getErrorMessage(error) });
-    }
+router.get('/operations/collaboration-directory', (req, res) => {
+    const service = req.app.locals.collaborationService;
+    if (!service)
+        return res.status(503).json({ error: '协作服务正在启动，请稍后重试' });
+    void service.refresh();
+    res.json(service.directory());
 });
+export function collaborationDirectorySessions() { return globalSessionState.sessions.map(orchestrationSessionSnapshot); }
 export function collaborationLocalActivity() {
     return globalSessionState.sessions.map(record => {
         const backendId = collaborationRouting.get(record.sessionId)?.backendSessionId ?? record.backendSessionId;
@@ -5502,45 +5496,13 @@ export function collaborationLocalActivity() {
     });
 }
 export function deliverPeerCollaboration(sessionId) { void tryDeliverCollaborationInbox(sessionId); }
-router.post('/operations/collaboration-federation', (req, res) => {
-    try {
-        const group = req.body?.group;
-        if (!group || !Array.isArray(group.remoteSessions))
-            throw new Error('跨服务工作组无效');
-        const remoteIds = new Set(group.remoteSessions.map((session) => session.sessionId));
-        const localIds = new Set(globalSessionState.sessions.map((session) => session.sessionId));
-        const existing = collaborationStore.getGroup(group.id);
-        if (req.body.expectedUpdatedAt !== undefined && req.body.expectedUpdatedAt !== existing?.updatedAt) {
-            return res.status(409).json({ code: 'GROUP_CHANGED', error: '协作组已被修改，请重新打开成员管理后再保存' });
-        }
-        const retainedIds = new Set(existing?.sessionIds ?? []);
-        if (!group.deleted && group.sessionIds.some((id) => !localIds.has(id) && !remoteIds.has(id) && !retainedIds.has(id))) {
-            throw new Error('工作组包含不存在的本服务会话，请刷新成员列表');
-        }
-        collaborationStore.mergeFederatedGroup(group);
-        collaborationStore.mergeFederatedMessages(Array.isArray(req.body.messages) ? req.body.messages : []);
-        const fragments = Array.isArray(req.body.fragments) ? req.body.fragments : [];
-        if (fragments.length > 25 || fragments.some((fragment) => fragment.group_id !== group.id))
-            throw new Error('无效消息分片');
-        const fragmentReceipts = fragments.map((fragment) => collaborationStore.acceptFragment(fragment));
-        for (const entry of Array.isArray(req.body.transport) ? req.body.transport : []) {
-            if (collaborationStore.getMessage(entry.message_id)?.groupId !== group.id || !entry.diagnostic || !Number.isFinite(entry.diagnostic.checked_at) || !Number.isInteger(entry.diagnostic.attempt_count) || entry.diagnostic.attempt_count < 0)
-                continue;
-            collaborationStore.recordTransport(entry.message_id, entry.diagnostic);
-            if (entry.failure_reason)
-                collaborationStore.fail(entry.message_id, entry.failure_reason);
-        }
-        for (const id of group.sessionIds)
-            if (localIds.has(id))
-                tryDeliverCollaborationInbox(id);
-        res.json({ protocolVersion: 2, ...collaborationStore.federationSnapshot(), fragmentReceipts });
-    }
-    catch (error) {
-        res.status(400).json({ error: getErrorMessage(error) });
-    }
-});
 router.use('/operations', collaborationGroupRoutes({ store: collaborationStore,
-    sessions: () => globalSessionState.sessions.map(orchestrationSessionSnapshot) }));
+    sessions: () => globalSessionState.sessions.map(orchestrationSessionSnapshot),
+    save: (req, input) => {
+        if (!req.app.locals.collaborationService)
+            throw new Error('COLLABORATION_UNAVAILABLE');
+        return req.app.locals.collaborationService.save(input);
+    } }));
 /** Group id from a URL param: the short id a terminal shows resolves to
  *  its full id, an ambiguous prefix is refused with 409, and anything else is
  *  simply "no such group" — the same 404 each route already answers. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.233",
+  "version": "1.4.234",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.233",
+  "version": "1.4.234",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-GHB6P5NPYFEdDR/sPm0FHVSEBdpzcJ8Jghr5X2uikWU=",
-  "clientBundleHash": "sha256-QvAwqyw8+TgNqMDTtWnsp5gbsoE5RiJyCfPonVL0aX4=",
+  "serverBundleHash": "sha256-nhvsmvXOZsSAZPmQTztOUo074PRH4RrLqcMhe5r4kKk=",
+  "clientBundleHash": "sha256-NULxnbzNlpIXlrOpTKR4KD9KY3y5ekC2/dn3VWl6AcE=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }