termdock 1.4.190 → 1.4.192

package/dist/server/routes/terminal.js

@@ -13,7 +13,7 @@ import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 import QRCode from 'qrcode';
 import { execFile, spawn } from 'child_process';
-import { createHash, randomUUID } from 'crypto';
+import { createHash, randomBytes, randomUUID } from 'crypto';
 import { promisify } from 'util';
 import { caffeinateManager } from '../utils/caffeinate.js';
 import { DesktopRuntimeOwnerClient } from '../utils/desktopRuntimeOwner.js';
@@ -39,13 +39,13 @@ import { buildBracketedSubmitBytes, canDeliverPromptToAgent } from '../agent/pro
 import { collaborationRoutes } from '../agent/collaborationRoutes.js';
 import { COLLAB_LIMITS, extrasFromBody } from '../agent/collaborationProtocol.js';
 import { CollaborationStore } from '../agent/collaborationStore.js';
-import { formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
-import { resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
+import { COLLAB_NAME_FORBIDDEN, formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
+import { buildCollaborationSpawnCommand, 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 { approveCollaborationDialog, captureTmuxPaneHistory, captureTmuxPaneText, recoverStuckPaste, sendTmuxPaneKey, 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';
@@ -152,6 +152,18 @@ class HttpStatusError extends Error {
 }
 const terminalSessions = new Map();
 let globalSessionState = { sessions: [], updatedAt: Date.now() };
+/** 8-char base36 frontend session ids. Dozens of sessions live at once, so a
+ * short collision-checked id beats a 36-char UUID to type in CLI operations;
+ * the random draw is retried when it hits an existing session. Each of the 8
+ * bytes maps to one base36 character — toString(36) turns the 0-35 residue
+ * into a single 0-9a-z char, never a multi-digit number string. */
+function generateFrontendSessionId() {
+    for (;;) {
+        const id = [...randomBytes(8)].map((byte) => (byte % 36).toString(36)).join('');
+        if (!globalSessionState.sessions.some((session) => session.sessionId === id))
+            return id;
+    }
+}
 // ── 持久化 globalSessionState 到磁盘，防止服务重启后丢失 ──
 const GLOBAL_SESSION_STATE_FILE = `${TERMDOCK_DIR}/global-session-state.json`;
 const CLIENT_STATES_FILE = `${TERMDOCK_DIR}/client-states.json`; // 保留用于迁移
@@ -1043,6 +1055,10 @@ function removeGlobalSessionRecord(frontendSessionId) {
     if (changed) {
         collaborationStore.removeSession(frontendSessionId);
         collaborationRouting.remove(frontendSessionId);
+        for (const key of [...collaborationScaffoldState.keys()]) {
+            if (key.startsWith(`${frontendSessionId}|`))
+                collaborationScaffoldState.delete(key);
+        }
     }
     return changed;
 }
@@ -1243,7 +1259,7 @@ async function openInventorySession(req, input) {
         throw new HttpStatusError(404, 'session not found');
     }
     if (!record) {
-        const sessionId = preferredFrontendSessionId || randomUUID();
+        const sessionId = preferredFrontendSessionId || generateFrontendSessionId();
         const defaultName = normalizedMode === 'tmux' && normalizedTmuxName
             ? `tmux:${normalizedTmuxName}`
             : `terminal-${now.toString(36)}`;
@@ -1433,13 +1449,33 @@ function tryDeliverCollaborationInbox(frontendSessionId) {
     }
     collaborationDeliveryWorker.wake(frontendSessionId);
     const route = collaborationDeliveryWorker.state(frontendSessionId);
-    return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId),
+    return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId), waitable: true,
         reason: route.reason ?? '消息已入队，后台正在恢复路由并投递' };
 }
+// Per-session routing-help education state: static help (peer roster + help
+// pointer) rides only the first delivery, then returns when the roster
+// changes (a new member joined). In-memory only — a restart simply re-educates
+// once, which is harmless. Dynamic notices are never gated by this.
+const collaborationScaffoldState = new Map();
+function collaborationRosterSignature(frontendSessionId) {
+    const peerIds = new Set(collaborationStore.groupsForSession(frontendSessionId)
+        .flatMap((group) => group.sessionIds ?? []).filter((id) => id !== frontendSessionId));
+    return [...peerIds].sort().join('|');
+}
 function formatLocalCollaborationMessages(frontendSessionId, messages) {
+    const signature = collaborationRosterSignature(frontendSessionId);
+    // Education follows the bound agent identity, not just the pane: a rebind to
+    // a different agent session must re-educate the newcomer.
+    const binding = collaborationRouting.get(frontendSessionId);
+    const educationKey = `${frontendSessionId}|${binding?.agentSlug ?? ''}|${binding?.nativeSessionId ?? ''}`;
+    const educated = collaborationScaffoldState.get(educationKey);
+    const showRoutingHelp = !educated || educated.rosterSignature !== signature;
+    if (showRoutingHelp)
+        collaborationScaffoldState.set(educationKey, { rosterSignature: signature });
     return formatCollaborationDelivery({ targetSessionId: frontendSessionId, messages,
         groups: collaborationStore.groupsForSession(frontendSessionId),
         sessions: [...collaborationRemoteSessions(), ...globalSessionState.sessions.map(orchestrationSessionSnapshot)],
+        showRoutingHelp,
     });
 }
 async function inspectCollaborationTmux(binding, requestedPane) {
@@ -1511,6 +1547,12 @@ async function rebindCollaborationRoute(frontendSessionId, paneId) {
     collaborationDeliveryWorker.wake(frontendSessionId);
     return { ...collaborationRouting.get(frontendSessionId), state: 'recovering' };
 }
+/**
+ * Delivery is deliberately un-gated: any reachable recipient receives the
+ * message immediately, whatever its agent is doing. Busy guessing (hook state,
+ * turn phase) is the sender's job — the send receipt carries a screen
+ * snapshot of the recipient after the write, and the sender judges from that.
+ */
 async function resolveCollaborationRoute(frontendSessionId) {
     let record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
     if (!record)
@@ -1554,12 +1596,16 @@ async function resolveCollaborationRoute(frontendSessionId) {
         }
         if (!backend)
             return { state: 'detached', reason: 'TMUX_BACKEND_UNAVAILABLE' };
-        return { state: 'ready', write: async (messages) => {
+        return { state: 'ready', capture: async () => (await captureTmuxPane(pinned.paneId)).content, 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();
-            } };
+                // First-delivery confirm: history proves the agent rendered our
+                // message (boot sequences clear only the screen, never the history a
+                // live TUI writes into). Terminal-state only — no agent hooks.
+            }, confirm: async () => captureTmuxPaneHistory(runTmux, pinned), approve: async () => approveCollaborationDialog(runTmux, pinned),
+            recoverStuck: async (baseline) => recoverStuckPaste(runTmux, pinned, baseline) };
     }
     if (!backend || !binding.backendSessionId)
         return { state: 'offline', reason: 'SHELL_BACKEND_NOT_RUNNING' };
@@ -1597,7 +1643,7 @@ async function refreshCollaborationAgentIdentity(backendSessionId, session) {
     persistActiveProgramBinding(backendSessionId, activeProgram?.command);
     syncAgentIdentity(backendSessionId, session);
 }
-function deliverCollaborationInboxWhenAgentReady(frontendSessionId, backendSessionId, attempt = 0) {
+function deliverCollaborationInboxWhenAgentReady(frontendSessionId) {
     collaborationDeliveryWorker.wake(frontendSessionId);
 }
 async function spawnCollaborationAgentSession(req, group, sourceSessionId, input) {
@@ -1618,6 +1664,9 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
         fallbackMode: fallbackRecord?.mode,
     });
     const requestedName = typeof input.name === 'string' ? input.name.trim().slice(0, 120) : '';
+    if (requestedName && COLLAB_NAME_FORBIDDEN.test(requestedName)) {
+        throw new HttpStatusError(400, '会话名称不能包含「【】」、间隔号「·」、换行或控制字符', 'COLLAB_NAME_INVALID');
+    }
     const requestedCwd = typeof input.cwd === 'string' ? input.cwd.trim() : '';
     const opened = await openInventorySession(req, {
         name: requestedName || `${launcher.displayName} · ${group.name}`,
@@ -1634,7 +1683,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
         name: group.name,
         sessionIds: [...group.sessionIds, frontendSessionId],
     });
-    writeTerminalInput(backend, `${launcher.command}\r`);
+    writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: launcher.command })}\r`);
     const requestedTask = typeof input.task === 'string' ? input.task.trim().slice(0, 20_000) : '';
     collaborationStore.send({
         groupId: updatedGroup.id,
@@ -1644,7 +1693,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
         content: requestedTask || `你已创建并加入协作组“${updatedGroup.name}”。请运行 td collab status 查看成员，并准备参与协作。`,
     });
     setTimeout(() => {
-        deliverCollaborationInboxWhenAgentReady(frontendSessionId, opened.terminalSession.sessionId);
+        deliverCollaborationInboxWhenAgentReady(frontendSessionId);
     }, 300).unref?.();
     return { group: updatedGroup, session: orchestrationSessionSnapshot(globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId)) };
 }
@@ -4858,7 +4907,7 @@ async function adoptPtyHostSessions() {
         if (!existing) {
             const now = Date.now();
             upsertGlobalSessionRecord({
-                sessionId: randomUUID(),
+                sessionId: generateFrontendSessionId(),
                 name: `terminal-${now.toString(36)}`,
                 backendSessionId: meta.id,
                 mode: 'shell',
@@ -5541,8 +5590,217 @@ router.post('/operations/orchestration/spawn', async (req, res) => {
         res.status(400).json({ error: getErrorMessage(error) });
     }
 });
+/**
+ * Session cleanup for the collaboration CLI. Two semantic guards make the
+ * destructive surface safe from inside a group:
+ *  - a target must share a collaboration group with the caller (personal
+ *    sessions stay reachable only from the web UI), and the caller can never
+ *    clean its own session;
+ *  - cleanup refuses when removing a target would dissolve a group the caller
+ *    still belongs to (groups under 2 members are dropped with their whole
+ *    message history — dissolving your own group needs a deliberate group op,
+ *    not a member cleanup).
+ * Every execution is a two-step human-granted act: without `confirmed: true`
+ * the route only reports the plan (records, groups, tmux sessions that would
+ * be destroyed) and refuses; an agent must relay that plan to the user and
+ * re-run with explicit confirmation before anything is deleted.
+ */
+router.post('/operations/orchestration/cleanup', async (req, res) => {
+    const sourceSessionId = resolveFrontendSessionId(req.body ?? {});
+    if (!sourceSessionId)
+        return res.status(400).json({ error: '无法识别当前会话；请从 Termdock 会话内运行 td collab' });
+    const requested = Array.isArray(req.body?.sessionIds)
+        ? [...new Set(req.body.sessionIds.filter((id) => typeof id === 'string' && id.trim().length > 0))]
+        : [];
+    if (requested.length === 0)
+        return res.status(400).json({ error: '至少需要一个待清理的会话 id' });
+    if (requested.includes(sourceSessionId))
+        return res.status(400).json({ error: '不能清理当前会话自身；如需退出协作请使用组操作或网页端' });
+    const recordsById = new Map(globalSessionState.sessions.map((session) => [session.sessionId, session]));
+    const missing = requested.filter((id) => !recordsById.has(id));
+    if (missing.length > 0)
+        return res.status(404).json({ error: `以下会话不存在（可能已清理或已离线）：${missing.join('、')}` });
+    const label = (sessionId) => recordsById.get(sessionId)?.name.trim() || sessionId;
+    // Targets must share a collaboration group with the caller: CLI cleanup only
+    // covers orchestration peers, never unrelated personal terminals.
+    const callerGroupIds = new Set(collaborationStore.groupsForSession(sourceSessionId).map((group) => group.id));
+    const outsiders = requested.filter((id) => !collaborationStore.groupsForSession(id).some((group) => callerGroupIds.has(group.id)));
+    if (outsiders.length > 0) {
+        return res.status(403).json({ error: `目标会话不在你的协作组中，CLI 无法清理：${outsiders.map(label).join('、')}（个人会话请在网页端删除）` });
+    }
+    const requestedSet = new Set(requested);
+    const groupEffects = [];
+    for (const id of requested) {
+        for (const group of collaborationStore.groupsForSession(id)) {
+            if (groupEffects.some((effect) => effect.id === group.id))
+                continue;
+            const remaining = group.sessionIds.filter((member) => !requestedSet.has(member)).length;
+            groupEffects.push({
+                id: group.id, name: group.name ?? null, sizeBefore: group.sessionIds.length,
+                sizeAfter: remaining < 2 ? 0 : remaining, dissolves: remaining < 2,
+                includesCaller: group.sessionIds.includes(sourceSessionId),
+            });
+        }
+    }
+    const dissolvingOwn = groupEffects.find((effect) => effect.dissolves && effect.includesCaller);
+    if (dissolvingOwn) {
+        return res.status(403).json({ error: `清理会使你所在的协作组「${dissolvingOwn.name ?? dissolvingOwn.id}」解散（剩余成员不足 2，组内消息会被一并清除）；如需解散协作组请在网页端操作，组保留时再清理成员会话` });
+    }
+    const targets = requested.map((sessionId) => {
+        const record = recordsById.get(sessionId);
+        return { sessionId: record.sessionId, name: record.name.trim() || null, mode: record.mode,
+            tmuxSessionName: record.mode === 'tmux' ? (record.tmuxSessionName ?? null) : null,
+            backendSessionId: record.backendSessionId ?? null };
+    });
+    const plan = { targets, groups: groupEffects };
+    if (req.body?.confirmed !== true) {
+        return res.json({ ok: false, code: 'CLEANUP_CONFIRM_REQUIRED',
+            error: '不可恢复的风险操作：执行前必须先获得用户（人类）的明确同意',
+            instruction: `将清理计划告知用户并取得明确同意后重跑：td collab cleanup ${requested.join(' ')} --confirm`,
+            plan });
+    }
+    const removed = [];
+    for (const sessionId of requested) {
+        const record = globalSessionState.sessions.find((candidate) => candidate.sessionId === sessionId);
+        if (!record) {
+            removed.push({ sessionId, name: null });
+            continue;
+        }
+        archiveAgentResumeRecord(record, 'closed');
+        removeGlobalSessionRecord(sessionId);
+        if (record.mode === 'tmux' && record.tmuxSessionName) {
+            try {
+                const outcome = await destroyTmuxSessionSafely(record.tmuxSessionName);
+                removed.push({ sessionId, name: record.name.trim() || null, mode: record.mode, tmuxSessionName: record.tmuxSessionName, alreadyGone: outcome.alreadyGone === true });
+            }
+            catch (error) {
+                console.error(`[cleanup] tmux teardown failed for ${record.tmuxSessionName}:`, getErrorMessage(error));
+                removed.push({ sessionId, name: record.name.trim() || null, mode: record.mode, tmuxSessionName: record.tmuxSessionName, failure: getErrorMessage(error) });
+            }
+        }
+        else {
+            let killed = false;
+            if (record.backendSessionId && terminalSessions.has(record.backendSessionId)) {
+                try {
+                    cleanupSession(record.backendSessionId, { killProcess: true });
+                    killed = true;
+                }
+                catch (error) {
+                    console.error(`[cleanup] pty teardown failed for ${sessionId}:`, getErrorMessage(error));
+                }
+            }
+            removed.push({ sessionId, name: record.name.trim() || null, mode: record.mode, tmuxSessionName: null, killed });
+        }
+    }
+    await persistGlobalStateNow();
+    broadcastClientState();
+    res.json({ ok: true, removed, plan });
+});
+// Drive a collaboration member's terminal: inject one named key, or dismiss
+// an interactive approval dialog. Wrapping key injection in our own CLI keeps
+// every manipulation of another session explicit and auditable — no ad-hoc
+// tmux calls. Scope mirrors cleanup: only members sharing a group with the
+// caller, tmux-local only, and `approve` refuses unless an approval dialog is
+// actually showing (Enter on the highlighted option). The dialogs may be
+// approving any command the member agent asked for; the caller is presumed to
+// own that decision (the delivery confirm gate uses the same primitive).
+const DRIVE_KEYS = new Set(['enter', 'escape', 'space', 'left', 'right', 'up', 'down']);
+router.post('/operations/orchestration/drive', async (req, res) => {
+    const sourceSessionId = resolveFrontendSessionId(req.body ?? {});
+    if (!sourceSessionId)
+        return res.status(400).json({ error: '无法识别当前会话；请从 Termdock 会话内运行 td collab' });
+    const target = typeof req.body?.session === 'string' ? req.body.session.trim() : '';
+    const action = typeof req.body?.action === 'string' ? req.body.action.trim() : '';
+    if (!target || !action)
+        return res.status(400).json({ error: 'drive 需要目标会话 id 与动作（approve|enter|escape|space|left|right|up|down|capture|run）' });
+    if (target === sourceSessionId)
+        return res.status(400).json({ error: '不能驱动当前会话自身' });
+    const record = globalSessionState.sessions.find((candidate) => candidate.sessionId === target);
+    if (!record)
+        return res.status(404).json({ error: '目标会话不存在（可能已清理或已离线）' });
+    const callerGroups = collaborationStore.groupsForSession(sourceSessionId).map((group) => group.id);
+    if (!collaborationStore.groupsForSession(target).some((group) => callerGroups.includes(group.id))) {
+        return res.status(403).json({ error: '目标会话不在你的协作组中，CLI 无法驱动；如需操作个人会话请在网页端进行' });
+    }
+    if (record.mode !== 'tmux' || !record.tmuxSessionName) {
+        return res.status(409).json({ error: '目标会话不是 tmux 会话，无法从 CLI 驱动（模式：' + (record.mode ?? 'unknown') + '）' });
+    }
+    const binding = collaborationRouting.get(target);
+    const pane = binding?.pane ?? null;
+    if (!pane)
+        return res.status(409).json({ error: '目标会话还没有可驱动的已固定终端面板（agent 可能尚未启动或已离线）' });
+    try {
+        if (action === 'approve') {
+            const approved = await approveCollaborationDialog(runTmux, pane);
+            if (!approved)
+                return res.status(409).json({ ok: false, code: 'NO_APPROVAL_DIALOG', error: '目标面板当前没有显示审批对话框；未发送任何按键' });
+            return res.json({ ok: true, action, sessionId: target, approved: true });
+        }
+        if (action === 'capture') {
+            const snapshot = await captureTmuxPaneText(runTmux, pane);
+            return res.json({ ok: true, action, sessionId: target, snapshot });
+        }
+        if (action === 'run') {
+            const text = typeof req.body?.text === 'string' ? req.body.text.trim() : '';
+            if (!text)
+                return res.status(400).json({ error: 'run 需要一行文本（放在请求的 text 字段）' });
+            if (text.length > 10_000)
+                return res.status(400).json({ error: 'run 文本过长（上限 10000 字符）；需要更多内容请走 td collab send 投递' });
+            // Same bracketed-paste write path deliveries use: one line, one submit,
+            // embedded newlines stay inside the recipient's editor.
+            await writeCollaborationTmuxPane(runTmux, pane, text);
+            const snapshot = await captureTmuxPaneText(runTmux, pane);
+            return res.json({ ok: true, action, sessionId: target, text, snapshot });
+        }
+        if (!DRIVE_KEYS.has(action)) {
+            return res.status(400).json({ error: `未知动作 ${action}；可用：approve|enter|escape|space|left|right|up|down|capture|run` });
+        }
+        await sendTmuxPaneKey(runTmux, pane, action);
+        res.json({ ok: true, action, sessionId: target });
+    }
+    catch (error) {
+        res.status(409).json({ ok: false, code: 'DRIVE_FAILED', error: getErrorMessage(error) });
+    }
+});
 router.use('/operations/orchestration', collaborationRoutes({ store: collaborationStore, resolveSession: resolveFrontendSessionId,
-    deliver: tryDeliverCollaborationInbox, rebind: rebindCollaborationRoute }));
+    deliver: tryDeliverCollaborationInbox, rebind: rebindCollaborationRoute,
+    resolveNames: (ids) => {
+        const names = new Map([...collaborationRemoteSessions(),
+            ...globalSessionState.sessions.map(orchestrationSessionSnapshot)].map((session) => [session.sessionId, session.name]));
+        return Object.fromEntries(ids.map((id) => [id, names.get(id) ?? null]));
+    },
+    // Same semantics as the inventory PATCH rename: a display name that wins
+    // over auto-titles (customName=true clears autoTitle) and is pushed into
+    // the tmux @termdock-friendly-name option. Names arrive pre-cleaned from
+    // the collaboration route.
+    renameSession: async (frontendSessionId, name) => {
+        const index = globalSessionState.sessions.findIndex((session) => session.sessionId === frontendSessionId);
+        if (index < 0)
+            return { ok: false, code: 'SESSION_NOT_FOUND', error: 'session not found' };
+        const next = { ...globalSessionState.sessions[index], lastActivity: Date.now(),
+            name, customName: true, autoTitle: null };
+        if (next.mode === 'tmux' && next.tmuxSessionName) {
+            try {
+                await setTmuxOption(next.tmuxSessionName, '@termdock-friendly-name', name);
+            }
+            catch (error) {
+                console.warn(`[collab] failed to set friendly name on ${next.tmuxSessionName}: ${getErrorMessage(error)}`);
+            }
+        }
+        upsertGlobalSessionRecord(next);
+        await persistGlobalStateNow();
+        // The broadcast inventory must not be a stale (≤1.5s TTL) cache build:
+        // browsers apply the inventory over the session list, so an old cached
+        // name would keep the sidebar showing the previous title.
+        try {
+            await getSessionInventorySnapshot({ refresh: true });
+        }
+        catch (error) {
+            console.warn('[collab] failed to refresh inventory after rename:', getErrorMessage(error));
+        }
+        broadcastClientState();
+        return { ok: true };
+    } }));
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.190",
+  "version": "1.4.192",
   "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.190",
+  "version": "1.4.192",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-oNkzCv5hSYAirgwQMVMQLGGEhu1GuhpHYUODkc7g0Eg=",
-  "clientBundleHash": "sha256-YR2GZIYxr5gypWl/+mLDzxUCC12obrg4Gp1mWhDKV8k=",
+  "serverBundleHash": "sha256-jIRqCSStnF2/E81Q9GtAEeXAsshmnR4UUDtExjgLex0=",
+  "clientBundleHash": "sha256-wpGsT/oJup/G4MyJSKqpHBJlzc2Ha3wFIWmtp4vc/Wc=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }