termdock 1.4.178 → 1.4.180

package/dist/server/routes/terminal.js

@@ -39,6 +39,10 @@ import { CollaborationStore } from '../agent/collaborationStore.js';
 import { formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
 import { resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
 import { SessionSearchStore } from '../agent/sessionSearchStore.js';
+import { resolveCollaborationBackend, resolveCollaborationSessionId } from '../agent/sessionBindingRecovery.js';
+import { CollaborationRoutingStore, selectCollaborationPane } from '../agent/collaborationRouting.js';
+import { CollaborationDeliveryWorker } from '../agent/collaborationDeliveryWorker.js';
+import { writeCollaborationTmuxPane } from '../agent/collaborationTmuxDelivery.js';
 import { listAllHookAgents, refreshStaleHooksAtLaunch, installHooksForSlug, uninstallHooksForSlug, } from '../agent/installers.js';
 import { loadPlugins, savePlugin, removePlugin, readPluginIcon, validateManifest, } from '../agent/plugins.js';
 import { TmuxLifecycleCoordinator } from '../utils/tmuxLifecycle.js';
@@ -60,6 +64,14 @@ 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`);
+const collaborationRouting = new CollaborationRoutingStore(`${TERMDOCK_DIR}/collaboration-routing.json`);
+const collaborationDeliveryWorker = new CollaborationDeliveryWorker({
+    store: collaborationStore,
+    peers: () => collaborationStore.list().filter((group) => !group.deleted).flatMap((group) => group.sessionIds),
+    isLocal: (id) => !id.startsWith('remote:'),
+    resolve: resolveCollaborationRoute,
+    onError: (error) => console.warn('[collaboration] background delivery failed:', getErrorMessage(error)),
+});
 const sessionSearchStore = new SessionSearchStore(`${TERMDOCK_DIR}/session-search`);
 let atomicJsonWriteSequence = 0;
 async function readJsonFileIfExists(filePath) {
@@ -572,6 +584,7 @@ void (async () => {
     });
     pruneOrphanSessions();
     await backfillPersistedTmuxMetadata();
+    collaborationDeliveryWorker.start();
 })();
 caffeinateManager.startNetworkMonitor();
 // 清理磁盘恢复后后端已不存在的 session 引用。
@@ -1002,6 +1015,16 @@ function upsertGlobalSessionRecord(record) {
         sessions: deduplicateGlobalSessions(next),
         updatedAt: Date.now(),
     };
+    // Capture server-observed bindings when sessions are created/adopted. Client
+    // projections may later lose their backend id; the routing registry must not.
+    if (normalized.backendSessionId && terminalSessions.has(normalized.backendSessionId)) {
+        try {
+            resolveOrchestrationBackend(normalized);
+        }
+        catch (error) {
+            console.warn('[collaboration] binding persistence failed:', getErrorMessage(error));
+        }
+    }
     return normalized;
 }
 function removeGlobalSessionRecord(frontendSessionId) {
@@ -1011,8 +1034,10 @@ function removeGlobalSessionRecord(frontendSessionId) {
         updatedAt: Date.now(),
     };
     const changed = globalSessionState.sessions.length !== before;
-    if (changed)
+    if (changed) {
         collaborationStore.removeSession(frontendSessionId);
+        collaborationRouting.remove(frontendSessionId);
+    }
     return changed;
 }
 function archiveAgentResumeRecord(record, reason) {
@@ -1263,19 +1288,48 @@ async function openInventorySession(req, input) {
         reused,
     };
 }
+function resolveOrchestrationBackend(record) {
+    const recovered = resolveCollaborationBackend(record, globalSessionState.sessions, terminalSessions, collaborationRouting);
+    if (!recovered)
+        return null;
+    const [backendSessionId, backend] = recovered;
+    const changed = record.backendSessionId !== backendSessionId || record.tmuxSessionName !== backend.tmuxSessionName || record.mode !== backend.mode;
+    record.backendSessionId = backendSessionId;
+    record.mode = backend.mode;
+    record.tmuxSessionName = backend.tmuxSessionName;
+    record.cwd = backend.cwd ?? record.cwd;
+    if (changed) {
+        globalSessionState.updatedAt = Date.now();
+        schedulePersistGlobalState();
+        const metadata = searchMetadataForBackend(backendSessionId, backend);
+        if (metadata)
+            sessionSearchStore.update(metadata);
+    }
+    return backend;
+}
 function orchestrationSessionSnapshot(record) {
-    const backend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
-    const agent = backend?.agent ?? (record.agentResume?.slug ? agentBySlug(record.agentResume.slug) : null);
-    const latestPrompt = backend?.autoTitlePromptPayloads.at(-1)?.trim() ?? '';
+    const binding = collaborationRouting.get(record.sessionId);
+    const backendId = binding?.backendSessionId ?? record.backendSessionId;
+    const backend = backendId ? terminalSessions.get(backendId) : null;
+    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, Boolean(backend), backend?.agentSession?.status),
+        ...collaborationStore.sessionFacts(record.sessionId, route.state === 'ready', turnState),
+        route_state: route.state,
+        route_error: route.reason,
+        route_checked_at: route.checkedAt,
         sessionId: record.sessionId,
-        agentNativeSessionId: backend?.agentSession?.sessionId ?? record.agentResume?.sessionId ?? null,
-        backendSessionId: record.backendSessionId ?? null,
+        agentNativeSessionId: binding?.pane ? binding.pane.nativeSessionId : binding?.nativeSessionId ?? backend?.agentSession?.sessionId ?? record.agentResume?.sessionId ?? null,
+        backendSessionId: backendId ?? null,
         name: record.name,
         cwd: backend?.cwd ?? record.cwd ?? '',
         agent: agent ? { slug: agent.slug, displayName: agent.displayName } : null,
-        status: backend?.agentSession?.status ?? (backend ? 'shell' : 'offline'),
+        status: route.state === 'ready' ? turnState ?? 'ready' : route.state,
         capability: agent
             ? [agent.displayName, ...(agent.capabilities ?? []), backend?.activeProgram?.command || record.activeProgram || 'Agent 会话'].join(' · ')
             : (backend?.activeProgram?.command || record.activeProgram || 'Shell 终端'),
@@ -1356,17 +1410,7 @@ async function runAgentAutomation(automation, req) {
     }
 }
 function resolveFrontendSessionId(input) {
-    const sessionId = typeof input.sessionId === 'string' ? input.sessionId.trim() : '';
-    if (sessionId && globalSessionState.sessions.some((record) => record.sessionId === sessionId))
-        return sessionId;
-    const backendSessionId = typeof input.backendSessionId === 'string' ? input.backendSessionId.trim() : '';
-    if (backendSessionId) {
-        const resolved = globalSessionState.sessions.find((record) => record.backendSessionId === backendSessionId)?.sessionId;
-        if (resolved)
-            return resolved;
-    }
-    const tmuxSessionName = typeof input.tmuxSessionName === 'string' ? input.tmuxSessionName.trim() : '';
-    return globalSessionState.sessions.find((record) => record.tmuxSessionName === tmuxSessionName)?.sessionId ?? null;
+    return resolveCollaborationSessionId(input, globalSessionState.sessions, collaborationRouting);
 }
 function collaborationRemoteSessions() {
     return Array.from(new Map(collaborationStore.list().flatMap((group) => group.remoteSessions ?? [])
@@ -1381,45 +1425,154 @@ function tryDeliverCollaborationInbox(frontendSessionId) {
                 ? `服务 ${remote.serviceLabel} 不可达：消息尚未送达，仅保存在待发送队列；请勿等待对方已收到的回复，服务重连且 Mac 客户端运行后重试投递。`
                 : '跨服务消息尚未确认送达，正在等待 Mac 客户端转发。' };
     }
-    const record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
-    const session = record?.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
-    const pending = collaborationStore.inbox(frontendSessionId, { pendingOnly: true, limit: 10 });
-    // Submit to every online Agent immediately. Its TUI owns ordering while a
-    // turn is active; Termdock only retains messages when the Agent is offline.
-    if (!session || !canDeliverPromptToAgent(session) || pending.length === 0) {
-        return { delivered: [], pending: pending.length };
-    }
-    const prompt = formatCollaborationDelivery({
-        targetSessionId: frontendSessionId,
-        messages: pending,
+    collaborationDeliveryWorker.wake(frontendSessionId);
+    const route = collaborationDeliveryWorker.state(frontendSessionId);
+    return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId),
+        reason: route.reason ?? '消息已入队，后台正在恢复路由并投递' };
+}
+function formatLocalCollaborationMessages(frontendSessionId, messages) {
+    return formatCollaborationDelivery({ targetSessionId: frontendSessionId, messages,
         groups: collaborationStore.groupsForSession(frontendSessionId),
-        sessions: [...collaborationRemoteSessions(), ...globalSessionState.sessions.map((candidate) => {
-                const snapshot = orchestrationSessionSnapshot(candidate);
-                return {
-                    sessionId: snapshot.sessionId,
-                    agentNativeSessionId: snapshot.agentNativeSessionId,
-                    name: snapshot.name,
-                    status: snapshot.status,
-                };
-            })],
+        sessions: [...collaborationRemoteSessions(), ...globalSessionState.sessions.map(orchestrationSessionSnapshot)],
     });
+}
+async function inspectCollaborationTmux(binding, requestedPane) {
+    if (!binding.tmuxSessionName)
+        return { state: 'offline', reason: 'TMUX_BINDING_MISSING' };
+    const name = `=${binding.tmuxSessionName}`;
     try {
-        session.ptyProcess.write(buildBracketedSubmitBytes(prompt));
+        await runTmux(['has-session', '-t', name]);
     }
     catch (error) {
-        for (const message of pending)
-            collaborationStore.recordTransport(message.id, {
-                relay_online: null, peer_reachable: true, attempt_count: (collaborationStore.diagnostic(message.id)?.attempt_count ?? 0) + 1,
-                next_retry_at: Date.now() + 2_000, last_error: `PTY_WRITE_FAILED: ${getErrorMessage(error)}`, checked_at: Date.now(),
-            });
-        setTimeout(() => tryDeliverCollaborationInbox(frontendSessionId), 2_000).unref?.();
-        return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId), reason: '终端写入失败，消息已保留并等待重试' };
+        if (/can't find session|no server running|no sessions|error connecting.*No such file/i.test(getErrorMessage(error))) {
+            return { state: 'offline', reason: 'TMUX_SESSION_NOT_RUNNING' };
+        }
+        throw error;
     }
-    collaborationStore.markDelivered(pending.map((message) => message.id));
-    const remaining = collaborationStore.pendingCount(frontendSessionId);
-    if (remaining)
-        setTimeout(() => tryDeliverCollaborationInbox(frontendSessionId), 300).unref?.();
-    return { delivered: pending.map((message) => message.id), pending: remaining };
+    const layout = await getTmuxLayout(binding.tmuxSessionName);
+    if (layout.sessionName !== binding.tmuxSessionName)
+        throw new Error('TMUX_SESSION_IDENTITY_CHANGED');
+    const serverPid = Number((await runTmux(['display-message', '-p', '#{pid}'])).trim());
+    if (!Number.isInteger(serverPid) || serverPid <= 0)
+        throw new Error('TMUX_SERVER_IDENTITY_UNAVAILABLE');
+    const panes = await Promise.all(layout.windows.flatMap((window) => window.panes).map(async (pane) => {
+        const program = await resolveTmuxPaneProgram(pane);
+        const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
+        const nativeSessionId = agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null;
+        return { serverPid, sessionId: layout.sessionId, paneId: pane.id, panePid: pane.pid,
+            agentSlug: agent?.slug ?? '', nativeSessionId, cwd: pane.currentPath };
+    }));
+    return selectCollaborationPane(binding, requestedPane ? panes.filter((pane) => pane.paneId === requestedPane) : panes);
+}
+async function rebindCollaborationRoute(frontendSessionId, paneId) {
+    await collaborationDeliveryWorker.reconfigure(frontendSessionId, async () => {
+        const record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
+        if (!record)
+            throw new Error('SESSION_REMOVED');
+        const previous = collaborationRouting.get(frontendSessionId);
+        const binding = {
+            sessionId: frontendSessionId, backendSessionId: previous?.backendSessionId ?? record.backendSessionId,
+            mode: record.mode, tmuxSessionName: record.tmuxSessionName ?? previous?.tmuxSessionName ?? null,
+            agentSlug: null, nativeSessionId: null, pane: null,
+        };
+        if (binding.mode === 'tmux') {
+            const inspected = await inspectCollaborationTmux(binding, paneId);
+            if (inspected.state !== 'ready' || !inspected.pane)
+                throw new Error(inspected.reason ?? 'AGENT_NOT_RUNNING');
+            const pane = inspected.pane;
+            binding.pane = { serverPid: pane.serverPid, sessionId: pane.sessionId, paneId: pane.paneId, panePid: pane.panePid,
+                agentSlug: pane.agentSlug, nativeSessionId: pane.nativeSessionId };
+            binding.agentSlug = pane.agentSlug;
+            binding.nativeSessionId = pane.nativeSessionId;
+        }
+        else {
+            if (paneId)
+                throw new Error('PANE_REQUIRES_TMUX');
+            const backend = binding.backendSessionId ? terminalSessions.get(binding.backendSessionId) : null;
+            if (!backend)
+                throw new Error('SHELL_BACKEND_NOT_RUNNING');
+            await refreshCollaborationAgentIdentity(binding.backendSessionId, backend);
+            const agent = detectSessionAgent(backend);
+            if (!agent)
+                throw new Error('AGENT_NOT_RUNNING');
+            binding.agentSlug = agent.slug;
+            binding.nativeSessionId = backend.agentSession?.sessionId ?? null;
+        }
+        if (!globalSessionState.sessions.some((candidate) => candidate.sessionId === frontendSessionId))
+            throw new Error('SESSION_REMOVED');
+        collaborationRouting.bind(binding);
+    });
+    collaborationDeliveryWorker.wake(frontendSessionId);
+    return { ...collaborationRouting.get(frontendSessionId), state: 'recovering' };
+}
+async function resolveCollaborationRoute(frontendSessionId) {
+    let record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
+    if (!record)
+        return { state: 'offline', reason: 'SESSION_REMOVED' };
+    let backend = resolveOrchestrationBackend(record);
+    let binding = collaborationRouting.get(frontendSessionId) ?? {
+        sessionId: record.sessionId, backendSessionId: null, mode: record.mode, tmuxSessionName: record.tmuxSessionName,
+        agentSlug: record.agentResume?.slug ?? null, nativeSessionId: record.agentResume?.sessionId ?? null, pane: null,
+    };
+    if (binding.mode === 'tmux') {
+        const inspected = await inspectCollaborationTmux(binding);
+        if (inspected.state !== 'ready' || !inspected.pane)
+            return inspected;
+        record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
+        if (!record)
+            return { state: 'offline', reason: 'SESSION_REMOVED_DURING_RECOVERY' };
+        const pane = inspected.pane;
+        // Remember the target before attachment. A failed attachment must not let
+        // a subsequent active-pane change silently choose another recipient.
+        const pinned = { serverPid: pane.serverPid, sessionId: pane.sessionId, paneId: pane.paneId, panePid: pane.panePid,
+            agentSlug: pane.agentSlug, nativeSessionId: pane.nativeSessionId ?? binding.nativeSessionId };
+        binding = { ...binding, pane: pinned, agentSlug: pinned.agentSlug, nativeSessionId: pinned.nativeSessionId };
+        collaborationRouting.bind(binding);
+        if (!backend) {
+            const cwd = pane.cwd || record.cwd;
+            if (!cwd)
+                return { state: 'detached', reason: 'TMUX_ATTACH_CWD_UNAVAILABLE' };
+            await pathValidator.allowSessionCwd(cwd);
+            // Attach only. Never recreate a vanished session or launch/resume an
+            // Agent in response to a queued collaboration message.
+            const spawned = await spawnTerminalSession({}, { cwd, mode: 'tmux',
+                tmuxSessionName: binding.tmuxSessionName, attachExistingOnly: true, tmuxAttachTarget: pane.sessionId });
+            record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
+            if (!record)
+                return { state: 'offline', reason: 'SESSION_REMOVED_DURING_RECOVERY' };
+            if (!terminalSessions.has(spawned.sessionId))
+                return { state: 'detached', reason: 'TMUX_ATTACH_EXITED' };
+            binding = { ...binding, backendSessionId: spawned.sessionId };
+            collaborationRouting.bind(binding);
+            backend = resolveOrchestrationBackend(record);
+        }
+        if (!backend)
+            return { state: 'detached', reason: 'TMUX_BACKEND_UNAVAILABLE' };
+        return { state: 'ready', write: async (messages) => {
+                if (!globalSessionState.sessions.some((candidate) => candidate.sessionId === frontendSessionId))
+                    throw new Error('SESSION_REMOVED');
+                await writeCollaborationTmuxPane(runTmux, pinned, formatLocalCollaborationMessages(frontendSessionId, messages));
+                backend.lastActivity = Date.now();
+            } };
+    }
+    if (!backend || !binding.backendSessionId)
+        return { state: 'offline', reason: 'SHELL_BACKEND_NOT_RUNNING' };
+    await refreshCollaborationAgentIdentity(binding.backendSessionId, backend);
+    if (!detectSessionAgent(backend))
+        return { state: 'agent-exited', reason: 'AGENT_NOT_RUNNING' };
+    if ((binding.agentSlug && backend.agent?.slug !== binding.agentSlug)
+        || (binding.nativeSessionId && backend.agentSession?.sessionId && backend.agentSession.sessionId !== binding.nativeSessionId)) {
+        return { state: 'identity-mismatch', reason: 'AGENT_IDENTITY_CHANGED' };
+    }
+    const target = backend;
+    return { state: 'ready', write: async (messages) => {
+            if (!globalSessionState.sessions.some((candidate) => candidate.sessionId === frontendSessionId))
+                throw new Error('SESSION_REMOVED');
+            if (terminalSessions.get(binding.backendSessionId) !== target)
+                throw new Error('SHELL_BACKEND_CHANGED');
+            target.ptyProcess.write(buildBracketedSubmitBytes(formatLocalCollaborationMessages(frontendSessionId, messages)));
+            target.lastActivity = Date.now();
+        } };
 }
 async function refreshCollaborationAgentIdentity(backendSessionId, session) {
     let activeProgram = null;
@@ -1434,33 +1587,12 @@ async function refreshCollaborationAgentIdentity(backendSessionId, session) {
             ? { ...resolved, updatedAt: Date.now() }
             : getActiveProgramFromTmuxLayout(layout);
     }
-    if (!activeProgram)
-        return;
     session.activeProgram = activeProgram;
-    persistActiveProgramBinding(backendSessionId, activeProgram.command);
+    persistActiveProgramBinding(backendSessionId, activeProgram?.command);
     syncAgentIdentity(backendSessionId, session);
 }
 function deliverCollaborationInboxWhenAgentReady(frontendSessionId, backendSessionId, attempt = 0) {
-    const session = terminalSessions.get(backendSessionId);
-    if (!session)
-        return;
-    if (canDeliverPromptToAgent(session)) {
-        setTimeout(() => tryDeliverCollaborationInbox(frontendSessionId), 300).unref?.();
-        return;
-    }
-    if (attempt >= 60)
-        return;
-    void refreshCollaborationAgentIdentity(backendSessionId, session)
-        .catch(() => undefined)
-        .finally(() => {
-        if (canDeliverPromptToAgent(session)) {
-            setTimeout(() => tryDeliverCollaborationInbox(frontendSessionId), 300).unref?.();
-            return;
-        }
-        setTimeout(() => {
-            deliverCollaborationInboxWhenAgentReady(frontendSessionId, backendSessionId, attempt + 1);
-        }, 250).unref?.();
-    });
+    collaborationDeliveryWorker.wake(frontendSessionId);
 }
 async function spawnCollaborationAgentSession(req, group, sourceSessionId, input) {
     const agentSlug = typeof input.agentSlug === 'string' ? input.agentSlug.trim().toLowerCase() : '';
@@ -4435,7 +4567,22 @@ function ptyHostShellModeEnabled() {
     const isBun = typeof globalThis.Bun !== 'undefined';
     return process.platform !== 'win32' && !isBun && process.env.TERMDOCK_PTY_HOST !== 'off';
 }
+const tmuxBackendSpawns = new Map();
 async function spawnTerminalSession(req, input) {
+    const name = input.mode === 'tmux' && input.tmuxSessionName ? normalizeTmuxSessionName(input.tmuxSessionName) : null;
+    if (!name)
+        return spawnTerminalSessionUnlocked(req, input);
+    const pending = tmuxBackendSpawns.get(name);
+    if (pending)
+        return pending;
+    const existing = findBackendSessionForTmux(name);
+    if (existing)
+        return { sessionId: existing[0], session: existing[1], cols: existing[1].cols, rows: existing[1].rows };
+    const operation = spawnTerminalSessionUnlocked(req, input).finally(() => tmuxBackendSpawns.delete(name));
+    tmuxBackendSpawns.set(name, operation);
+    return operation;
+}
+async function spawnTerminalSessionUnlocked(req, input) {
     const cwd = await resolveWorkingDirectory(req, input.cwd);
     const cols = input.cols || 80;
     const rows = input.rows || 24;
@@ -4446,19 +4593,28 @@ async function spawnTerminalSession(req, input) {
     if (mode === 'tmux') {
         const tmuxStatus = await getTmuxStatus();
         if (!tmuxStatus.available) {
+            if (input.attachExistingOnly)
+                throw new Error('TMUX_UNAVAILABLE');
             console.warn('[termdock] tmux not available, falling back to shell mode:', tmuxStatus.reason);
             mode = 'shell';
         }
     }
     const tmuxSessionName = mode === 'tmux' ? normalizeTmuxSessionName(input.tmuxSessionName) : null;
     if (mode === 'tmux' && tmuxSessionName) {
-        await prepareManagedTmuxSession(tmuxSessionName, cwd);
+        if (input.attachExistingOnly) {
+            if (!await tmuxSessionExists(input.tmuxAttachTarget ?? `=${tmuxSessionName}`))
+                throw new Error('TMUX_SESSION_NOT_RUNNING');
+        }
+        else
+            await prepareManagedTmuxSession(tmuxSessionName, cwd);
     }
     const command = mode === 'tmux'
         ? getTmuxBinary()
         : (process.platform === 'win32' ? 'powershell.exe' : resolveShellCandidates()[0]);
+    const supportsFeatures = mode === 'tmux' && await supportsTmuxClientFeatures(command);
     const args = mode === 'tmux' && tmuxSessionName
-        ? buildTmuxAttachArgs(tmuxSessionName, await supportsTmuxClientFeatures(command))
+        ? [...buildTmuxAttachArgs(input.tmuxAttachTarget ?? tmuxSessionName, supportsFeatures),
+            ...(input.attachExistingOnly && supportsFeatures ? ['-f', 'ignore-size'] : [])]
         : (process.platform === 'win32' ? buildPowerShellCwdHookArgs() : []);
     const envPath = buildAugmentedPath();
     const resolvedEnv = buildInteractiveColorEnvironment({
@@ -5393,7 +5549,8 @@ router.post('/operations/orchestration/spawn', async (req, res) => {
         res.status(400).json({ error: getErrorMessage(error) });
     }
 });
-router.use('/operations/orchestration', collaborationRoutes({ store: collaborationStore, resolveSession: resolveFrontendSessionId, deliver: tryDeliverCollaborationInbox }));
+router.use('/operations/orchestration', collaborationRoutes({ store: collaborationStore, resolveSession: resolveFrontendSessionId,
+    deliver: tryDeliverCollaborationInbox, rebind: rebindCollaborationRoute }));
 router.get('/operations/session-search', (req, res) => {
     const query = typeof req.query.q === 'string' ? req.query.q : '';
     const results = sessionSearchStore.search(query, Number(req.query.limit) || 30).map((result) => {

package/dist/server/utils/publicSecurity.js

@@ -34,7 +34,7 @@ export const securityHeaders = (req, res, next) => {
     const shellSource = /^[a-z0-9.\-:\[\]]+$/i.test(host) ? `http://${host}/preview-shell.html https://${host}/preview-shell.html` : "'none'";
     const shell = req.path === '/preview-shell.html';
     res.setHeader('Content-Security-Policy', shell
-        ? "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline' blob: https: http:; style-src 'unsafe-inline' blob: https:; img-src blob: data: https:; font-src blob: data: https:; media-src blob: data: https:; connect-src https:; frame-src 'none'; frame-ancestors 'self'; object-src 'none'; base-uri https://termdock-preview.invalid; form-action 'none'"
+        ? "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline' 'wasm-unsafe-eval' blob: https: http:; style-src 'unsafe-inline' blob: https:; img-src blob: data: https:; font-src blob: data: https:; media-src blob: data: https:; connect-src blob: https: wss:; worker-src blob:; frame-src 'none'; frame-ancestors 'self'; object-src 'none'; base-uri https://termdock-preview.invalid; form-action 'none'"
         : preview
             ? "sandbox allow-scripts; frame-ancestors 'self'; object-src 'none'; base-uri 'self'"
             : `script-src 'self' 'wasm-unsafe-eval'; script-src-attr 'none'; worker-src 'self' blob:; frame-src ${shellSource}; frame-ancestors 'self'; object-src 'none'; base-uri 'self'`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.178",
+  "version": "1.4.180",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",
@@ -119,6 +119,7 @@
     "concurrently": "^8.2.0",
     "cross-env": "^10.1.0",
     "electron": "^43.2.0",
+    "es-module-shims": "^2.8.4",
     "esbuild": "^0.27.7",
     "eslint": "^9.39.2",
     "jsdom": "^24.0.0",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.178",
+  "version": "1.4.180",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-kSujny2SLOFnZ1ffxm1FYtli7g1vEN8d3vj1oQeLLdc=",
-  "serverBundleHash": "sha256-wG7h9fvsMN8idDY+H+dioaPsjuM+ojnCMxgwFMeS61M=",
-  "clientBundleHash": "sha256-Wjd5odYe+uZp1t365akaiTeCrJ6DjjG2XFJwMyCO3Cg=",
+  "serverBundleHash": "sha256-OJ83J67z97pdLmRW6AEkj8r5LkhdkmNIeAxu2L4niig=",
+  "clientBundleHash": "sha256-uS0kVZf+KwoYUsvNs5oQQ2EOdE7L45iUtfuHunLnQ2Q=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }