@shareai-lab/kode-sdk 2.7.1 → 2.7.2

package/dist/core/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/context-manager.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManager = void 0;
+/**
+ * ContextManager v2 - 带完整历史追踪的上下文管理器
+ *
+ * 职责：
+ * 1. 分析上下文使用情况（token 估算）
+ * 2. 压缩超限上下文并保存历史窗口
+ * 3. 保存压缩记录与文件快照
+ * 4. 发送 Monitor 事件以供审计
+ */
+class ContextManager {
+    constructor(store, agentId, opts) {
+        this.store = store;
+        this.agentId = agentId;
+        this.maxTokens = opts?.maxTokens ?? 50000;
+        this.compressToTokens = opts?.compressToTokens ?? 30000;
+        this.compressionModel = opts?.compressionModel ?? 'claude-haiku-4-5';
+        this.compressionPrompt = opts?.compressionPrompt ?? 'Summarize the conversation history concisely';
+        const keepRecent = opts?.multimodalRetention?.keepRecent ?? 3;
+        this.keepRecentMultimodal = Math.max(0, Math.floor(keepRecent));
+    }
+    /**
+     * 分析上下文使用情况（粗略的 token 估算）
+     */
+    analyze(messages) {
+        const totalTokens = messages.reduce((sum, message) => {
+            const blocks = message.metadata?.transport === 'omit'
+                ? message.content
+                : message.metadata?.content_blocks ?? message.content;
+            return (sum +
+                blocks.reduce((inner, block) => {
+                    if (block.type === 'text')
+                        return inner + Math.ceil(block.text.length / 4); // 粗略估算：4 chars = 1 token
+                    if (block.type === 'reasoning')
+                        return inner + Math.ceil(block.reasoning.length / 4);
+                    if (block.type === 'image' || block.type === 'audio' || block.type === 'file') {
+                        return inner + 500; // 固定估算，避免 base64 膨胀
+                    }
+                    return inner + Math.ceil(JSON.stringify(block).length / 4);
+                }, 0));
+        }, 0);
+        return {
+            totalTokens,
+            messageCount: messages.length,
+            shouldCompress: totalTokens > this.maxTokens,
+        };
+    }
+    /**
+     * 压缩上下文并保存历史
+     *
+     * 流程：
+     * 1. 保存 HistoryWindow（压缩前的完整快照）
+     * 2. 执行压缩（简单版：保留后半部分 + 生成摘要）
+     * 3. 保存 CompressionRecord（压缩元信息）
+     * 4. 保存重要文件快照（如果有 FilePool）
+     * 5. 返回压缩结果
+     */
+    async compress(messages, events, filePool, sandbox) {
+        const usage = this.analyze(messages);
+        if (!usage.shouldCompress)
+            return undefined;
+        const timestamp = Date.now();
+        const windowId = `window-${timestamp}`;
+        const compressionId = `comp-${timestamp}`;
+        // 1. 保存历史窗口
+        const window = {
+            id: windowId,
+            messages,
+            events,
+            stats: {
+                messageCount: messages.length,
+                tokenCount: usage.totalTokens,
+                eventCount: events.length,
+            },
+            timestamp,
+        };
+        await this.store.saveHistoryWindow(this.agentId, window);
+        // 2. 执行压缩（简化版：保留 60% 消息）
+        const targetRatio = this.compressToTokens / usage.totalTokens;
+        let keepCount = Math.ceil(messages.length * Math.max(targetRatio, 0.6));
+        const keepFromIndex = messages.length - keepCount;
+        const multimodalKeepFrom = this.findKeepFromIndexForMultimodal(messages, this.keepRecentMultimodal);
+        const finalKeepFrom = Math.min(keepFromIndex, multimodalKeepFrom);
+        keepCount = messages.length - finalKeepFrom;
+        const retainedMessages = messages.slice(-keepCount);
+        const removedMessages = messages.slice(0, messages.length - keepCount);
+        // 生成摘要
+        const summaryText = this.generateSummary(removedMessages);
+        const summary = {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: `<context-summary timestamp="${new Date().toISOString()}" window="${windowId}">\n${summaryText}\n</context-summary>`,
+                },
+            ],
+        };
+        // 3. 保存压缩记录
+        const recoveredPaths = [];
+        if (filePool && sandbox) {
+            const accessed = filePool.getAccessedFiles().slice(0, 5); // 只保存最近 5 个文件
+            for (const { path, mtime } of accessed) {
+                recoveredPaths.push(path);
+                try {
+                    // 读取实际文件内容（用于上下文恢复）
+                    const content = await sandbox.fs.read(path);
+                    const file = {
+                        path,
+                        content,
+                        mtime,
+                        timestamp,
+                    };
+                    await this.store.saveRecoveredFile(this.agentId, file);
+                }
+                catch (err) {
+                    // 如果读取失败，保存错误信息
+                    const file = {
+                        path,
+                        content: `// Failed to read file: ${err instanceof Error ? err.message : String(err)}`,
+                        mtime,
+                        timestamp,
+                    };
+                    await this.store.saveRecoveredFile(this.agentId, file);
+                }
+            }
+        }
+        const ratio = retainedMessages.length / messages.length;
+        const record = {
+            id: compressionId,
+            windowId,
+            config: {
+                model: this.compressionModel,
+                prompt: this.compressionPrompt,
+                threshold: this.maxTokens,
+            },
+            summary: summaryText.slice(0, 500), // 保存摘要前 500 字符
+            ratio,
+            recoveredFiles: recoveredPaths,
+            timestamp,
+        };
+        await this.store.saveCompressionRecord(this.agentId, record);
+        return {
+            summary,
+            removedMessages,
+            retainedMessages,
+            windowId,
+            compressionId,
+            ratio,
+        };
+    }
+    /**
+     * 生成压缩摘要
+     */
+    generateSummary(messages) {
+        return messages
+            .map((msg, idx) => {
+            const header = `${idx + 1}. [${msg.role}]`;
+            const blocks = msg.metadata?.transport === 'omit'
+                ? msg.content
+                : msg.metadata?.content_blocks ?? msg.content;
+            const content = blocks
+                .map((block) => {
+                if (block.type === 'text')
+                    return block.text.slice(0, 200);
+                if (block.type === 'reasoning')
+                    return `[reasoning] ${block.reasoning.slice(0, 200)}`;
+                if (block.type === 'image') {
+                    const source = block.base64 ? 'base64' : block.url ? 'url' : block.file_id ? 'file_id' : 'unknown';
+                    const id = block.file_id || block.url || 'base64';
+                    return `[image-summary id=${id} mime=${block.mime_type || 'unknown'} note="source=${source}"]`;
+                }
+                if (block.type === 'audio') {
+                    const source = block.base64 ? 'base64' : block.url ? 'url' : block.file_id ? 'file_id' : 'unknown';
+                    const id = block.file_id || block.url || 'base64';
+                    return `[audio-summary id=${id} mime=${block.mime_type || 'unknown'} note="source=${source}"]`;
+                }
+                if (block.type === 'file') {
+                    const source = block.base64 ? 'base64' : block.url ? 'url' : block.file_id ? 'file_id' : 'unknown';
+                    const id = block.file_id || block.url || block.filename || 'base64';
+                    return `[file-summary id=${id} mime=${block.mime_type || 'unknown'} note="source=${source}"]`;
+                }
+                if (block.type === 'tool_use')
+                    return `[tool] ${block.name}(...)`;
+                if (block.type === 'tool_result') {
+                    const preview = JSON.stringify(block.content).slice(0, 100);
+                    return `[result] ${preview}`;
+                }
+                return '';
+            })
+                .join('\n');
+            return `${header}\n${content}`;
+        })
+            .join('\n\n');
+    }
+    findKeepFromIndexForMultimodal(messages, keepRecent) {
+        if (keepRecent <= 0)
+            return messages.length;
+        let remaining = keepRecent;
+        let earliestIndex = messages.length;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            const blocks = msg.metadata?.transport === 'omit'
+                ? msg.content
+                : msg.metadata?.content_blocks ?? msg.content;
+            for (const block of blocks) {
+                if (block.type === 'image' || block.type === 'audio' || block.type === 'file') {
+                    remaining -= 1;
+                    earliestIndex = i;
+                    if (remaining <= 0) {
+                        return i;
+                    }
+                }
+            }
+        }
+        if (earliestIndex === messages.length) {
+            return messages.length;
+        }
+        return earliestIndex;
+    }
+    /**
+     * 恢复历史窗口（用于审计或调试）
+     */
+    async loadHistory() {
+        return await this.store.loadHistoryWindows(this.agentId);
+    }
+    /**
+     * 加载压缩记录
+     */
+    async loadCompressions() {
+        return await this.store.loadCompressionRecords(this.agentId);
+    }
+    /**
+     * 加载恢复的文件
+     */
+    async loadRecoveredFiles() {
+        return await this.store.loadRecoveredFiles(this.agentId);
+    }
+}
+exports.ContextManager = ContextManager;

