c0de-agent 1.0.0 → 1.2.0

package/dist/session/compaction.js

@@ -1,6 +1,6 @@
 import { generateId } from '../shared/index.js';
 import { archiveOriginalEntries } from './archive.js';
-import { deleteEntriesByIds, getMessages, insertEntry } from './message.js';
+import { deleteEntriesByIds, getEntries, getMessages, insertEntry } from './message.js';
 import { upsertFileSnapshot } from './snapshot.js';
 import { estimateMessageTokens, estimateTokens } from './token.js';
 /**
@@ -51,30 +51,80 @@ function extractHotFiles(messages) {
     }
     return hot.sort((a, b) => b.accessCount - a.accessCount).slice(0, 10);
 }
-/** Build the LLM summarization prompt for a set of messages. */
-function buildCompactionPrompt(messages) {
+/** 工具输出在压缩 prompt 中保留的最大字符数（参考 opencode）。 */
+const TOOL_OUTPUT_MAX_CHARS = 2000;
+/** 截断超长字符串：head 60% + "[truncated]" + tail 40%，而非硬切。 */
+function truncateToolOutput(s) {
+    if (s.length <= TOOL_OUTPUT_MAX_CHARS)
+        return s;
+    const head = Math.floor(TOOL_OUTPUT_MAX_CHARS * 0.6);
+    const tail = TOOL_OUTPUT_MAX_CHARS - head;
+    return `${s.slice(0, head)}[truncated]${s.slice(-tail)}`;
+}
+/** 序列化单个 content part：text/thinking 保持原样，tool 输出超长时截断。 */
+function serializePart(p) {
+    if (p._tag === 'text' || p._tag === 'thinking')
+        return p.text;
+    if (p._tag === 'tool_call') {
+        const input = truncateToolOutput(JSON.stringify(p.input));
+        return JSON.stringify({ _tag: p._tag, id: p.id, tool: p.tool, input });
+    }
+    if (p._tag === 'tool_result') {
+        const output = truncateToolOutput(JSON.stringify(p.output));
+        return JSON.stringify({ _tag: p._tag, id: p.id, tool: p.tool, output });
+    }
+    return JSON.stringify(p);
+}
+/**
+ * Build the LLM summarization prompt for a set of messages.
+ *
+ * 当存在 previousSummary（上一次压缩生成的摘要）时，prompt 头部改为增量更新指令，
+ * 引导模型在已有摘要上叠加新事实、剔除过时信息，从而避免连续多次压缩导致的
+ * 信息逐次丢失。无 previousSummary 时退回原始的从零压缩指令。
+ */
+function buildCompactionPrompt(messages, previousSummary) {
     const history = messages
-        .map((m) => `[${m.role}] ${m.content.map((p) => (p._tag === 'text' ? p.text : JSON.stringify(p))).join(' ')}`)
+        .map((m) => `[${m.role}] ${m.content.map((p) => serializePart(p)).join(' ')}`)
         .join('\n');
-    return `将以下对话历史压缩为结构化摘要。保留关键信息，丢弃冗余细节。
+    const sections = `## Agenda
+逐条列出对话中出现的议题/任务，按处理顺序排列。每条格式：
+- **[议题标题]** — ✅已解决 / ⏳进行中 / 🔒阻塞 / 📋待办
+  - ✅/🔒 → 一行：最终结论或卡点
+  - ⏳/📋 → 完整保留：目标、约束、已尝试方向、相关文件路径、关键决策、待确认问题
 
 ## Goal
-用户的目标是什么
+用户此次会话的总体目标（若 Agenda 已涵盖，写"见 Agenda"）
 
-## Progress
-已完成的工作
+## Constraints & Preferences
+用户约束、偏好、规范要求（或"(none)"）
 
-## Decisions
-做出的关键决策
-
-## Next Steps
-接下来要做什么
+## Key Decisions
+做出的关键决策及原因
 
 ## Critical Context
-必须记住的上下文（文件路径、变量名、错误信息等）
+必须记住的技术事实（文件路径、变量名、命令、错误信息、未解决问题）
 
 ## Modified Files
-修改过的文件列表及变更摘要
+修改过的文件路径及变更摘要
+
+## Relevant Files
+对任务重要的文件/目录路径及原因`;
+    const header = previousSummary
+        ? `更新以下已有【议题驱动】摘要。重点：
+- 已解决的议题：状态更新为✅并压缩为一行结论；
+- 新增议题：补入 Agenda 并完整保留其描述与约束；
+- 尚未解决的议题：保持其原有描述与约束不变，只叠加本轮新进展。
+
+<previous-summary>
+${previousSummary}
+</previous-summary>`
+        : `将以下对话历史压缩为一份【议题驱动】的结构化摘要。
+核心原则——非对称保留：已解决的议题只留一行结论；尚未解决/待办的议题
+必须完整保留其描述、约束、已尝试方向、相关文件与待确认问题，它们是后续
+工作的蓝图，绝不可被稀释。`;
+    return `${header}
+
+${sections}
 
 ---
 对话历史：
@@ -115,6 +165,22 @@ function findKeepRecentStart(messages, keepRecentTokens) {
     // Always retain at least the most recent message.
     return Math.min(start, messages.length - 1);
 }
+/**
+ * 查找 session 最新的 compaction 摘要，用于增量摘要（P0-2）。
+ *
+ * 从全部 entries 中筛选 tag='compaction' 的记录，取最后一条（时间序最晚）的
+ * summary。无历史摘要时返回 undefined，buildCompactionPrompt 据此退回从零压缩模式。
+ */
+async function findPreviousSummary(handle, sessionId) {
+    const entries = await getEntries(handle, sessionId);
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry && '_tag' in entry && entry._tag === 'compaction') {
+            return entry.summary;
+        }
+    }
+    return undefined;
+}
 /**
  * Compact a session: summarize old messages, archive them, keep recent ones.
  *
@@ -144,7 +210,10 @@ async function compactSession(handle, sessionId, summarizer, config) {
     if (compactMessages.length === 0) {
         return { compacted: false, reason: 'nothing_to_compact' };
     }
-    const prompt = buildCompactionPrompt(compactMessages);
+    // 查询当前 session 最新的 compaction 摘要，作为增量更新的基线（P0-2）。
+    // 这样连续多次压缩时，新摘要会基于已有摘要叠加而非从零重建，避免早期信息逐次丢失。
+    const previousSummary = await findPreviousSummary(handle, sessionId);
+    const prompt = buildCompactionPrompt(compactMessages, previousSummary);
     // Run the (slow, network) summarizer OUTSIDE the transaction so we don't
     // hold a DB transaction open across an LLM call.
     const summary = await summarizer(prompt);

package/dist/session/shake.d.ts

@@ -0,0 +1,66 @@
+import type { Message } from '../shared/types/message.js';
+export interface ShakeConfig {
+    /** 保护最近 N token 的上下文不被 shake。 */
+    protectTokens: number;
+    /** 总节省 token < minSavings 时不 shake（preview 路径用）。 */
+    minSavings: number;
+    /** fenced/XML block 的最小 token 阈值。 */
+    fenceMinTokens: number;
+    /** 受保护的工具名列表（其 tool_result 不被 shake）。 */
+    protectedTools: string[];
+}
+/** Auto-shake 默认配置：保护活跃尾部，保守阈值。 */
+export declare const DEFAULT_SHAKE_CONFIG: ShakeConfig;
+export type ShakeRegion = {
+    kind: 'toolResult';
+    id: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    tokens: number;
+    originalText: string;
+    label: string;
+    /** tool_call_id（tool_result part.id），前端用于跨消息合并后匹配渲染块。 */
+    toolCallId: string;
+} | {
+    kind: 'block';
+    id: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    start: number;
+    end: number;
+    tokens: number;
+    originalText: string;
+    label: string;
+};
+/** API 返回给前端的区域视图。 */
+export type ShakeRegionView = {
+    id: string;
+    kind: 'toolResult' | 'block';
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    tokens: number;
+    label: string;
+    preview: string;
+    placeholder: string;
+    isAfterProtectWindow: boolean;
+    /** tool_result 的 tool_call_id（仅 toolResult 类别），前端跨消息合并后匹配渲染块。 */
+    toolCallId?: string;
+};
+/**
+ * 定位 fenced 代码块和顶层 XML 元素 span。返回字符偏移 [start, end) 数组，
+ * 覆盖完整块（含围栏/标签行，不含尾换行）。围栏内抑制 XML 检测。
+ * 未闭合围栏/标签不产生 range（保守策略）。
+ */
+export declare function scanTextForBlockRanges(text: string): Array<{
+    start: number;
+    end: number;
+}>;
+/** 收集可 shake 的区域。纯函数，不修改输入。 */
+export declare function collectShakeRegions(messages: Message[], config: ShakeConfig): ShakeRegion[];
+/** 原位替换选中区域。返回新数组，不修改原数组。 */
+export declare function applyShakeRegions(messages: Message[], regions: ShakeRegion[]): Message[];
+/** 区域转 API 视图。protectWindow 窗口内的标记 isAfterProtectWindow=false。 */
+export declare function toRegionViews(regions: ShakeRegion[], config: ShakeConfig, messages: Message[]): ShakeRegionView[];

