termdock 1.4.230 → 1.4.232

package/dist/server/agent/collaborationStore.js

@@ -1,7 +1,14 @@
+import { plainCollaborationSnapshot } from './collaborationText.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { COLLAB_LIMITS, CollaborationError, STATUS_RANK, canonicalShortId, drawCollaborationId, newCollaborationId, resolveIdPrefix, validateExtras } from './collaborationProtocol.js';
+function newerRevision(a, b) {
+    return !b || a.updatedAt > b.updatedAt || (a.updatedAt === b.updatedAt && a.version > b.version);
+}
+function validRevision(value) {
+    return !!value && Number.isSafeInteger(value.updatedAt) && value.updatedAt >= 0 && typeof value.version === 'string' && /^[a-zA-Z0-9-]{1,80}$/.test(value.version);
+}
 /** Characters that would corrupt a role line injected into the delivery shell
  * (`你的定位:...`) or smuggle terminal output. Unlike names, roles are plain
  * prose — 「」 and · are harmless there — so only control sequences are barred. */
@@ -21,11 +28,29 @@ function pruneRoles(group, sessionIds) {
     const roles = Object.fromEntries(Object.entries(group.roles).filter(([id]) => sessionIds.includes(id)));
     return Object.keys(roles).length ? { ...group, roles } : { ...group, roles: undefined };
 }