package/dist/core/errors.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderCapabilityError = exports.UnsupportedProviderError = exports.UnsupportedContentBlockError = exports.MultimodalValidationError = exports.ResumeError = void 0;
+exports.assert = assert;
+class ResumeError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ResumeError';
+    }
+}
+exports.ResumeError = ResumeError;
+function assert(condition, code, message) {
+    if (!condition) {
+        throw new ResumeError(code, message);
+    }
+}
+class MultimodalValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'ERR_MULTIMODAL_INVALID';
+        this.name = 'MultimodalValidationError';
+    }
+}
+exports.MultimodalValidationError = MultimodalValidationError;
+class UnsupportedContentBlockError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'ERR_CONTENTBLOCK_UNSUPPORTED';
+        this.name = 'UnsupportedContentBlockError';
+    }
+}
+exports.UnsupportedContentBlockError = UnsupportedContentBlockError;
+class UnsupportedProviderError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'ERR_PROVIDER_UNSUPPORTED';
+        this.name = 'UnsupportedProviderError';
+    }
+}
+exports.UnsupportedProviderError = UnsupportedProviderError;
+class ProviderCapabilityError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'ERR_PROVIDER_CAPABILITY';
+        this.name = 'ProviderCapabilityError';
+    }
+}
+exports.ProviderCapabilityError = ProviderCapabilityError;