package/dist/session/shake.js

@@ -0,0 +1,304 @@
+import { estimateTokens } from './token.js';
+/** Rough token cost of a placeholder line; used only for the savings gate. */
+const PLACEHOLDER_TOKEN_ESTIMATE = 16;
+/** 识别顶层 XML 元素（小写 tag，保守策略）。 */
+const OPENING_XML = /^<([a-z_-]+)(?:\s+[^>]*)?>$/;
+const CLOSING_XML = /^<\/([a-z_-]+)>$/;
+/** Auto-shake 默认配置：保护活跃尾部，保守阈值。 */
+export const DEFAULT_SHAKE_CONFIG = {
+    protectTokens: 16_000,
+    minSavings: 4_000,
+    fenceMinTokens: 400,
+    protectedTools: [],
+};
+/**
+ * 定位 fenced 代码块和顶层 XML 元素 span。返回字符偏移 [start, end) 数组，
+ * 覆盖完整块（含围栏/标签行，不含尾换行）。围栏内抑制 XML 检测。
+ * 未闭合围栏/标签不产生 range（保守策略）。
+ */
+export function scanTextForBlockRanges(text) {
+    const ranges = [];
+    let inFence = false;
+    let fenceStart = -1;
+    const tagStack = [];
+    let xmlStart = -1;
+    let lineStart = 0;
+    for (let i = 0; i <= text.length; i++) {
+        if (i !== text.length && text[i] !== '\n')
+            continue;
+        const line = text.slice(lineStart, i);
+        const lineEnd = i;
+        const trimmedStart = line.trimStart();
+        const isFenceLine = trimmedStart.startsWith('```') || trimmedStart.startsWith('~~~');
+        if (isFenceLine) {
+            if (!inFence) {
+                inFence = true;
+                fenceStart = lineStart;
+            }
+            else {
+                inFence = false;
+                ranges.push({ start: fenceStart, end: lineEnd });
+                fenceStart = -1;
+            }
+            lineStart = i + 1;
+            continue;
+        }
+        if (!inFence) {
+            // Only recognize top-level XML (no leading whitespace)
+            if (line.length === trimmedStart.length) {
+                const openingMatch = OPENING_XML.exec(trimmedStart);
+                if (openingMatch) {
+                    const tagName = openingMatch[1];
+                    if (tagName) {
+                        if (tagStack.length === 0)
+                            xmlStart = lineStart;
+                        tagStack.push(tagName);
+                    }
+                }
+                else {
+                    const closingMatch = CLOSING_XML.exec(trimmedStart);
+                    if (closingMatch &&
+                        tagStack.length > 0 &&
+                        tagStack[tagStack.length - 1] === closingMatch[1]) {
+                        tagStack.pop();
+                        if (tagStack.length === 0 && xmlStart >= 0) {
+                            ranges.push({ start: xmlStart, end: lineEnd });
+                            xmlStart = -1;
+                        }
+                    }
+                }
+            }
+        }
+        lineStart = i + 1;
+    }
+    return mergeRanges(ranges);
+}
+/** 按 start 升序，丢弃与已保留范围重叠的（嵌套取最外层）。 */
+function mergeRanges(ranges) {
+    if (ranges.length <= 1)
+        return ranges;
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    const kept = [];
+    let lastEnd = -1;
+    for (const range of sorted) {
+        if (range.start < lastEnd)
+            continue;
+        kept.push(range);
+        lastEnd = range.end;
+    }
+    return kept;
+}
+/** 单条消息的 token 估算（优先用缓存的 tokenCount）。 */
+function messageTokens(m) {
+    if (m.tokenCount > 0)
+        return m.tokenCount;
+    let total = 0;
+    for (const part of m.content) {
+        switch (part._tag) {
+            case 'text':
+            case 'thinking':
+            case 'steering':
+                total += estimateTokens(part.text);
+                break;
+            case 'tool_call':
+                total += estimateTokens(JSON.stringify(part.input));
+                break;
+            case 'tool_result':
+                total += estimateTokens(JSON.stringify(part.output));
+                break;
+        }
+    }
+    return total;
+}
+/** tool_result part 的输出文本。 */
+function toolResultText(output) {
+    if (output._tag === 'success')
+        return output.output;
+    if (output._tag === 'error')
+        return output.error;
+    if (output._tag === 'truncated')
+        return output.output;
+    return '';
+}
+/** 收集可 shake 的区域。纯函数，不修改输入。 */
+export function collectShakeRegions(messages, config) {
+    const n = messages.length;
+    if (n === 0)
+        return [];
+    // accumulatedAfter[i] = i 之后所有 message 的 token 总和
+    const accumulatedAfter = new Array(n);
+    let acc = 0;
+    for (let i = n - 1; i >= 0; i--) {
+        accumulatedAfter[i] = acc;
+        const m = messages[i];
+        if (m)
+            acc += messageTokens(m);
+    }
+    const regions = [];
+    for (let i = 0; i < n; i++) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        const afterTokens = accumulatedAfter[i] ?? 0;
+        const isAfterProtectWindow = afterTokens >= config.protectTokens;
+        if (!isAfterProtectWindow)
+            continue;
+        for (let partIndex = 0; partIndex < msg.content.length; partIndex++) {
+            const part = msg.content[partIndex];
+            if (!part)
+                continue;
+            // tool_result 区域
+            if (part._tag === 'tool_result') {
+                // 已 shaken 跳过
+                if ('shakenAt' in part.output && part.output.shakenAt)
+                    continue;
+                // protectedTools 跳过
+                if (config.protectedTools.includes(part.tool))
+                    continue;
+                const text = toolResultText(part.output);
+                if (text.length === 0)
+                    continue;
+                const tokens = estimateTokens(text);
+                if (tokens < config.fenceMinTokens)
+                    continue;
+                regions.push({
+                    kind: 'toolResult',
+                    id: `${msg.id}:toolResult:${partIndex}`,
+                    messageId: msg.id,
+                    messageIndex: i,
+                    partIndex,
+                    tokens,
+                    originalText: text,
+                    label: part.tool,
+                    toolCallId: part.id,
+                });
+                continue;
+            }
+            // text/thinking block 区域
+            if (part._tag === 'text' || part._tag === 'thinking') {
+                for (const range of scanTextForBlockRanges(part.text)) {
+                    const slice = part.text.slice(range.start, range.end);
+                    if (slice.length === 0)
+                        continue;
+                    const tokens = estimateTokens(slice);
+                    if (tokens < config.fenceMinTokens)
+                        continue;
+                    regions.push({
+                        kind: 'block',
+                        id: `${msg.id}:block:${partIndex}:${range.start}`,
+                        messageId: msg.id,
+                        messageIndex: i,
+                        partIndex,
+                        start: range.start,
+                        end: range.end,
+                        tokens,
+                        originalText: slice,
+                        label: msg.role,
+                    });
+                }
+            }
+        }
+    }
+    // minSavings 门控
+    let savings = 0;
+    for (const region of regions)
+        savings += Math.max(0, region.tokens - PLACEHOLDER_TOKEN_ESTIMATE);
+    if (savings < config.minSavings)
+        return [];
+    return regions;
+}
+/** 为区域生成占位符文本。 */
+function placeholderFor(region) {
+    if (region.kind === 'toolResult') {
+        return `[shaken: ${region.label}, ${region.tokens} tokens]`;
+    }
+    return '[shaken]';
+}
+/** 原位替换选中区域。返回新数组，不修改原数组。 */
+export function applyShakeRegions(messages, regions) {
+    if (regions.length === 0)
+        return messages;
+    // 按 messageId 分组
+    const byMessage = new Map();
+    for (const region of regions) {
+        const list = byMessage.get(region.messageId) ?? [];
+        list.push(region);
+        byMessage.set(region.messageId, list);
+    }
+    return messages.map((msg) => {
+        const msgRegions = byMessage.get(msg.id);
+        if (!msgRegions)
+            return msg;
+        // 深拷贝 content（保证不修改原对象）
+        const newContent = structuredClone(msg.content);
+        const now = Date.now();
+        // toolResult 区域：替换 output 文本
+        for (const region of msgRegions) {
+            if (region.kind !== 'toolResult')
+                continue;
+            const part = newContent[region.partIndex];
+            if (!part)
+                continue;
+            if (part._tag !== 'tool_result')
+                continue;
+            const placeholder = placeholderFor(region);
+            if (part.output._tag === 'success') {
+                part.output = { ...part.output, output: placeholder, shakenAt: now };
+            }
+            else if (part.output._tag === 'error') {
+                part.output = { ...part.output, error: placeholder, shakenAt: now };
+            }
+            else if (part.output._tag === 'truncated') {
+                part.output = { ...part.output, output: placeholder, shakenAt: now };
+            }
+        }
+        // block 区域：按 partIndex 分组，同一 text 内按 start 降序 splice
+        const blockByPart = new Map();
+        for (const region of msgRegions) {
+            if (region.kind !== 'block')
+                continue;
+            const list = blockByPart.get(region.partIndex) ?? [];
+            list.push(region);
+            blockByPart.set(region.partIndex, list);
+        }
+        for (const [partIndex, blockRegions] of blockByPart) {
+            const part = newContent[partIndex];
+            if (!part || (part._tag !== 'text' && part._tag !== 'thinking'))
+                continue;
+            const sorted = [...blockRegions].sort((a, b) => b.start - a.start);
+            let text = part.text;
+            for (const br of sorted) {
+                text = text.slice(0, br.start) + placeholderFor(br) + text.slice(br.end);
+            }
+            part.text = text;
+        }
+        return { ...msg, content: newContent };
+    });
+}
+/** 区域转 API 视图。protectWindow 窗口内的标记 isAfterProtectWindow=false。 */
+export function toRegionViews(regions, config, messages) {
+    const n = messages.length;
+    const accumulatedAfter = new Array(n);
+    let acc = 0;
+    for (let i = n - 1; i >= 0; i--) {
+        accumulatedAfter[i] = acc;
+        const m = messages[i];
+        if (m)
+            acc += messageTokens(m);
+    }
+    return regions.map((region) => ({
+        id: region.id,
+        kind: region.kind,
+        messageId: region.messageId,
+        messageIndex: region.messageIndex,
+        partIndex: region.partIndex,
+        tokens: region.tokens,
+        label: region.label,
+        preview: region.originalText.slice(0, 200),
+        placeholder: region.kind === 'toolResult'
+            ? `[shaken: ${region.label}, ${region.tokens} tokens]`
+            : '[shaken]',
+        isAfterProtectWindow: (accumulatedAfter[region.messageIndex] ?? 0) >= config.protectTokens,
+        ...(region.kind === 'toolResult' ? { toolCallId: region.toolCallId } : {}),
+    }));
+}

