termdock 1.4.346 → 1.4.347

package/dist/server/agent/collaborationStore.js

@@ -467,6 +467,12 @@ export class CollaborationStore {
         const group = this.getGroup(groupId);
         if (!group || group.deleted || !context || typeof context !== 'object')
             return;
+        if (this.applyContext(group, context))
+            this.persist();
+    }
+    applyContext(group, context) {
+        if (group.deleted)
+            return false;
         let changed = false;
         const rules = context.instructions;
         if (rules && validRevision(rules) && typeof rules.text === 'string' && Buffer.byteLength(rules.text) <= 8192
@@ -488,8 +494,7 @@ export class CollaborationStore {
                 delete group.roles[id];
             changed = true;
         }
-        if (changed)
-            this.persist();
+        return changed;
     }
     removeSession(sessionId) {
         const count = this.document.groups.filter(group => group.sessionIds.includes(sessionId)).length;
@@ -712,12 +717,17 @@ export class CollaborationStore {
         if (existing && (!existing.federated || (existing.deleted && (!group.deleted || existing.updatedAt >= group.updatedAt))
             || (!group.deleted && existing.updatedAt > group.updatedAt)))
             return;
-        const incoming = group.deleted && existing && !existing.deleted
-            ? { ...group, updatedAt: Math.max(group.updatedAt, existing.updatedAt + 1) } : group;
-        const priorContext = existing ? this.context(group.id) : undefined;
-        this.document.groups = [...this.document.groups.filter((item) => item.id !== group.id), { ...incoming }];
-        if (priorContext)
-            this.mergeContext(group.id, priorContext);
+        // Directory refreshes repeat the same group every few seconds. Compare
+        // content as well as the timestamp: equal timestamps can carry real edits.
+        if (existing && stableJson(existing) === stableJson(group))
+            return;
+        const incoming = structuredClone(group.deleted && existing && !existing.deleted
+            ? { ...group, updatedAt: Math.max(group.updatedAt, existing.updatedAt + 1) } : group);
+        if (existing)
+            this.applyContext(incoming, this.context(group.id));
+        if (existing && stableJson(existing) === stableJson(incoming))
+            return;
+        this.document.groups = [...this.document.groups.filter((item) => item.id !== group.id), incoming];
         if (group.deleted)
             this.document.messages = this.document.messages.filter((item) => item.groupId !== group.id);
         this.persist();
@@ -861,16 +871,34 @@ export class CollaborationStore {
         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
-            && (message.toPrincipalId ? reply.integrationOrigin?.integrationId === message.toPrincipalId : reply.fromSessionId === message.toSessionId)
+        return this.messageReceipt(message, this.document.messages.filter(reply => reply.replyTo === id), raw);
+    }
+    /** Reconcile message events in one pass without rescanning the complete
+     * history for every receipt or formatting snapshots which events omit. */
+    snapshotMessagesWithReceipts(groups) {
+        const replies = new Map();
+        for (const message of this.document.messages)
+            if (message.replyTo) {
+                const list = replies.get(message.replyTo) ?? [];
+                list.push(message);
+                replies.set(message.replyTo, list);
+            }
+        return structuredClone(this.document.messages.filter(message => groups.has(message.groupId)).map(message => {
+            const { snapshot: _, ...receipt } = this.messageReceipt(message, replies.get(message.id) ?? [], false, false);
+            return { message, receipt };
+        }));
+    }
+    messageReceipt(message, candidates, raw, includeSnapshot = true) {
+        const id = message.id;
+        const replies = candidates.filter(reply => (message.toPrincipalId ? reply.integrationOrigin?.integrationId === message.toPrincipalId : reply.fromSessionId === message.toSessionId)
             && (message.integrationOrigin ? reply.toPrincipalId === message.integrationOrigin.integrationId : reply.toSessionId === message.fromSessionId));
         const diagnostic = this.diagnostic(id);
-        const facts = terminalMessage(message, raw);
+        const facts = terminalMessage(includeSnapshot ? message : { ...message, snapshot: null }, raw);
         return { message_id: id, thread_id: message.threadId, status: facts.status, queued_at: message.status === 'stored' ? null : message.createdAt, stored_at: message.storedAt ?? null,
             from_principal_id: message.integrationOrigin?.integrationId ?? null, to_principal_id: message.toPrincipalId ?? null,
             delivered_at: facts.deliveredAt, expires_at: message.expiresAt ?? null,
             failure_reason: message.failureReason ?? null, delivery_semantics: message.status === 'stored' ? 'durable_storage' : facts.deliverySource ?? (facts.deliveredAt === null ? 'not_delivered' : 'legacy_or_unspecified'),
-            snapshot: message.snapshot ? (raw ? message.snapshot : plainCollaborationSnapshot(message.snapshot)) : null,
+            snapshot: includeSnapshot && message.snapshot ? (raw ? message.snapshot : plainCollaborationSnapshot(message.snapshot)) : null,
             delivery: { status: facts.status,
                 stage: message.status === 'stored' ? 'stored' : facts.deliveredAt !== null ? 'terminal_written' : diagnostic?.route_state === 'identity-mismatch' || diagnostic?.last_error === 'TMUX_PANE_CHANGED' ? 'blocked' : diagnostic?.remote_received_at ? 'remote_received' : 'queued',
                 ...(!diagnostic?.route_diagnostics && diagnostic?.last_error === 'TMUX_PANE_CHANGED' ? { requires_confirmation: true } : {}),

package/dist/server/agent/integrationServer.js

@@ -29,6 +29,8 @@ export class IntegrationRuntime {
     streams = new Set();
     sent = new Map();
     syncing = false;
+    dirtySources = new Set(['messages', 'tasks', 'sessions']);
+    syncedGroups = '';
     retry;
     releaseBatchFile;
     releaseBatchOperations = [];
@@ -57,14 +59,17 @@ export class IntegrationRuntime {
                 throw error;
         }
         this.stops.push(options.messages.registerRuntimeGuard(id => this.sessions.assertRuntimeMessage(id)));
-        const changed = () => { try {
-            this.sync();
-        }
-        catch (error) {
-            this.failStreams(error);
-            this.scheduleRetry();
-        } };
-        this.stops.push(options.messages.subscribe(changed), options.taskStore.subscribe(changed), this.sessions.subscribe(changed));
+        const changed = (source) => () => {
+            this.dirtySources.add(source);
+            try {
+                this.sync();
+            }
+            catch (error) {
+                this.failStreams(error);
+                this.scheduleRetry();
+            }
+        };
+        this.stops.push(options.messages.subscribe(changed('messages')), options.taskStore.subscribe(changed('tasks')), this.sessions.subscribe(changed('sessions')));
         const app = express();
         app.use(express.json({ limit: '2mb' }));
         app.use((req, res, next) => {
@@ -461,11 +466,25 @@ export class IntegrationRuntime {
         if (this.syncing)
             return;
         this.syncing = true;
+        let sources = new Set();
         try {
             const groups = new Set(this.store.policies().filter(p => !p.revoked).map(p => p.groupId)), updates = [];
-            if (!groups.size)
+            const groupVersion = JSON.stringify([...groups].sort());
+            // Newly granted groups need a complete source reconciliation, including
+            // retained facts that predate the grant. Never advance dirty state until
+            // the durable event append succeeds.
+            if (groupVersion !== this.syncedGroups)
+                for (const source of ['messages', 'tasks', 'sessions'])
+                    this.dirtySources.add(source);
+            sources = this.dirtySources;
+            this.dirtySources = new Set();
+            if (!sources.size)
+                return;
+            if (!groups.size) {
+                this.syncedGroups = groupVersion;
                 return;
-            for (const task of this.options.taskStore.snapshot())
+            }
+            for (const task of sources.has('tasks') ? this.options.taskStore.snapshot() : [])
                 if (groups.has(task.groupId)) {
                     for (const event of task.events)
                         updates.push({ sourceKey: `task:${task.id}:${event.id}`, sourceVersion: '1', eventId: event.id, event: {
@@ -485,31 +504,30 @@ export class IntegrationRuntime {
                                 task_id: task.id, attempt_id: delivery.attemptId, message_id: delivery.messageId, source: 'system', payload: { delivery }
                             } });
                 }
-            for (const message of this.options.messages.snapshotMessages())
-                if (groups.has(message.groupId)) {
-                    const link = message.metadata?.termdockTask;
-                    const context = { group_id: message.groupId, task_id: link?.taskId ?? null, attempt_id: link?.attemptId ?? null,
-                        reply_to_event_id: link?.replyToEventId ?? null, message_id: message.id, source: message.integrationOrigin ? 'integration' : message.fromSessionId ? 'member' : 'system',
-                        actor: message.integrationOrigin ? { integration_id: message.integrationOrigin.integrationId } : message.fromSessionId ? { session_id: message.fromSessionId } : null,
-                        external_actor: message.integrationOrigin?.externalActor ?? null };
-                    updates.push({ sourceKey: `message:${message.id}`, sourceVersion: '1', event: { ...context,
-                            kind: message.kind === 'reply' ? 'message.reply' : 'message.queued', created_at: message.createdAt,
-                            payload: { message_id: message.id, thread_id: message.threadId, reply_to: message.replyTo ?? null,
-                                from_session_id: message.fromSessionId, to_session_id: message.toPrincipalId ? null : message.toSessionId,
-                                to_principal_id: message.toPrincipalId ?? null, integration_origin: message.integrationOrigin ?? null,
-                                response_kind: message.responseKind ?? null, stored_at: message.storedAt ?? null,
-                                content: message.content, metadata: message.metadata ?? null } } });
-                    const { snapshot: _, ...receipt } = this.options.messages.receipt(message.id);
-                    updates.push({ sourceKey: `message-status:${message.id}`, sourceVersion: JSON.stringify(receipt), event: {
-                            ...context, kind: 'message.delivery', created_at: message.deliveredAt ?? message.createdAt, payload: { receipt }
-                        } });
-                }
-            for (const session of this.sessions.snapshot())
+            for (const { message, receipt } of sources.has('messages') ? this.options.messages.snapshotMessagesWithReceipts(groups) : []) {
+                const link = message.metadata?.termdockTask;
+                const context = { group_id: message.groupId, task_id: link?.taskId ?? null, attempt_id: link?.attemptId ?? null,
+                    reply_to_event_id: link?.replyToEventId ?? null, message_id: message.id, source: message.integrationOrigin ? 'integration' : message.fromSessionId ? 'member' : 'system',
+                    actor: message.integrationOrigin ? { integration_id: message.integrationOrigin.integrationId } : message.fromSessionId ? { session_id: message.fromSessionId } : null,
+                    external_actor: message.integrationOrigin?.externalActor ?? null };
+                updates.push({ sourceKey: `message:${message.id}`, sourceVersion: '1', event: { ...context,
+                        kind: message.kind === 'reply' ? 'message.reply' : 'message.queued', created_at: message.createdAt,
+                        payload: { message_id: message.id, thread_id: message.threadId, reply_to: message.replyTo ?? null,
+                            from_session_id: message.fromSessionId, to_session_id: message.toPrincipalId ? null : message.toSessionId,
+                            to_principal_id: message.toPrincipalId ?? null, integration_origin: message.integrationOrigin ?? null,
+                            response_kind: message.responseKind ?? null, stored_at: message.storedAt ?? null,
+                            content: message.content, metadata: message.metadata ?? null } } });
+                updates.push({ sourceKey: `message-status:${message.id}`, sourceVersion: JSON.stringify(receipt), event: {
+                        ...context, kind: 'message.delivery', created_at: message.deliveredAt ?? message.createdAt, payload: { receipt }
+                    } });
+            }
+            const sessions = sources.has('sessions') ? this.sessions.snapshot() : [];
+            for (const session of sessions)
                 if (groups.has(session.group_id))
                     updates.push({ sourceKey: `session:${session.session_id}`, sourceVersion: JSON.stringify(publicIntegrationSession(session)), event: {
                             group_id: session.group_id, kind: `session.${session.state}`, created_at: session.updated_at, source: 'system', actor: { integration_id: session.principal_id }, payload: { session: publicIntegrationSession(session) }
                         } });
-            for (const session of this.sessions.snapshot())
+            for (const session of sessions)
                 if (groups.has(session.group_id) && session.name_updated_at)
                     updates.push({
                         sourceKey: `session-name:${session.session_id}`, sourceVersion: JSON.stringify([session.name, session.name_updated_at, session.name_generation]), event: {
@@ -519,9 +537,17 @@ export class IntegrationRuntime {
                     });
             updates.sort((a, b) => a.event.created_at - b.event.created_at);
             this.store.append(updates);
+            this.syncedGroups = groupVersion;
+        }
+        catch (error) {
+            for (const source of sources)
+                this.dirtySources.add(source);
+            throw error;
         }
         finally {
             this.syncing = false;
+            if (this.dirtySources.size)
+                this.scheduleRetry();
         }
     }
     failStreams(error) {

package/dist/server/agent/integrationSessions.js

@@ -68,6 +68,8 @@ export class IntegrationSessions {
     stopDeliveryGuard;
     observing = false;
     observeAgain = false;
+    observationTimer;
+    stopped = false;
     constructor(file, adapter, bindingTimeout = 120000) {
         this.file = file;
         this.adapter = adapter;
@@ -94,7 +96,22 @@ export class IntegrationSessions {
             if (record.startup_input && record.startup_input.state !== 'observed')
                 record.startup_input.matched_since = null;
         this.stopDeliveryGuard = adapter.registerDeliveryGuard?.(id => this.deliveryReadiness(id));
-        this.stopObservation = adapter.subscribe(() => { void this.refreshAll().catch(() => { }); });
+        this.stopObservation = adapter.subscribe(() => this.scheduleObservation());
+    }
+    scheduleObservation() {
+        if (this.stopped)
+            return;
+        if (this.observing) {
+            this.observeAgain = true;
+            return;
+        }
+        if (this.observationTimer)
+            return;
+        this.observationTimer = setTimeout(() => {
+            this.observationTimer = undefined;
+            void this.refreshAll().catch(() => { });
+        }, 250);
+        this.observationTimer.unref();
     }
     scheduleRefresh(record) {
         for (const deadline of new Set([record.deadline, ...(record.startup_input ? [record.startup_input.deadline] : [])])) {
@@ -974,18 +991,29 @@ export class IntegrationSessions {
             this.observeAgain = true;
             return;
         }
+        if (this.observationTimer) {
+            clearTimeout(this.observationTimer);
+            this.observationTimer = undefined;
+        }
         this.observing = true;
+        this.observeAgain = false;
         try {
-            do {
-                this.observeAgain = false;
-                for (const record of this.snapshot())
-                    await this.refresh(record.session_id);
-            } while (this.observeAgain);
+            for (const record of this.snapshot())
+                await this.refresh(record.session_id);
         }
         finally {
             this.observing = false;
+            if (this.observeAgain)
+                this.scheduleObservation();
         }
     }
-    close() { this.stopObservation(); this.stopDeliveryGuard?.(); for (const timer of this.timers)
-        clearTimeout(timer); }
+    close() {
+        this.stopped = true;
+        this.stopObservation();
+        this.stopDeliveryGuard?.();
+        if (this.observationTimer)
+            clearTimeout(this.observationTimer);
+        for (const timer of this.timers)
+            clearTimeout(timer);
+    }
 }

package/dist/server/agent/integrationStore.js

@@ -152,18 +152,19 @@ export class IntegrationStore {
             integrationError('INTEGRATION_PERMISSION_DENIED', 'Operation is outside the integration grant', 403);
     }
     append(updates) {
-        const next = structuredClone(this.doc);
-        let changed = false;
+        // Most reconciliations repeat already-journaled facts. Do not copy the
+        // retained event history until the first actual source-version change.
+        let next;
         for (const update of updates) {
-            if (next.sources[update.sourceKey] === update.sourceVersion)
+            if ((next ?? this.doc).sources[update.sourceKey] === update.sourceVersion)
                 continue;
+            next ??= structuredClone(this.doc);
             const group = update.event.group_id, sequence = (next.sequences[group] ?? 0) + 1;
             next.events.push({ ...update.event, event_id: update.eventId ?? randomUUID(), sequence, cursor: this.cursor(group, sequence) });
             next.sequences[group] = sequence;
             next.sources[update.sourceKey] = update.sourceVersion;
-            changed = true;
         }
-        if (!changed)
+        if (!next)
             return;
         const counts = new Map();
         next.events = next.events.reverse().filter(event => {

package/dist/server/routes/terminal.js

@@ -1765,7 +1765,7 @@ async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane =
         // pane so a plain shell member is drivable (run/capture are shell ops).
         return selectDrivePane(binding, candidates, layout.activePaneId);
     }
-    return { ...selectCollaborationPane(binding, candidates), candidates };
+    return { ...selectCollaborationPane(binding, candidates), candidates, layout };
 }
 function routeOwnershipConfirmed(frontendSessionId, binding, panes) {
     const record = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
@@ -2350,7 +2350,7 @@ export const integrationSessionAdapter = {
         if (inspected.state !== 'ready' || !inspected.pane)
             integrationError('SESSION_IDENTITY_MISMATCH', 'Owned tmux pane cannot be uniquely verified', 409);
         const pane = inspected.pane;
-        const layout = await getTmuxLayout(terminal.tmuxSessionName);
+        const layout = inspected.layout;
         if (layout.windows.flatMap(window => window.panes).length !== 1 || layout.activePaneId !== pane.paneId)
             integrationError('SESSION_IDENTITY_MISMATCH', 'Integration native binding requires the single owned pane', 409);
         const backend = terminal.backendSessionId ? terminalSessions.get(terminal.backendSessionId) : null;

package/docs/integrations.md

@@ -1383,3 +1383,14 @@ wrapper 负责实际设置 Agent 自己的数据目录、准备 hooks/参数，
 用 stdin 文件给启动命令附带业务 prompt 是接入方的 bootstrap：TD 不为其中业务副作用提供消息幂等或执行确认；无 TD message 历史也不等于没有业务执行。冷启动与精确 resume 应分开处理，恢复时不得重放初始业务文件。host 收取 final/hook receipt 是 host 侧证据，不伪造成 TD 明确 reply。仍只粘贴一次、等待 50ms、写一次 CR。
 
 回归包含确定性交错的旧读盘覆盖/串行写入/删除不复活、同 pane shell 初始化等待与超时/换 pane/已有 Agent 拒绝、CLI 对旧服务拒绝，以及 Linux 真实 tmux/内核 flock 的独立目录核验。私有 TraeX/DevBox 的启动兼容仍需接入方维护窗实机验证；维护机合成测试不冒充该项通过。
+
+## 1.4.347：无变化同步与后台观察的开销
+
+这是服务运行时优化，不增加接口、权限或配置。需要更新实际运行服务到 **1.4.347**；仅安装新 CLI 不会更新已运行进程。
+
+- 跨服务目录重复合并相同群内容时不写盘、不通知事件同步。比较包含内容而非仅时间戳；同时间戳的真实变化仍处理。合并独立群规/角色版本后如有效内容未变也不写盘；有效群更新与保留的新上下文一次持久化。
+- 空事件追加及 source/version 全重复的追加在克隆事件历史之前返回。真实更新继续持久提交，失败保留可重试源版本，不改变事件 ID、顺序、ACK 或保留策略。
+- 事件同步按消息、任务、会话三个变化来源分别扫描；会话通知不再复制消息历史和生成全部消息回执。新授权组及服务重启仍对保留事实完整对账；失败来源继续重试。消息变化时一次建立回复索引，避免每条回执重扫历史；回执仍核验双方身份，并省去事件中不包含的终端快照格式化。这是按来源增量同步，真实变化仍会扫描该来源的保留记录。
+- 终端输出触发的后台会话观察按 250ms 窗口合并；一轮观察期间的新通知安排到后续一轮，不连续抢占。显式 `session get`、生命周期操作及投递前核验保留原路径，不以此窗口判断 Agent 可输入；不延迟业务输入来猜测应用状态。同一次 integration 观察复用其新鲜 tmux layout，下一次观察重新读取，不把缓存用作身份写入凭据。
+
+无删除消息/事件、缩短历史、停用消费者、额外 Enter 或正文重发。`pty_written` 仍只代表终端写入调用完成，不代表应用提交或任务完成。回归包含约 26 MB journal 的空/重复追加零克隆、相同群同步零写入、真实变化/持久化失败重试、授权后历史补收、通知洪峰合并、换 pane/原生身份冲突拒绝。生产 CPU、事件循环延迟和 health 改善须在实际维护窗升级后对比采样，不能用隔离基准代替实机验收。

package/package.json

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

package/runtime-manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.346",
+  "version": "1.4.347",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-ObG1OGq7e7fMFQmYoPxPp3jRodEusYHulVNa5mT1aW8=",
-  "serverBundleHash": "sha256-14J5QvRzetON18qbhx5HXdLAx08WrjndjMlOCMpgfOc=",
+  "serverBundleHash": "sha256-FXUdT0eV3/+rgHBnc0Jg9dn2sAb4hcLY83xScGapcKQ=",
   "clientBundleHash": "sha256-kn3Tg+BTj+H4rZe0g9OE5JUEQNsBGiUSGew8Epm5A38=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"