+/** Public collaboration facts never expose legacy read guesses. */
+export function terminalMessage(message, raw = false) {
+    const { readAt: _readAt, readSource: _readSource, ...body } = message;
+    const legacyConsumption = message.deliverySource === 'consumer_read';
+    return { ...body, status: legacyConsumption ? 'pending' : message.status === 'read' ? 'delivered' : message.status,
+        deliveredAt: legacyConsumption ? null : message.deliveredAt,
+        deliverySource: legacyConsumption ? undefined : message.deliverySource,
+        snapshot: message.snapshot ? (raw ? message.snapshot : plainCollaborationSnapshot(message.snapshot)) : null };
+}
 const MAX_MESSAGES = 2_000;
 const MESSAGE_KINDS = new Set(['message', 'ask', 'reply', 'task', 'handoff', 'done']);
 export class CollaborationStore {
     filePath;
     drawId;
+    onMessageQueued;
+    peerActivity = new Map();
+    recordPeerActivity(sessionId, outputAt, observedAt) {
+        if (this.peerActivity.size >= 2000 && !this.peerActivity.has(sessionId))
+            this.peerActivity.delete(this.peerActivity.keys().next().value);
+        this.peerActivity.set(sessionId, { last_terminal_output_at: typeof outputAt === 'number' && Number.isFinite(outputAt) && outputAt > 0 ? outputAt : null,
+            activity_observed_at: typeof observedAt === 'number' && Number.isFinite(observedAt) ? observedAt : null,
+            last_peer_sync_at: Date.now(), activity_source: 'remote_terminal_output' });
+    }
     document = { version: 2, groups: [], messages: [] };
     persistedDocument = JSON.stringify(this.document);
     /** `drawId` is the random source behind newCollaborationId. It is a
@@ -128,9 +153,11 @@ export class CollaborationStore {
         else
             delete roles[input.sessionId];
         const updated = { ...group, roles: Object.keys(roles).length ? roles : undefined,
+            roleVersions: { ...group.roleVersions, [input.sessionId]: { version: crypto.randomUUID(), updatedAt: Math.max(Date.now(), (group.roleVersions?.[input.sessionId]?.updatedAt ?? 0) + 1) } },
             updatedAt: Math.max(Date.now(), group.updatedAt + 1) };
         this.document.groups = this.document.groups.map((candidate) => candidate.id === group.id ? updated : candidate);
         this.persist();
+        queueMicrotask(() => this.onMessageQueued?.());
         return updated;
     }
     remove(id) {
@@ -175,6 +202,55 @@ export class CollaborationStore {
         };
         this.persist();
     }
+    setRules(groupId, text, updatedBy, expectedVersion) {
+        const group = this.getGroup(groupId);
+        if (!group || group.deleted || !group.sessionIds.includes(updatedBy))
+            throw new CollaborationError('NOT_A_MEMBER', '只能修改当前协作组的约定', 403);
+        if (expectedVersion !== undefined && expectedVersion !== (group.instructions?.version ?? ''))
+            throw new CollaborationError('RULES_CHANGED', '群规已更新，请重新读取后再修改', 409);
+        if (typeof text === 'string')
+            text = text.replace(/\r\n?/g, '\n');
+        if (typeof text !== 'string' || Buffer.byteLength(text) > 8192 || /[\x00-\x08\x0b-\x1f\x7f]/.test(text))
+            throw new CollaborationError('INVALID_RULES', '群规最多 8192 UTF-8 字节，不允许终端控制字符');
+        const instructions = { text, updatedBy, version: crypto.randomUUID(), updatedAt: Math.max(Date.now(), (group.instructions?.updatedAt ?? 0) + 1) };
+        group.instructions = instructions;
+        group.updatedAt = Math.max(Date.now(), group.updatedAt + 1);
+        this.persist();
+        queueMicrotask(() => this.onMessageQueued?.());
+        return instructions;
+    }
+    context(groupId) {
+        const group = this.getGroup(groupId);
+        return group ? { instructions: group.instructions, roles: group.roles, roleVersions: group.roleVersions } : {};
+    }
+    mergeContext(groupId, context) {
+        const group = this.getGroup(groupId);
+        if (!group || group.deleted || !context || typeof context !== 'object')
+            return;
+        let changed = false;
+        const rules = context.instructions;
+        if (rules && validRevision(rules) && typeof rules.text === 'string' && Buffer.byteLength(rules.text) <= 8192
+            && !/[\x00-\x08\x0b-\x1f\x7f]/.test(rules.text) && typeof rules.updatedBy === 'string'
+            && group.sessionIds.includes(rules.updatedBy) && newerRevision(rules, group.instructions)) {
+            group.instructions = { ...rules };
+            changed = true;
+        }
+        for (const [id, revision] of Object.entries(context.roleVersions ?? {})) {
+            if (!group.sessionIds.includes(id) || !validRevision(revision) || !newerRevision(revision, group.roleVersions?.[id]))
+                continue;
+            const role = context.roles?.[id];
+            if (role !== undefined && typeof role !== 'string')
+                continue;
+            (group.roleVersions ??= {})[id] = revision;
+            if (role)
+                (group.roles ??= {})[id] = sanitizeCollaborationRole(role);
+            else if (group.roles)
+                delete group.roles[id];
+            changed = true;
+        }
+        if (changed)
+            this.persist();
+    }
     removeSession(sessionId) {
         const affected = this.document.groups.filter((group) => group.sessionIds.includes(sessionId));
         if (affected.length === 0)
@@ -241,7 +317,7 @@ export class CollaborationStore {
             toSessionId, kind: input.kind, content, threadId,
             fanOutIds: recipients.length > 1 ? recipients.filter((id) => id !== toSessionId) : undefined,
             replyTo: input.replyTo?.trim() || null, status: 'pending', createdAt: now,
-            deliveredAt: null, readAt: null,
+            deliveredAt: null, readAt: null, instructions: group.instructions ? { ...group.instructions } : undefined,
         }));
         if (messages.some((message) => Buffer.byteLength(JSON.stringify(message)) > COLLAB_LIMITS.wire_bytes))
             throw new CollaborationError('MESSAGE_WIRE_TOO_LARGE', `Encoded message exceeds ${COLLAB_LIMITS.wire_bytes} JSON bytes`, 413);
@@ -249,6 +325,7 @@ export class CollaborationStore {
         if (key)
             (this.document.idempotency ??= {})[key] = { hash, ids: messages.map((message) => message.id), expiresAt: now + COLLAB_LIMITS.idempotency_retention_ms };
         this.persist();
+        queueMicrotask(() => this.onMessageQueued?.());
         return messages;
     }
     listMessages(groupId, limit = 200) {
@@ -332,7 +409,10 @@ export class CollaborationStore {
         const existing = this.getGroup(group.id);
         if (existing && (!existing.federated || existing.updatedAt > group.updatedAt))
             return;
-        this.document.groups = [...this.document.groups.filter((item) => item.id !== group.id), group];
+        const priorContext = existing ? this.context(group.id) : undefined;
+        this.document.groups = [...this.document.groups.filter((item) => item.id !== group.id), { ...group }];
+        if (priorContext)
+            this.mergeContext(group.id, priorContext);
         if (group.deleted)
             this.document.messages = this.document.messages.filter((item) => item.groupId !== group.id);
         this.persist();
@@ -402,6 +482,11 @@ export class CollaborationStore {
                     changed = true;
                 }
             }
+            if (index >= 0 && rank[message.status] >= rank[this.document.messages[index].status]
+                && typeof message.snapshot === 'string' && message.snapshot && this.document.messages[index].snapshot !== message.snapshot) {
+                this.document.messages[index].snapshot = message.snapshot.slice(0, 16000);
+                changed = true;
+            }
             if (index >= 0 && rank[message.status] > rank[this.document.messages[index].status]) {
                 const existing = this.document.messages[index];
                 // A receipt may advance status, but never rewrite an existing message.
@@ -443,21 +528,26 @@ export class CollaborationStore {
     }
     diagnostic(id) { return this.document.transport?.[id] ?? null; }
     recordTransport(id, diagnostic) {
-        if (!this.getMessage(id))
+        if (!this.getMessage(id) || (this.document.transport?.[id]?.checked_at ?? 0) > diagnostic.checked_at)
             return;
         (this.document.transport ??= {})[id] = diagnostic;
         this.persist();
     }
-    receipt(id) {
+    receipt(id, raw = false) {
         const message = this.getMessage(id);
         if (!message)
             throw new CollaborationError('MESSAGE_NOT_FOUND', 'Message not found or no longer retained', 404);
         const replies = this.document.messages.filter((reply) => reply.replyTo === id && reply.fromSessionId === message.toSessionId && reply.toSessionId === message.fromSessionId);
         const diagnostic = this.diagnostic(id);
-        return { message_id: id, thread_id: message.threadId, status: message.status, queued_at: message.createdAt,
-            delivered_at: message.deliveredAt, read_at: message.readAt, expires_at: message.expiresAt ?? null,
-            failure_reason: message.failureReason ?? null, delivery_semantics: message.deliverySource ?? (message.deliveredAt === null ? 'not_delivered' : 'legacy_or_unspecified'), read_semantics: message.readAt ? message.readSource ?? 'legacy_or_unspecified' : 'not_read',
-            snapshot: message.snapshot ?? null,
+        const facts = terminalMessage(message, raw);
+        return { message_id: id, thread_id: message.threadId, status: facts.status, queued_at: message.createdAt,
+            delivered_at: facts.deliveredAt, expires_at: message.expiresAt ?? null,
+            failure_reason: message.failureReason ?? null, delivery_semantics: facts.deliverySource ?? (facts.deliveredAt === null ? 'not_delivered' : 'legacy_or_unspecified'),
+            snapshot: message.snapshot ? (raw ? message.snapshot : plainCollaborationSnapshot(message.snapshot)) : null,
+            delivery: { status: facts.status,
+                stage: facts.deliveredAt !== null ? 'terminal_written' : diagnostic?.remote_received_at ? 'remote_received' : 'queued',
+                remote_received_at: diagnostic?.remote_received_at ?? null, delivered_at: facts.deliveredAt, error: message.failureReason ?? diagnostic?.last_error ?? null },
+            reply: { status: replies.length ? 'received' : 'pending', ack_at: replies.find(reply => reply.responseKind === 'ack')?.createdAt ?? null, reply_ids: replies.map(reply => reply.id) },
             idempotency_key: message.idempotencyKey ?? null,
             ack_at: replies.find((reply) => reply.responseKind === 'ack')?.createdAt ?? null,
             reply_ids: replies.map((reply) => reply.id), result_ids: replies.filter((reply) => reply.responseKind === 'result').map((reply) => reply.id),
@@ -469,26 +559,21 @@ export class CollaborationStore {
             last_error: diagnostic?.last_error ?? null, transport_checked_at: diagnostic?.checked_at ?? null,
             fragments_sent: diagnostic?.fragments_sent ?? 0, fragments_total: diagnostic?.fragments_total ?? 0 };
     }
-    sessionFacts(sessionId, online, turnState) {
+    sessionFacts(sessionId, online, _legacyTurnState) {
         const reports = this.document.messages.filter((message) => message.fromSessionId === sessionId);
         const tasks = new Map();
         for (const message of reports)
             if (message.task)
                 tasks.set(message.task.task_id, { task_id: message.task.task_id, status: message.task.status, reported_at: message.createdAt, message_id: message.id });
-        // Aggregated from the *latest* report of each task, never inferred: an
-        // agent handed a task that has not yet replied is simply idle here —
-        // dispatch in flight is the sender-side receipt's concern (pending), not a
-        // fact about this session. blocked counts as active: the agent holds the
-        // task open. A failed terminal state only surfaces once no task is still
-        // in flight, since another in-progress task means the agent is busy.
-        const latest = [...tasks.values()];
-        const taskState = latest.some((task) => task.status === 'ack' || task.status === 'working' || task.status === 'blocked') ? 'active'
-            : latest.some((task) => task.status === 'failed') ? 'failed'
-                : 'idle';
-        return { session_state: online ? 'online' : 'offline', turn_state: turnState === 'done' ? 'ended' : turnState ?? 'unknown',
-            task_state: taskState, tasks: [...tasks.values()], last_heartbeat: null, last_tool_activity_at: null,
+        return { session_state: online ? 'online' : 'offline', tasks: [...tasks.values()],
             last_message_at: reports.length ? Math.max(...reports.map((message) => message.createdAt)) : null,
-            state_source: 'optional_adapter', task_source: 'explicit_message' };
+            last_terminal_output_at: this.peerActivity.get(sessionId)?.last_terminal_output_at ?? null,
+            activity_observed_at: this.peerActivity.get(sessionId)?.activity_observed_at ?? null,
+            last_peer_sync_at: this.peerActivity.get(sessionId)?.last_peer_sync_at ?? null,
+            activity_source: this.peerActivity.get(sessionId)?.activity_source ?? 'unavailable',
+            output_idle_seconds: this.peerActivity.get(sessionId)?.last_terminal_output_at && this.peerActivity.get(sessionId)?.activity_observed_at
+                ? Math.max(0, Math.floor((this.peerActivity.get(sessionId).activity_observed_at - this.peerActivity.get(sessionId).last_terminal_output_at) / 1000)) : null,
+            task_source: 'explicit_message' };
     }
     /** Timeline of one task as reported by a session, oldest first. The lineage
      *  starts at the recipient's first reply carrying that task_id — a bare
@@ -538,7 +623,7 @@ export class CollaborationStore {
             && (!options.thread || message.threadId === options.thread) && (!options.kind || message.kind === options.kind)
             && (!options.responseKind || message.responseKind === options.responseKind))
             .sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0));
-        const messages = incremental || options.order === 'oldest' ? candidates.slice(0, limit) : candidates.slice().sort((a, b) => Number(a.status === 'read') - Number(b.status === 'read') || (b.sequence ?? 0) - (a.sequence ?? 0)).slice(0, limit);
+        const messages = incremental || options.order === 'oldest' ? candidates.slice(0, limit) : candidates.slice().sort((a, b) => (b.sequence ?? 0) - (a.sequence ?? 0)).slice(0, limit);
         const sequence = messages.length ? Math.max(...messages.map((message) => message.sequence ?? 0)) : after;
         const next_cursor = Buffer.from(JSON.stringify({ scope, sequence })).toString('base64url');
         return { messages, next_cursor, retention_gap: incremental && after < (this.document.prunedThrough?.[sessionId] ?? 0), has_more: incremental ? candidates.length > messages.length : false, consumer: options.consumer ?? null };

package/dist/server/agent/collaborationText.js

@@ -0,0 +1,5 @@
+import { stripVTControlCharacters } from 'node:util';
+/** Snapshot rendering only. Message bodies are never normalized. */
+export function plainCollaborationSnapshot(text) {
+    return stripVTControlCharacters(text).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+}

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -1,3 +1,4 @@
+import { plainCollaborationSnapshot } from './collaborationText.js';
 import { normalizePromptForPaste } from './promptDelivery.js';
 const TMUX_KEY_NAMES = {
     enter: 'Enter', escape: 'Escape', space: 'Space', left: 'Left', right: 'Right', up: 'Up', down: 'Down',
@@ -120,10 +121,10 @@ export async function sendTmuxPaneKey(run, pane, key) {
     await run(['send-keys', '-t', pane.paneId, TMUX_KEY_NAMES[key]]);
 }
 /** Current pane screen text (viewport), identity-checked. */
-export async function captureTmuxPaneText(run, pane) {
+export async function captureTmuxPaneText(run, pane, rawOutput = false) {
     await assertSamePane(run, pane);
-    const raw = await run(['capture-pane', '-p', '-J', '-t', pane.paneId]);
-    return raw.replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '').replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '');
+    const raw = await run(['capture-pane', '-p', '-J', ...(rawOutput ? ['-e'] : []), '-t', pane.paneId]);
+    return rawOutput ? raw : plainCollaborationSnapshot(raw);
 }
 /** Dismiss an interactive approval dialog on the member pane by pressing
  *  Enter (the highlighted option). Refuses unless the screen actually shows
@@ -153,8 +154,10 @@ export async function recoverStuckPaste(run, pane, baseline) {
 }
 /** History-inclusive pane text (scrollback + viewport) used to confirm a
  *  delivery was actually rendered by the agent, not wiped by a boot clear. */
-export async function captureTmuxPaneHistory(run, pane, lines = 800) {
+export async function captureTmuxPaneHistory(run, pane, lines = 800, rawOutput = false) {
     await assertSamePane(run, pane);
-    const raw = await run(['capture-pane', '-p', '-J', '-S', `-${lines}`, '-t', pane.paneId]);
-    return raw.replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '').replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '');
+    if (!Number.isInteger(lines) || lines < 1 || lines > 10000)
+        throw new Error('INVALID_HISTORY_LINES');
+    const raw = await run(['capture-pane', '-p', '-J', ...(rawOutput ? ['-e'] : []), '-S', `-${lines}`, '-t', pane.paneId]);
+    return rawOutput ? raw : plainCollaborationSnapshot(raw);
 }