package/dist/session/types.d.ts

@@ -101,7 +101,7 @@ type CompactionArchive = {
     id: string;
     sessionId: string;
     compactionId: string;
-    archiveType: 'compaction' | 'squash';
+    archiveType: 'compaction' | 'squash' | 'shake';
     originalEntries: SessionEntry[];
     summary: string;
     tokenCount: number;

package/dist/shared/types/agent.d.ts

@@ -172,6 +172,18 @@ type AgentEvent = {
     agentType: string;
     success: boolean;
     output?: string;
+}
+/**
+ * 会话压缩成功后发出（spec: plugin-hooks `session:compact`）。
+ * 实际发生压缩（runCompaction 返回 compacted=true）时才 yield；
+ * nothing_to_compact 不发。archiveId/summary 仅在真实压缩时存在。
+ */
+ | {
+    _tag: 'compaction_done';
+    summary: string;
+    archiveId?: string;
+    compactedCount: number;
+    keptCount: number;
 } | {
     _tag: 'done';
 };
@@ -198,5 +210,20 @@ type AgentState = {
         provider: string;
         model: string;
     };
+    /**
+     * 压缩死锁标记：自动压缩成功后仍超阈值（如 keepRecentTokens 本身已超限）时置真，
+     * 暂停后续自动压缩以防每轮重复触发（无限循环）。收到新用户消息（agentLoop 重入）时重置。
+     */
+    compactionDeadEnd?: boolean;
+    /**
+     * 压缩退化监测器：压缩成功后初始化，监测接下来若干轮 assistant 回复。
+     * 若连续产生空回复（无实质文本且无 tool_call），发出非致命警告（不中断循环），
+     * 提示 agent 可能在"沉默退化"。remaining 耗尽即清除；新一轮用户输入
+     * （agentLoop 重入）时不会自动重置——它由压缩成功单独建立。
+     */
+    postCompactionMonitor?: {
+        remaining: number;
+        noTextStreak: number;
+    };
 };
 export type { AgentConfig, AgentError, AgentEvent, AgentState, AgentStatus, LLMCall, LLMSegment, PendingToolCall, SegmentTrigger, TokenBudget, };