package/dist/core/events.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+const events_1 = require("events");
+const logger_1 = require("../utils/logger");
+class EventBus {
+    constructor() {
+        this.cursor = 0;
+        this.seq = 0;
+        this.timeline = [];
+        this.subscribers = new Map();
+        this.controlEmitter = new events_1.EventEmitter();
+        this.monitorEmitter = new events_1.EventEmitter();
+        this.failedEvents = [];
+        this.MAX_FAILED_BUFFER = 1000;
+        this.subscribers.set('progress', new Set());
+        this.subscribers.set('control', new Set());
+        this.subscribers.set('monitor', new Set());
+        // Prevent Node.js ERR_UNHANDLED_ERROR when emitting 'error' events
+        // without a listener. This allows MonitorEvent with type='error' to be
+        // emitted safely. Users can still register their own 'error' handlers.
+        this.monitorEmitter.on('error', () => {
+            // No-op: errors are handled through the subscriber system
+        });
+    }
+    setStore(store, agentId) {
+        this.store = store;
+        this.agentId = agentId;
+    }
+    emitProgress(event) {
+        const envelope = this.emit('progress', event);
+        this.notifySubscribers('progress', envelope);
+        return envelope;
+    }
+    emitControl(event) {
+        const envelope = this.emit('control', event);
+        this.controlEmitter.emit(event.type, envelope.event);
+        this.notifySubscribers('control', envelope);
+        return envelope;
+    }
+    emitMonitor(event) {
+        const envelope = this.emit('monitor', event);
+        this.monitorEmitter.emit(event.type, envelope.event);
+        this.notifySubscribers('monitor', envelope);
+        return envelope;
+    }
+    subscribeProgress(opts) {
+        const subscriber = new EventSubscriber(opts?.kinds);
+        this.subscribers.get('progress').add(subscriber);
+        if (opts?.since) {
+            void this.replayHistory('progress', subscriber, opts.since);
+        }
+        const bus = this;
+        return {
+            [Symbol.asyncIterator]() {
+                return {
+                    async next() {
+                        const value = (await subscriber.next());
+                        if (!value) {
+                            bus.subscribers.get('progress').delete(subscriber);
+                            return { done: true, value: undefined };
+                        }
+                        return { done: false, value };
+                    },
+                    async return() {
+                        subscriber.close();
+                        bus.subscribers.get('progress').delete(subscriber);
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+        };
+    }
+    subscribe(channels = ['progress', 'control', 'monitor'], opts) {
+        const subscriber = new EventSubscriber(opts?.kinds);
+        for (const channel of channels) {
+            this.subscribers.get(channel).add(subscriber);
+            if (opts?.since) {
+                void this.replayHistory(channel, subscriber, opts.since);
+            }
+        }
+        return this.iterableFor(channels, subscriber);
+    }
+    onControl(type, handler) {
+        this.controlEmitter.on(type, handler);
+        return () => this.controlEmitter.off(type, handler);
+    }
+    onMonitor(type, handler) {
+        this.monitorEmitter.on(type, handler);
+        return () => this.monitorEmitter.off(type, handler);
+    }
+    getTimeline(since) {
+        return since !== undefined ? this.timeline.filter((t) => t.cursor >= since) : this.timeline;
+    }
+    getCursor() {
+        return this.cursor;
+    }
+    getLastBookmark() {
+        const last = this.timeline[this.timeline.length - 1];
+        return last?.bookmark;
+    }
+    syncCursor(bookmark) {
+        if (!bookmark)
+            return;
+        const nextSeq = bookmark.seq + 1;
+        if (this.seq < nextSeq) {
+            this.seq = nextSeq;
+        }
+        const timelineCursor = this.timeline.length
+            ? this.timeline[this.timeline.length - 1].cursor + 1
+            : 0;
+        const nextCursor = Math.max(this.cursor, nextSeq, timelineCursor);
+        if (this.cursor < nextCursor) {
+            this.cursor = nextCursor;
+        }
+    }
+    reset() {
+        this.cursor = 0;
+        this.seq = 0;
+        this.timeline = [];
+        for (const set of this.subscribers.values()) {
+            set.clear();
+        }
+        this.controlEmitter.removeAllListeners();
+        this.monitorEmitter.removeAllListeners();
+    }
+    emit(channel, event) {
+        const bookmark = {
+            seq: this.seq++,
+            timestamp: Date.now(),
+        };
+        const eventWithChannel = { ...event, channel };
+        const eventWithBookmark = { ...eventWithChannel, bookmark };
+        const envelope = {
+            cursor: this.cursor++,
+            bookmark,
+            event: eventWithBookmark,
+        };
+        const timelineEntry = {
+            cursor: envelope.cursor,
+            bookmark,
+            event: envelope.event,
+        };
+        this.timeline.push(timelineEntry);
+        if (this.timeline.length > 10000) {
+            this.timeline = this.timeline.slice(-5000);
+        }
+        if (this.store && this.agentId) {
+            const isCritical = this.isCriticalEvent(event);
+            this.store.appendEvent(this.agentId, timelineEntry)
+                .then(() => {
+                // 成功后尝试重试之前失败的事件
+                if (this.failedEvents.length > 0) {
+                    void this.retryFailedEvents();
+                }
+            })
+                .catch((err) => {
+                if (isCritical) {
+                    // 关键事件失败：缓存到内存
+                    this.failedEvents.push(timelineEntry);
+                    if (this.failedEvents.length > this.MAX_FAILED_BUFFER) {
+                        this.failedEvents = this.failedEvents.slice(-this.MAX_FAILED_BUFFER);
+                    }
+                    // 发送降级的内存 Monitor 事件（不持久化）
+                    try {
+                        this.monitorEmitter.emit('storage_failure', {
+                            type: 'storage_failure',
+                            severity: 'critical',
+                            failedEvent: event.type,
+                            bufferedCount: this.failedEvents.length,
+                            error: err.message
+                        });
+                    }
+                    catch {
+                        // 降级事件发送失败也不阻塞
+                    }
+                }
+                else {
+                    // 非关键事件失败：仅记录日志
+                    logger_1.logger.warn(`[EventBus] Failed to persist non-critical event: ${event.type}`, err);
+                }
+            });
+        }
+        return envelope;
+    }
+    isCriticalEvent(event) {
+        const criticalTypes = new Set([
+            'tool:end',
+            'done',
+            'permission_decided',
+            'agent_resumed',
+            'state_changed',
+            'breakpoint_changed',
+            'error',
+        ]);
+        return criticalTypes.has(event.type);
+    }
+    async retryFailedEvents() {
+        if (!this.store || !this.agentId || this.failedEvents.length === 0)
+            return;
+        const toRetry = this.failedEvents.splice(0, 10);
+        for (const event of toRetry) {
+            try {
+                await this.store.appendEvent(this.agentId, event);
+            }
+            catch (err) {
+                this.failedEvents.unshift(event);
+                break;
+            }
+        }
+    }
+    getFailedEventCount() {
+        return this.failedEvents.length;
+    }
+    async flushFailedEvents() {
+        while (this.failedEvents.length > 0) {
+            await this.retryFailedEvents();
+            if (this.failedEvents.length > 0) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+    }
+    notifySubscribers(channel, envelope) {
+        const subscribers = this.subscribers.get(channel);
+        if (!subscribers)
+            return;
+        for (const subscriber of subscribers) {
+            if (subscriber.accepts(envelope)) {
+                subscriber.push(envelope);
+            }
+        }
+    }
+    async replayHistory(channel, subscriber, since) {
+        if (this.store && this.agentId) {
+            try {
+                const opts = { channel: channel, since };
+                for await (const entry of this.store.readEvents(this.agentId, opts)) {
+                    const envelope = entry;
+                    if (subscriber.accepts(envelope)) {
+                        subscriber.push(envelope);
+                    }
+                }
+                return;
+            }
+            catch (error) {
+                logger_1.logger.error('Failed to replay events from store:', error);
+            }
+        }
+        const past = this.timeline.filter((t) => {
+            if (t.event.channel !== channel)
+                return false;
+            if (!since)
+                return true;
+            return t.bookmark.seq > since.seq;
+        });
+        for (const entry of past) {
+            const envelope = entry;
+            if (subscriber.accepts(envelope)) {
+                subscriber.push(envelope);
+            }
+        }
+    }
+    iterableFor(channel, subscriber) {
+        const channels = Array.isArray(channel) ? channel : [channel];
+        const bus = this;
+        return {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: async () => {
+                        const value = (await subscriber.next());
+                        if (!value) {
+                            for (const ch of channels)
+                                bus.subscribers.get(ch).delete(subscriber);
+                            return { done: true, value: undefined };
+                        }
+                        return { done: false, value };
+                    },
+                    return: async () => {
+                        subscriber.close();
+                        for (const ch of channels)
+                            bus.subscribers.get(ch).delete(subscriber);
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+        };
+    }
+}
+exports.EventBus = EventBus;
+class EventSubscriber {
+    constructor(kinds) {
+        this.kinds = kinds;
+        this.queue = [];
+        this.waiting = null;
+        this.closed = false;
+    }
+    accepts(envelope) {
+        if (!this.kinds || this.kinds.length === 0)
+            return true;
+        return this.kinds.includes(String(envelope.event.type));
+    }
+    push(envelope) {
+        if (this.closed)
+            return;
+        if (this.waiting) {
+            this.waiting(envelope);
+            this.waiting = null;
+        }
+        else {
+            this.queue.push(envelope);
+        }
+    }
+    async next() {
+        if (this.closed)
+            return null;
+        if (this.queue.length > 0)
+            return this.queue.shift();
+        return new Promise((resolve) => {
+            this.waiting = resolve;
+        });
+    }
+    close() {
+        this.closed = true;
+        if (this.waiting) {
+            this.waiting(null);
+            this.waiting = null;
+        }
+    }
+}

package/dist/core/file-pool.d.ts

@@ -23,6 +23,7 @@ export declare class FilePool {
     private readonly sandbox;
     private records;
     private watchers;
+    private watchPending;
     private readonly watchEnabled;
     private readonly onChange?;
     constructor(sandbox: Sandbox, opts?: FilePoolOptions);
@@ -33,6 +34,7 @@ export declare class FilePool {
     checkFreshness(path: string): Promise<FileFreshness>;
     getTrackedFiles(): string[];
     private ensureWatch;
+    private doWatch;
     getAccessedFiles(): Array<{
         path: string;
         mtime: number;