package/dist/server/entry.js

@@ -1,3 +1,6 @@
+import { X509Certificate } from 'node:crypto';
+import { CollaborationPeerTransport, connectCollaborationRpc } from './agent/collaborationPeerTransport.js';
+import { collaborationStore, deliverPeerCollaboration, collaborationLocalActivity } from './routes/terminal.js';
 import { setPushTargetPeerId } from './notifications/pushService.js';
 import { desktopDirectTargets } from './federation/desktopTargets.js';
 import { createOpenAccessRouter } from './federation/openAccess.js';
@@ -404,11 +407,12 @@ export function startServer(options = {}) {
         runtimeMonitor,
     });
     const { server, scheme } = createServerForApp(app, options);
+    let collaborationTransport;
     let entrySubjectAllowed = (_subjectId) => false;
     let routeInvitations;
     let federationServiceId = '';
     const desktopTargets = () => desktopDirectTargets(path.join(homedir(), '.termdock', 'desktop.json'), federationServiceId);
-    const routeAccess = new RouteAccess(path.join(homedir(), '.termdock', 'federation', 'routes.json'), Date.now, (subjectId, targetServiceId) => routeInvitations?.allows(subjectId, targetServiceId) === true, desktopTargets);
+    const routeAccess = new RouteAccess(path.join(homedir(), '.termdock', 'federation', 'routes.json'), Date.now, (subjectId, targetServiceId) => routeInvitations?.allows(subjectId, targetServiceId) === true || collaborationTransport?.canRoute(subjectId, targetServiceId) === true, desktopTargets);
     const relayRouter = new RelayRouter({
         authenticate: context => context,
         allowRegister: (principal, serviceId) => routeAccess.allowRegister(principal, serviceId),
@@ -441,6 +445,11 @@ export function startServer(options = {}) {
     const federation = createFederationRuntime(app, path.join(homedir(), '.termdock', 'federation'), {
         terminal: handleTerminalWebSocket, control: handleControlWebSocket,
     }, {
+        collaborationExchange: (subjectId, packet) => {
+            if (!collaborationTransport)
+                throw new Error('COLLABORATION_UNAVAILABLE');
+            return collaborationTransport.receive(subjectId, packet);
+        },
         listRouteTargets: () => { refreshDirectTargets(); return routeAccess.configuredTargets().map(target => ({ ...target, available: relayRouter.hasRoute(target.serviceId) })); },
         listRouteAccess: () => routeInvitations?.list() || [],
         grantRouteAccess: async (issuerId, targetServiceId, subjectId, url) => {
@@ -461,7 +470,7 @@ export function startServer(options = {}) {
         },
         revokeRouteAccess: id => routeInvitations?.revoke(id) || false,
         issueRouteTicket: (subjectId, serviceId) => routeAccess.issueRouteTicket(subjectId, serviceId),
-        hasRouteGrant: (subjectId, serviceId) => routeInvitations?.allows(subjectId, serviceId) === true,
+        hasRouteGrant: (subjectId, serviceId) => routeInvitations?.allows(subjectId, serviceId) === true || collaborationTransport?.canRoute(subjectId, serviceId) === true,
         createRouteInvitation: (issuerId, serviceId) => {
             if (!routeInvitations)
                 throw new Error('ROUTE_NOT_AVAILABLE');
@@ -478,6 +487,37 @@ export function startServer(options = {}) {
         setPushTargetPeerId(runtime.serviceId);
         refreshDirectTargets();
         app.locals.passwordRuntime = runtime;
+        collaborationTransport = new CollaborationPeerTransport({
+            file: path.join(homedir(), '.termdock', 'federation', 'collaboration-peers.json'), serviceId: runtime.serviceId,
+            store: collaborationStore, deliver: deliverPeerCollaboration, activity: collaborationLocalActivity,
+            connect: async (peer, via) => {
+                if (!via)
+                    return connectCollaborationRpc(runtime.identity, peer);
+                const entry = await connectCollaborationRpc(runtime.identity, via);
+                try {
+                    const ticket = await entry.request({ type: 'route-ticket', serviceId: peer.serviceId });
+                    if (typeof ticket.routeToken !== 'string')
+                        throw new Error('ROUTE_UNAVAILABLE');
+                    const url = new URL('/api/federation/relay', via.origin.replace(/^https:/, 'wss:'));
+                    url.searchParams.set('routeToken', ticket.routeToken);
+                    // TLS authenticates the entry; Noise pins the final destination.
+                    return await connectCollaborationRpc(runtime.identity, { ...via, serviceId: peer.serviceId }, url.href);
+                }
+                finally {
+                    entry.close();
+                }
+            },
+        });
+        app.locals.collaborationTransport = collaborationTransport;
+        let caFingerprint256;
+        if (options.httpsCaPath)
+            try {
+                caFingerprint256 = new X509Certificate(fs.readFileSync(options.httpsCaPath)).fingerprint256;
+            }
+            catch { /* System TLS trust remains required. */ }
+        app.locals.collaborationNode = { serviceId: runtime.serviceId, ...(caFingerprint256 ? { caFingerprint256 } : {}) };
+        collaborationTransport.start();
+        server.once('close', () => collaborationTransport?.close());
         entrySubjectAllowed = subjectId => runtime.store.authorize({ subjectId, serviceId: runtime.serviceId, action: 'authorization.manage' }).allowed;
         routeInvitations = new RouteInvitationStore({
             filePath: path.join(homedir(), '.termdock', 'federation', 'route-invitations.json'), serviceId: runtime.serviceId,

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 === 'password-parameters') {
+                    if (packet.type === 'collaboration-exchange') {
+                        if (!options.collaborationExchange)
+                            throw new Error('COLLABORATION_UNAVAILABLE');
+                        send({ type: 'result', id: packet.id, ...options.collaborationExchange(subjectId, packet) });
+                    }
+                    else if (packet.type === 'password-parameters') {
                         send({ type: 'result', id: packet.id, ...passwordBootstrap.parameters() });
                     }
                     else if (packet.type === 'password-start') {
@@ -544,6 +549,6 @@ export async function createFederationRuntime(app, directory, handlers, options
             }
         }
     }
-    return { serviceId, store, accept, close() { for (const channel of channels)
+    return { serviceId, identity, store, accept, close() { for (const channel of channels)
             channel.close(); internal.close(); } };
 }

package/dist/server/routes/terminal.js

@@ -1,3 +1,4 @@
+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';
@@ -68,7 +69,7 @@ const router = express.Router();
 const execFileAsync = promisify(execFile);
 const TERMDOCK_DIR = `${os.homedir()}/.termdock`;
 const automationStore = new AutomationStore(`${TERMDOCK_DIR}/automations.json`);
-const collaborationStore = new CollaborationStore(`${TERMDOCK_DIR}/collaboration-groups.json`);
+export const collaborationStore = new CollaborationStore(`${TERMDOCK_DIR}/collaboration-groups.json`);
 const collaborationRouting = new CollaborationRoutingStore(`${TERMDOCK_DIR}/collaboration-routing.json`);
 const collaborationDeliveryWorker = new CollaborationDeliveryWorker({
     store: collaborationStore,
@@ -1338,12 +1339,12 @@ function orchestrationSessionSnapshot(record) {
     const route = collaborationDeliveryWorker.state(record.sessionId);
     const slug = binding?.pane?.agentSlug ?? binding?.agentSlug ?? record.agentResume?.slug;
     const agent = slug ? agentBySlug(slug) : backend?.agent;
-    const sameNativeSession = !binding?.pane || Boolean(binding.pane.nativeSessionId
-        && binding.pane.nativeSessionId === backend?.agentSession?.sessionId && binding.pane.agentSlug === backend?.agent?.slug);
-    const turnState = sameNativeSession ? backend?.agentSession?.status : undefined;
-    const latestPrompt = sameNativeSession ? backend?.autoTitlePromptPayloads.at(-1)?.trim() ?? '' : '';
     return {
-        ...collaborationStore.sessionFacts(record.sessionId, route.state === 'ready', turnState),
+        ...collaborationStore.sessionFacts(record.sessionId, route.state === 'ready'),
+        last_terminal_output_at: backend?.lastOutputAt || null,
+        activity_observed_at: backend ? Date.now() : null,
+        activity_source: backend ? 'terminal_output' : 'unavailable',
+        output_idle_seconds: backend?.lastOutputAt ? Math.max(0, Math.floor((Date.now() - backend.lastOutputAt) / 1000)) : null,
         route_state: route.state,
         route_error: route.reason,
         route_checked_at: route.checkedAt,
@@ -1353,11 +1354,10 @@ function orchestrationSessionSnapshot(record) {
         name: record.name,
         cwd: backend?.cwd ?? record.cwd ?? '',
         agent: agent ? { slug: agent.slug, displayName: agent.displayName } : null,
-        status: route.state === 'ready' ? turnState ?? 'ready' : route.state,
+        status: route.state,
         capability: agent
             ? [agent.displayName, ...(agent.capabilities ?? []), backend?.activeProgram?.command || record.activeProgram || 'Agent 会话'].join(' · ')
             : (backend?.activeProgram?.command || record.activeProgram || 'Shell 终端'),
-        currentTask: latestPrompt || record.name,
         updatedAt: backend?.lastActivity ?? record.lastActivity,
     };
 }
@@ -1438,16 +1438,20 @@ function resolveFrontendSessionId(input) {
 }
 function collaborationRemoteSessions() {
     return Array.from(new Map(collaborationStore.list().flatMap((group) => group.remoteSessions ?? [])
-        .map((session) => [session.sessionId, { ...session, ...collaborationStore.sessionFacts(session.sessionId, session.serviceConnected === true && Date.now() - (session.serviceCheckedAt ?? 0) <= 15_000, session.status), status: session.serviceConnected !== true || Date.now() - (session.serviceCheckedAt ?? 0) > 15_000 ? 'service-unreachable' : session.status, name: `${session.name} · ${session.serviceLabel}` }])).values());
+        .map((session) => {
+        const facts = collaborationStore.sessionFacts(session.sessionId, false);
+        const { currentTask: _currentTask, ...terminalSession } = session;
+        const checkedAt = Math.max(session.serviceCheckedAt ?? 0, facts.last_peer_sync_at ?? 0);
+        const online = Date.now() - checkedAt <= 15_000 && (session.serviceConnected === true || !!facts.last_peer_sync_at && Date.now() - facts.last_peer_sync_at <= 15_000);
+        return [session.sessionId, { ...terminalSession, ...facts, session_state: online ? 'online' : 'offline',
+                serviceConnected: online, serviceCheckedAt: checkedAt, status: online ? 'service-reachable' : 'service-unreachable', name: `${session.name} · ${session.serviceLabel}` }];
+    })).values());
 }
 function tryDeliverCollaborationInbox(frontendSessionId) {
     const remote = collaborationRemoteSessions().find((session) => session.sessionId === frontendSessionId);
     if (remote) {
-        const unavailable = remote.serviceConnected !== true || Date.now() - (remote.serviceCheckedAt ?? 0) > 15_000;
-        return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId),
-            serviceUnavailable: unavailable, reason: unavailable
-                ? `服务 ${remote.serviceLabel} 不可达：消息尚未送达，仅保存在待发送队列；请勿等待对方已收到的回复，服务重连且转发客户端恢复运行后重试投递。`
-                : '跨服务消息尚未确认送达，正在等待在线客户端转发。' };
+        return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId), waitable: true,
+            reason: '跨服务消息已入队，服务后台正在投递；使用 message get 查看送达回执或注册、重试原因。' };
     }
     collaborationDeliveryWorker.wake(frontendSessionId);
     const route = collaborationDeliveryWorker.state(frontendSessionId);
@@ -1608,7 +1612,7 @@ async function resolveCollaborationRoute(frontendSessionId) {
         }
         if (!backend)
             return { state: 'detached', reason: 'TMUX_BACKEND_UNAVAILABLE' };
-        return { state: 'ready', isShell: pane.isShell, capture: async () => (await captureTmuxPane(pinned.paneId)).content, write: async (messages) => {
+        return { state: 'ready', isShell: pane.isShell, capture: async () => captureTmuxPaneText(runTmux, pinned), write: async (messages) => {
                 if (!globalSessionState.sessions.some((candidate) => candidate.sessionId === frontendSessionId))
                     throw new Error('SESSION_REMOVED');
                 await writeCollaborationTmuxPane(runTmux, pinned, formatLocalCollaborationMessages(frontendSessionId, messages), runTmuxStdin);
@@ -4805,7 +4809,7 @@ async function spawnTerminalSessionUnlocked(req, input) {
         cols,
         rows,
         lastActivity: Date.now(),
-        lastOutputAt: Date.now(),
+        lastOutputAt: 0,
         clients: new Map(),
         createdAt: Date.now(),
         hasWrittenData: false,
@@ -4894,7 +4898,7 @@ async function adoptPtyHostSessions() {
             cols: meta.cols,
             rows: meta.rows,
             lastActivity: Date.now(),
-            lastOutputAt: Date.now(),
+            lastOutputAt: 0,
             clients: new Map(),
             createdAt: meta.startedAt,
             hasWrittenData: true,
@@ -5474,10 +5478,30 @@ router.delete('/operations/automations/:automationId', (req, res) => {
 });
 // 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, limits: COLLAB_LIMITS, ...collaborationStore.federationSnapshot(),
+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) });
 });
+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) });
+    }
+});
+export function collaborationLocalActivity() {
+    return globalSessionState.sessions.map(record => {
+        const backendId = collaborationRouting.get(record.sessionId)?.backendSessionId ?? record.backendSessionId;
+        const backend = backendId ? terminalSessions.get(backendId) : undefined;
+        return { sessionId: record.sessionId, last_terminal_output_at: backend?.lastOutputAt || null, activity_observed_at: backend ? Date.now() : null };
+    });
+}
+export function deliverPeerCollaboration(sessionId) { void tryDeliverCollaborationInbox(sessionId); }
 router.post('/operations/collaboration-federation', (req, res) => {
     try {
         const group = req.body?.group;
@@ -5832,7 +5856,11 @@ router.post('/operations/orchestration/drive', async (req, res) => {
             return res.json({ ok: true, action, sessionId: target, approved: true });
         }
         if (action === 'capture') {
-            const snapshot = await captureTmuxPaneText(runTmux, pane);
+            const lines = req.body.lines;
+            if (lines !== undefined && (!Number.isInteger(lines) || lines < 1 || lines > 10000))
+                return res.status(400).json({ error: 'lines 必须为 1..10000 的历史行数' });
+            const snapshot = lines === undefined ? await captureTmuxPaneText(runTmux, pane, req.body.raw === true)
+                : await captureTmuxPaneHistory(runTmux, pane, lines, req.body.raw === true);
             return res.json({ ok: true, action, sessionId: target, snapshot });
         }
         if (action === 'run') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.230",
+  "version": "1.4.232",
   "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.230",
+  "version": "1.4.232",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-DO8IZjFbTWRMSTgEwFWqztjBTjT2Wyex9+RzTXfIPLE=",
-  "clientBundleHash": "sha256-FimQqH8y7rTMRAYWpgY8AzY0qloO/UjmzZ8qb8PJkzw=",
+  "serverBundleHash": "sha256-GHB6P5NPYFEdDR/sPm0FHVSEBdpzcJ8Jghr5X2uikWU=",
+  "clientBundleHash": "sha256-AWAHyBvSOOJ9eViAjt+iC2NSH0Uex5K8eEGrkeFVEFI=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }