kode-sdk 2.7.0

package/dist/infra/sandbox.d.ts

@@ -0,0 +1,87 @@
+export type SandboxKind = 'local' | 'docker' | 'k8s' | 'remote' | 'vfs';
+export interface SandboxFS {
+    resolve(path: string): string;
+    isInside(path: string, access?: 'read' | 'write'): boolean;
+    read(path: string): Promise<string>;
+    write(path: string, content: string): Promise<void>;
+    rm(path: string, opts?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    temp(name?: string): string;
+    stat(path: string): Promise<{
+        mtimeMs: number;
+    }>;
+    glob(pattern: string, opts?: {
+        cwd?: string;
+        ignore?: string[];
+        dot?: boolean;
+        absolute?: boolean;
+    }): Promise<string[]>;
+}
+export interface SandboxExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface Sandbox {
+    kind: SandboxKind;
+    workDir?: string;
+    fs: SandboxFS;
+    exec(cmd: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<SandboxExecResult>;
+    watchFiles?(paths: string[], listener: (event: {
+        path: string;
+        mtimeMs: number;
+    }) => void): Promise<string>;
+    unwatchFiles?(id: string): void;
+    dispose?(): Promise<void> | void;
+}
+export interface LocalSandboxOptions {
+    workDir?: string;
+    baseDir?: string;
+    pwd?: string;
+    enforceBoundary?: boolean;
+    /**
+     * @deprecated Use allowReadPaths/allowWritePaths instead.
+     * If provided, it will be used for both read & write access.
+     */
+    allowPaths?: string[];
+    /**
+     * Extra paths allowed for read-like operations (read/stat/glob/watch).
+     * Writes are still blocked unless allowWritePaths (or legacy allowPaths) includes them.
+     */
+    allowReadPaths?: string[];
+    /**
+     * Extra paths allowed for write-like operations (write/rm).
+     * NOTE: Bash commands are not OS-sandboxed; this only affects SandboxFS-based tools.
+     */
+    allowWritePaths?: string[];
+    watchFiles?: boolean;
+}
+export declare class LocalSandbox implements Sandbox {
+    kind: SandboxKind;
+    workDir: string;
+    fs: SandboxFS;
+    private watchers;
+    private readonly enforceBoundary;
+    private readonly allowReadPaths;
+    private readonly allowWritePaths;
+    private readonly watchEnabled;
+    constructor(opts?: LocalSandboxOptions);
+    exec(cmd: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<SandboxExecResult>;
+    static local(opts: {
+        workDir?: string;
+        baseDir?: string;
+        pwd?: string;
+    }): LocalSandbox;
+    watchFiles(paths: string[], listener: (event: {
+        path: string;
+        mtimeMs: number;
+    }) => void): Promise<string>;
+    unwatchFiles(id: string): void;
+    dispose(): Promise<void>;
+}

package/dist/infra/sandbox.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSandbox = void 0;
+// 危险命令模式 - 防止执行破坏性操作
+const DANGEROUS_PATTERNS = [
+    /rm\s+-rf\s+\/($|\s)/, // rm -rf /
+    /sudo\s+/, // sudo 提权
+    /shutdown/, // 系统关机
+    /reboot/, // 系统重启
+    /mkfs\./, // 格式化文件系统
+    /dd\s+.*of=/, // dd 写入设备
+    /:\(\)\{\s*:\|\:&\s*\};:/, // fork bomb
+    /chmod\s+777\s+\//, // 修改根目录权限
+    /curl\s+.*\|\s*(bash|sh)/, // 管道执行远程脚本
+    /wget\s+.*\|\s*(bash|sh)/, // wget 执行远程脚本
+    />\s*\/dev\/sda/, // 直接写入硬盘
+    /mkswap/, // 创建交换分区
+    /swapon/, // 启用交换分区
+];
+class LocalSandbox {
+    constructor(opts = {}) {
+        this.kind = 'local';
+        this.watchers = new Map();
+        const path = require('path');
+        this.workDir = path.resolve(opts.workDir || opts.baseDir || opts.pwd || process.cwd());
+        this.enforceBoundary = opts.enforceBoundary !== false;
+        const legacy = (opts.allowPaths || []).map((p) => path.resolve(p));
+        this.allowReadPaths = (opts.allowReadPaths || legacy).map((p) => path.resolve(p));
+        this.allowWritePaths = (opts.allowWritePaths || legacy).map((p) => path.resolve(p));
+        this.watchEnabled = opts.watchFiles !== false; // default true
+        this.fs = new LocalFS(this.workDir, {
+            enforceBoundary: this.enforceBoundary,
+            allowReadPaths: this.allowReadPaths,
+            allowWritePaths: this.allowWritePaths,
+        });
+    }
+    async exec(cmd, opts) {
+        // 安全检查：阻止危险命令
+        for (const pattern of DANGEROUS_PATTERNS) {
+            if (pattern.test(cmd)) {
+                const error = `Dangerous command blocked for security: ${cmd.slice(0, 100)}`;
+                return {
+                    code: 1,
+                    stdout: '',
+                    stderr: error,
+                };
+            }
+        }
+        const { exec } = require('child_process');
+        const util = require('util');
+        const execPromise = util.promisify(exec);
+        const timeout = opts?.timeoutMs || 120000;
+        try {
+            const { stdout, stderr } = await execPromise(cmd, {
+                cwd: this.workDir,
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            return { code: 0, stdout: stdout || '', stderr: stderr || '' };
+        }
+        catch (error) {
+            return {
+                code: error.code || 1,
+                stdout: error.stdout || '',
+                stderr: error.stderr || error.message || '',
+            };
+        }
+    }
+    static local(opts) {
+        return new LocalSandbox(opts);
+    }
+    async watchFiles(paths, listener) {
+        if (!this.watchEnabled) {
+            return `watch-disabled-${Date.now()}`;
+        }
+        const id = `watch-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const fs = require('fs');
+        const watchers = [];
+        for (const path of paths) {
+            const resolved = this.fs.resolve(path);
+            if (!this.fs.isInside(resolved, 'read'))
+                continue;
+            const watcher = fs.watch(resolved, async () => {
+                try {
+                    const stat = await this.fs.stat(resolved);
+                    listener({ path: resolved, mtimeMs: stat.mtimeMs });
+                }
+                catch {
+                    listener({ path: resolved, mtimeMs: Date.now() });
+                }
+            });
+            watchers.push(watcher);
+        }
+        this.watchers.set(id, {
+            paths,
+            close: () => watchers.forEach((w) => w.close()),
+        });
+        return id;
+    }
+    unwatchFiles(id) {
+        const entry = this.watchers.get(id);
+        if (entry) {
+            entry.close();
+            this.watchers.delete(id);
+        }
+    }
+    async dispose() {
+        for (const entry of this.watchers.values()) {
+            entry.close();
+        }
+        this.watchers.clear();
+    }
+}
+exports.LocalSandbox = LocalSandbox;
+class LocalFS {
+    constructor(workDir, options) {
+        this.workDir = workDir;
+        this.options = options;
+    }
+    resolve(p) {
+        const path = require('path');
+        if (path.isAbsolute(p))
+            return p;
+        return path.resolve(this.workDir, p);
+    }
+    isInside(p, access = 'write') {
+        const path = require('path');
+        const resolved = path.resolve(this.resolve(p)); // resolve 去除 ..
+        // 1. 检查是否在 workDir 内
+        const relativeToWork = path.relative(this.workDir, resolved);
+        if (!relativeToWork.startsWith('..') && !path.isAbsolute(relativeToWork)) {
+            return true;
+        }
+        // 2. 如果不强制边界检查，允许所有路径
+        if (!this.options.enforceBoundary)
+            return true;
+        // 3. 检查白名单（先 resolve 防止绕过）
+        const allow = access === 'read' ? this.options.allowReadPaths : this.options.allowWritePaths;
+        return allow.some((allowed) => {
+            const resolvedAllowed = path.resolve(allowed); // 先 resolve
+            const relative = path.relative(resolvedAllowed, resolved);
+            return !relative.startsWith('..') && !path.isAbsolute(relative);
+        });
+    }
+    async read(p) {
+        const fs = require('fs').promises;
+        const resolved = this.resolve(p);
+        if (!this.isInside(resolved, 'read')) {
+            throw new Error(`Path outside sandbox: ${p}`);
+        }
+        return await fs.readFile(resolved, 'utf-8');
+    }
+    async write(p, content) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const resolved = this.resolve(p);
+        if (!this.isInside(resolved, 'write')) {
+            throw new Error(`Path outside sandbox: ${p}`);
+        }
+        const dir = path.dirname(resolved);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(resolved, content, 'utf-8');
+    }
+    async rm(p, opts) {
+        const fs = require('fs').promises;
+        const resolved = this.resolve(p);
+        if (!this.isInside(resolved, 'write')) {
+            throw new Error(`Path outside sandbox: ${p}`);
+        }
+        await fs.rm(resolved, { recursive: opts?.recursive ?? false, force: opts?.force ?? false });
+    }
+    temp(name) {
+        const path = require('path');
+        const tempName = name || `temp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        return path.relative(this.workDir, path.join(this.workDir, '.temp', tempName));
+    }
+    async stat(p) {
+        const fs = require('fs').promises;
+        const resolved = this.resolve(p);
+        if (!this.isInside(resolved, 'read')) {
+            throw new Error(`Path outside sandbox: ${p}`);
+        }
+        const stat = await fs.stat(resolved);
+        return { mtimeMs: stat.mtimeMs };
+    }
+    async glob(pattern, opts) {
+        const path = require('path');
+        const cwd = opts?.cwd ? this.resolve(opts.cwd) : this.workDir;
+        let matches;
+        try {
+            const fg = require('fast-glob');
+            matches = await fg(pattern, {
+                cwd,
+                dot: opts?.dot ?? false,
+                absolute: true,
+                ignore: opts?.ignore,
+            });
+        }
+        catch {
+            matches = await this.manualGlob(pattern, { cwd, dot: opts?.dot ?? false });
+        }
+        const filtered = matches.filter((entry) => this.isInside(entry, 'read'));
+        if (opts?.absolute) {
+            return filtered;
+        }
+        return filtered.map((entry) => path.relative(this.workDir, entry));
+    }
+    async manualGlob(pattern, opts) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const normalizedPattern = pattern.split(path.sep).join('/');
+        const results = [];
+        const walk = async (dir) => {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!opts.dot && entry.name.startsWith('.'))
+                    continue;
+                const full = path.join(dir, entry.name);
+                const rel = path.relative(opts.cwd, full).split(path.sep).join('/');
+                if (matchesGlob(normalizedPattern, rel)) {
+                    results.push(full);
+                }
+                if (entry.isDirectory()) {
+                    await walk(full);
+                }
+            }
+        };
+        await walk(opts.cwd);
+        return results;
+    }
+}
+function matchesGlob(pattern, target) {
+    const pSegs = pattern.split('/');
+    const tSegs = target.split('/');
+    return matchSegments(pSegs, tSegs);
+}
+function matchSegments(pattern, target) {
+    if (pattern.length === 0)
+        return target.length === 0;
+    const [head, ...rest] = pattern;
+    if (head === '**') {
+        return (matchSegments(rest, target) ||
+            (target.length > 0 && matchSegments(pattern, target.slice(1))));
+    }
+    if (target.length === 0)
+        return false;
+    if (!matchSegment(head, target[0]))
+        return false;
+    return matchSegments(rest, target.slice(1));
+}
+function matchSegment(pattern, target) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    const regex = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
+    return new RegExp(`^${regex}$`).test(target);
+}

package/dist/infra/store.d.ts

@@ -0,0 +1,154 @@
+import { Message, Timeline, Snapshot, AgentInfo, ToolCallRecord, Bookmark, AgentChannel } from '../core/types';
+import { TodoSnapshot } from '../core/todo';
+import { SkillsState } from '../skills/types';
+export interface HistoryWindow {
+    id: string;
+    messages: Message[];
+    events: Timeline[];
+    stats: {
+        messageCount: number;
+        tokenCount: number;
+        eventCount: number;
+    };
+    timestamp: number;
+}
+export interface CompressionRecord {
+    id: string;
+    windowId: string;
+    config: {
+        model: string;
+        prompt: string;
+        threshold: number;
+    };
+    summary: string;
+    ratio: number;
+    recoveredFiles: string[];
+    timestamp: number;
+}
+export interface RecoveredFile {
+    path: string;
+    content: string;
+    mtime: number;
+    timestamp: number;
+}
+/**
+ * Store 接口定义 Agent 持久化的所有能力
+ *
+ * 设计原则：
+ * 1. 所有方法都是必需的，不使用可选方法
+ * 2. 职责清晰：运行时状态、历史管理、事件流、元数据管理
+ * 3. 实现无关：接口不暴露存储细节（如 WAL、文件格式等）
+ */
+export interface Store {
+    /** 保存对话消息 */
+    saveMessages(agentId: string, messages: Message[]): Promise<void>;
+    /** 加载对话消息 */
+    loadMessages(agentId: string): Promise<Message[]>;
+    /** 保存工具调用记录 */
+    saveToolCallRecords(agentId: string, records: ToolCallRecord[]): Promise<void>;
+    /** 加载工具调用记录 */
+    loadToolCallRecords(agentId: string): Promise<ToolCallRecord[]>;
+    /** 保存 Todo 快照 */
+    saveTodos(agentId: string, snapshot: TodoSnapshot): Promise<void>;
+    /** 加载 Todo 快照 */
+    loadTodos(agentId: string): Promise<TodoSnapshot | undefined>;
+    /** 追加事件到流中 */
+    appendEvent(agentId: string, timeline: Timeline): Promise<void>;
+    /** 读取事件流（支持 Bookmark 续读和 Channel 过滤） */
+    readEvents(agentId: string, opts?: {
+        since?: Bookmark;
+        channel?: AgentChannel;
+    }): AsyncIterable<Timeline>;
+    /** 保存历史窗口（压缩前的完整快照） */
+    saveHistoryWindow(agentId: string, window: HistoryWindow): Promise<void>;
+    /** 加载所有历史窗口 */
+    loadHistoryWindows(agentId: string): Promise<HistoryWindow[]>;
+    /** 保存压缩记录 */
+    saveCompressionRecord(agentId: string, record: CompressionRecord): Promise<void>;
+    /** 加载所有压缩记录 */
+    loadCompressionRecords(agentId: string): Promise<CompressionRecord[]>;
+    /** 保存恢复文件快照 */
+    saveRecoveredFile(agentId: string, file: RecoveredFile): Promise<void>;
+    /** 加载所有恢复文件 */
+    loadRecoveredFiles(agentId: string): Promise<RecoveredFile[]>;
+    /** 保存快照 */
+    saveSnapshot(agentId: string, snapshot: Snapshot): Promise<void>;
+    /** 加载指定快照 */
+    loadSnapshot(agentId: string, snapshotId: string): Promise<Snapshot | undefined>;
+    /** 列出所有快照 */
+    listSnapshots(agentId: string): Promise<Snapshot[]>;
+    /** 保存 Agent 元信息 */
+    saveInfo(agentId: string, info: AgentInfo): Promise<void>;
+    /** 加载 Agent 元信息 */
+    loadInfo(agentId: string): Promise<AgentInfo | undefined>;
+    /** 保存 Skills 状态 */
+    saveSkillsState(agentId: string, state: SkillsState): Promise<void>;
+    /** 加载 Skills 状态 */
+    loadSkillsState(agentId: string): Promise<SkillsState | undefined>;
+    /** 检查 Agent 是否存在 */
+    exists(agentId: string): Promise<boolean>;
+    /** 删除 Agent 所有数据 */
+    delete(agentId: string): Promise<void>;
+    /** 列出所有 Agent ID */
+    list(prefix?: string): Promise<string[]>;
+}
+export declare class JSONStore implements Store {
+    private baseDir;
+    private flushIntervalMs;
+    private eventWriters;
+    private walQueue;
+    private walRecovered;
+    constructor(baseDir: string, flushIntervalMs?: number);
+    private getAgentDir;
+    private getRuntimePath;
+    private getEventsPath;
+    private getHistoryDir;
+    private getSnapshotsDir;
+    private getMetaPath;
+    saveMessages(agentId: string, messages: Message[]): Promise<void>;
+    loadMessages(agentId: string): Promise<Message[]>;
+    saveToolCallRecords(agentId: string, records: ToolCallRecord[]): Promise<void>;
+    loadToolCallRecords(agentId: string): Promise<ToolCallRecord[]>;
+    saveTodos(agentId: string, snapshot: TodoSnapshot): Promise<void>;
+    loadTodos(agentId: string): Promise<TodoSnapshot | undefined>;
+    saveSkillsState(agentId: string, state: SkillsState): Promise<void>;
+    loadSkillsState(agentId: string): Promise<SkillsState | undefined>;
+    private saveWithWal;
+    private loadWithWal;
+    private queueWalWrite;
+    /**
+     * Store 初始化时主动恢复所有 WAL 文件
+     */
+    private recoverAllWALs;
+    /**
+     * 恢复运行时数据的 WAL
+     */
+    private recoverRuntimeWAL;
+    /**
+     * 恢复事件流的 WAL
+     */
+    private recoverEventWALFile;
+    appendEvent(agentId: string, timeline: Timeline): Promise<void>;
+    readEvents(agentId: string, opts?: {
+        since?: Bookmark;
+        channel?: AgentChannel;
+    }): AsyncIterable<Timeline>;
+    private getEventWriters;
+    private flushEvents;
+    private recoverEventWal;
+    private writeEventWal;
+    saveHistoryWindow(agentId: string, window: HistoryWindow): Promise<void>;
+    loadHistoryWindows(agentId: string): Promise<HistoryWindow[]>;
+    saveCompressionRecord(agentId: string, record: CompressionRecord): Promise<void>;
+    loadCompressionRecords(agentId: string): Promise<CompressionRecord[]>;
+    saveRecoveredFile(agentId: string, file: RecoveredFile): Promise<void>;
+    loadRecoveredFiles(agentId: string): Promise<RecoveredFile[]>;
+    saveSnapshot(agentId: string, snapshot: Snapshot): Promise<void>;
+    loadSnapshot(agentId: string, snapshotId: string): Promise<Snapshot | undefined>;
+    listSnapshots(agentId: string): Promise<Snapshot[]>;
+    saveInfo(agentId: string, info: AgentInfo): Promise<void>;
+    loadInfo(agentId: string): Promise<AgentInfo | undefined>;
+    exists(agentId: string): Promise<boolean>;
+    delete(agentId: string): Promise<void>;
+    list(prefix?: string): Promise<string[]>;
+}