package/dist/shared/types/config.d.ts

@@ -16,6 +16,16 @@ type CompactionConfig = {
     reserveTokens: number;
     /** Token budget for retaining recent messages verbatim. */
     keepRecentTokens: number;
+    /** 中轮压缩（mid-run compaction）：单个 turn 内工具执行后、下一次 LLM 请求前
+     * 按阈值静默压缩。与 turn-end 自动压缩独立——以本开关为闸门复用 shouldCompact
+     * 的阈值逻辑（不受 `enabled` 影响），默认关闭（保守开启）。 */
+    midTurnEnabled?: boolean;
+    /** 压缩摘要使用的模型覆盖。未设置时回退到会话主模型。
+     * 摘要任务对推理能力要求低，可指定便宜/快速模型以降低成本。 */
+    compactionModel?: {
+        provider: string;
+        model: string;
+    };
 };
 /** Tool-mode auto-selection configuration (spec §16.5). */
 type ToolMetricsConfig = {

package/dist/shared/types/llm.d.ts

@@ -117,6 +117,7 @@ type StreamChunk = {
     error: {
         message: string;
         retryable?: boolean;
+        classification?: 'context-overflow';
     };
 };
 export type { ChatMessage, ChatRequest, ChatTool, ContentPart, FinishReason, ModelCapabilities, ModelOverride, ModelRole, ProviderConfig, ProviderProtocol, StreamChunk, };

package/dist/shared/types/tool.d.ts

@@ -6,9 +6,11 @@ type ToolResult = {
     _tag: 'success';
     output: string;
     metadata?: Record<string, unknown>;
+    shakenAt?: number;
 } | {
     _tag: 'error';
     error: string;
+    shakenAt?: number;
 } | {
     _tag: 'permission_required';
     reason: string;
@@ -17,6 +19,7 @@ type ToolResult = {
     output: string;
     truncated: boolean;
     totalLines: number;
+    shakenAt?: number;
 };
 /** Context passed to a URL resolver (skill://, agent://, pr://, …). */
 type URLResolveContext = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c0de-agent",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Open-source AI coding assistant with Browser-Server architecture",
   "type": "module",
   "bin": {
@@ -50,7 +50,8 @@
   },
   "pnpm": {
     "onlyBuiltDependencies": [
-      "esbuild"
+      "esbuild",
+      "node-pty"
     ]
   },
   "devDependencies": {
@@ -69,10 +70,12 @@
     "@types/pg": "^8.20.0",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^6.0.3",
     "@wyw-in-js/vite": "^2.1.0",
     "drizzle-kit": "^0.31.10",
     "happy-dom": "^20.10.6",
+    "node-gyp": "^13.0.1",
     "pg": "^8.22.0",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
@@ -89,6 +92,9 @@
     "@native-router/core": "^1.1.0",
     "@native-router/react": "^1.1.2",
     "@tanstack/react-query": "^5.101.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/xterm": "^6.0.0",
     "diff": "^9.0.0",
     "drizzle-orm": "^0.45.2",
     "fuzzysort": "^3.1.0",
@@ -96,10 +102,12 @@
     "hono": "^4.12.27",
     "lucide-react": "^1.22.0",
     "marked": "^18.0.5",
+    "node-pty": "^1.1.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "react-router-dom": "^7.18.0",
     "shiki": "^4.3.0",
-    "undici": "^8.5.0"
+    "undici": "^8.5.0",
+    "ws": "^8.21.0"
   }
 }