@shareai-lab/kode-sdk 2.7.1 → 2.7.2

package/dist/infra/providers/utils.js

@@ -0,0 +1,400 @@
+"use strict";
+/**
+ * Shared utilities for provider implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDIO_UNSUPPORTED_TEXT = exports.IMAGE_UNSUPPORTED_TEXT = exports.FILE_UNSUPPORTED_TEXT = void 0;
+exports.resolveProxyUrl = resolveProxyUrl;
+exports.getProxyDispatcher = getProxyDispatcher;
+exports.withProxy = withProxy;
+exports.normalizeBaseUrl = normalizeBaseUrl;
+exports.normalizeOpenAIBaseUrl = normalizeOpenAIBaseUrl;
+exports.normalizeAnthropicBaseUrl = normalizeAnthropicBaseUrl;
+exports.normalizeGeminiBaseUrl = normalizeGeminiBaseUrl;
+exports.getMessageBlocks = getMessageBlocks;
+exports.markTransportIfDegraded = markTransportIfDegraded;
+exports.joinTextBlocks = joinTextBlocks;
+exports.formatToolResult = formatToolResult;
+exports.safeJsonStringify = safeJsonStringify;
+exports.concatTextWithReasoning = concatTextWithReasoning;
+exports.joinReasoningBlocks = joinReasoningBlocks;
+exports.normalizeThinkBlocks = normalizeThinkBlocks;
+exports.splitThinkText = splitThinkText;
+exports.extractReasoningDetails = extractReasoningDetails;
+exports.buildGeminiImagePart = buildGeminiImagePart;
+exports.buildGeminiFilePart = buildGeminiFilePart;
+exports.sanitizeGeminiSchema = sanitizeGeminiSchema;
+exports.hasAnthropicFileBlocks = hasAnthropicFileBlocks;
+exports.mergeAnthropicBetaHeader = mergeAnthropicBetaHeader;
+exports.normalizeAnthropicContent = normalizeAnthropicContent;
+exports.normalizeAnthropicContentBlock = normalizeAnthropicContentBlock;
+exports.normalizeAnthropicDelta = normalizeAnthropicDelta;
+// =============================================================================
+// Proxy Handling
+// =============================================================================
+const proxyAgents = new Map();
+function resolveProxyUrl(explicit) {
+    if (explicit)
+        return explicit;
+    const flag = process.env.KODE_USE_ENV_PROXY;
+    if (!flag || ['0', 'false', 'no'].includes(flag.toLowerCase())) {
+        return undefined;
+    }
+    return (process.env.HTTPS_PROXY ||
+        process.env.https_proxy ||
+        process.env.HTTP_PROXY ||
+        process.env.http_proxy ||
+        process.env.ALL_PROXY ||
+        process.env.all_proxy);
+}
+function getProxyDispatcher(proxyUrl) {
+    const resolved = resolveProxyUrl(proxyUrl);
+    if (!resolved)
+        return undefined;
+    const cached = proxyAgents.get(resolved);
+    if (cached)
+        return cached;
+    let ProxyAgent;
+    try {
+        ({ ProxyAgent } = require('undici'));
+    }
+    catch (error) {
+        throw new Error(`Proxy support requires undici. Install it to use proxyUrl (${error?.message || error}).`);
+    }
+    const agent = new ProxyAgent(resolved);
+    proxyAgents.set(resolved, agent);
+    return agent;
+}
+function withProxy(init, dispatcher) {
+    if (!dispatcher)
+        return init;
+    return { ...init, dispatcher };
+}
+// =============================================================================
+// URL Normalization
+// =============================================================================
+function normalizeBaseUrl(url) {
+    return url.replace(/\/+$/, '');
+}
+function normalizeOpenAIBaseUrl(url) {
+    let normalized = url.replace(/\/+$/, '');
+    // Auto-append /v1 if not present (for OpenAI-compatible APIs)
+    if (!normalized.endsWith('/v1')) {
+        normalized += '/v1';
+    }
+    return normalized;
+}
+function normalizeAnthropicBaseUrl(url) {
+    let normalized = url.replace(/\/+$/, '');
+    if (normalized.endsWith('/v1')) {
+        normalized = normalized.slice(0, -3);
+    }
+    return normalized;
+}
+function normalizeGeminiBaseUrl(url) {
+    let normalized = url.replace(/\/+$/, '');
+    // Auto-append /v1beta if no version path present
+    if (!normalized.endsWith('/v1beta') && !normalized.endsWith('/v1')) {
+        normalized += '/v1beta';
+    }
+    return normalized;
+}
+// =============================================================================
+// Content Block Utilities
+// =============================================================================
+function getMessageBlocks(message) {
+    if (message.metadata?.transport === 'omit') {
+        return message.content;
+    }
+    return message.metadata?.content_blocks ?? message.content;
+}
+function markTransportIfDegraded(message, blocks) {
+    if (message.metadata?.transport === 'omit') {
+        return;
+    }
+    if (!message.metadata) {
+        message.metadata = { content_blocks: blocks, transport: 'text' };
+        return;
+    }
+    if (!message.metadata.content_blocks) {
+        message.metadata.content_blocks = blocks;
+    }
+    message.metadata.transport = 'text';
+}
+// =============================================================================
+// Text Formatting
+// =============================================================================
+function joinTextBlocks(blocks) {
+    return blocks
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+function formatToolResult(content) {
+    if (typeof content === 'string')
+        return content;
+    return safeJsonStringify(content);
+}
+function safeJsonStringify(value) {
+    try {
+        const json = JSON.stringify(value ?? {});
+        return json === undefined ? '{}' : json;
+    }
+    catch {
+        return '{}';
+    }
+}
+// =============================================================================
+// Unsupported Content Messages
+// =============================================================================
+exports.FILE_UNSUPPORTED_TEXT = '[file unsupported] This model does not support PDF input. Please extract text or images first.';
+exports.IMAGE_UNSUPPORTED_TEXT = '[image unsupported] This model does not support image URLs; please provide base64 data if supported.';
+exports.AUDIO_UNSUPPORTED_TEXT = '[audio unsupported] This model does not support audio input; please provide a text transcript instead.';
+// =============================================================================
+// Reasoning/Thinking Utilities
+// =============================================================================
+function concatTextWithReasoning(blocks, reasoningTransport = 'text') {
+    let text = '';
+    for (const block of blocks) {
+        if (block.type === 'text') {
+            text += block.text;
+        }
+        else if (block.type === 'reasoning' && reasoningTransport === 'text') {
+            text += `<think>${block.reasoning}</think>`;
+        }
+    }
+    return text;
+}
+function joinReasoningBlocks(blocks) {
+    return blocks
+        .filter((block) => block.type === 'reasoning')
+        .map((block) => block.reasoning)
+        .join('\n');
+}
+/**
+ * Parse <think> tags in text blocks and convert to reasoning blocks.
+ */
+function normalizeThinkBlocks(blocks, reasoningTransport = 'text') {
+    if (reasoningTransport !== 'text') {
+        return blocks;
+    }
+    const output = [];
+    for (const block of blocks) {
+        if (block.type !== 'text') {
+            output.push(block);
+            continue;
+        }
+        const parts = splitThinkText(block.text);
+        if (parts.length === 0) {
+            output.push(block);
+        }
+        else {
+            output.push(...parts);
+        }
+    }
+    return output;
+}
+function splitThinkText(text) {
+    const blocks = [];
+    const regex = /<think>([\s\S]*?)<\/think>/g;
+    let match;
+    let cursor = 0;
+    let matched = false;
+    while ((match = regex.exec(text)) !== null) {
+        matched = true;
+        const before = text.slice(cursor, match.index);
+        if (before) {
+            blocks.push({ type: 'text', text: before });
+        }
+        const reasoning = match[1] || '';
+        blocks.push({ type: 'reasoning', reasoning });
+        cursor = match.index + match[0].length;
+    }
+    if (!matched) {
+        return [];
+    }
+    const after = text.slice(cursor);
+    if (after) {
+        blocks.push({ type: 'text', text: after });
+    }
+    return blocks;
+}
+/**
+ * Extract reasoning details from OpenAI response (for reasoning models).
+ */
+function extractReasoningDetails(message) {
+    const details = Array.isArray(message?.reasoning_details) ? message.reasoning_details : [];
+    const content = typeof message?.reasoning_content === 'string' ? message.reasoning_content : undefined;
+    const blocks = [];
+    for (const detail of details) {
+        if (typeof detail?.text === 'string') {
+            blocks.push({ type: 'reasoning', reasoning: detail.text });
+        }
+    }
+    if (content) {
+        blocks.push({ type: 'reasoning', reasoning: content });
+    }
+    return blocks;
+}
+// =============================================================================
+// Gemini Helpers
+// =============================================================================
+function buildGeminiImagePart(block) {
+    if (block.file_id) {
+        return { file_data: { mime_type: block.mime_type, file_uri: block.file_id } };
+    }
+    if (block.url) {
+        if (block.url.startsWith('gs://')) {
+            return { file_data: { mime_type: block.mime_type, file_uri: block.url } };
+        }
+        return null;
+    }
+    if (block.base64 && block.mime_type) {
+        return { inline_data: { mime_type: block.mime_type, data: block.base64 } };
+    }
+    return null;
+}
+function buildGeminiFilePart(block) {
+    const mimeType = block.mime_type || 'application/pdf';
+    if (block.file_id) {
+        return { file_data: { mime_type: mimeType, file_uri: block.file_id } };
+    }
+    if (block.url) {
+        if (block.url.startsWith('gs://')) {
+            return { file_data: { mime_type: mimeType, file_uri: block.url } };
+        }
+        return null;
+    }
+    if (block.base64) {
+        return { inline_data: { mime_type: mimeType, data: block.base64 } };
+    }
+    return null;
+}
+function sanitizeGeminiSchema(schema) {
+    if (schema === null || schema === undefined)
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map((item) => sanitizeGeminiSchema(item));
+    if (typeof schema !== 'object')
+        return schema;
+    const cleaned = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'additionalProperties' || key === '$schema' || key === '$defs' || key === 'definitions') {
+            continue;
+        }
+        cleaned[key] = sanitizeGeminiSchema(value);
+    }
+    return cleaned;
+}
+// =============================================================================
+// Anthropic Helpers
+// =============================================================================
+function hasAnthropicFileBlocks(messages) {
+    for (const msg of messages) {
+        const blocks = getMessageBlocks(msg);
+        for (const block of blocks) {
+            if (block.type === 'file' && block.file_id) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function mergeAnthropicBetaHeader(existing, entries) {
+    const set = new Set();
+    if (existing) {
+        for (const e of existing.split(',')) {
+            const trimmed = e.trim();
+            if (trimmed)
+                set.add(trimmed);
+        }
+    }
+    for (const e of entries) {
+        if (e)
+            set.add(e);
+    }
+    return set.size > 0 ? Array.from(set).join(',') : undefined;
+}
+/**
+ * Normalize Anthropic response content to internal format.
+ */
+function normalizeAnthropicContent(content, reasoningTransport) {
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const block of content) {
+        const normalized = normalizeAnthropicContentBlock(block, reasoningTransport);
+        if (normalized)
+            blocks.push(normalized);
+    }
+    return blocks;
+}
+/**
+ * Normalize a single Anthropic content block.
+ * Handles thinking blocks with signature preservation.
+ */
+function normalizeAnthropicContentBlock(block, reasoningTransport) {
+    if (!block || typeof block !== 'object')
+        return null;
+    // Handle thinking blocks - preserve signature for conversation continuity
+    if (block.type === 'thinking') {
+        if (reasoningTransport === 'text') {
+            return { type: 'text', text: `<think>${block.thinking ?? ''}</think>` };
+        }
+        const result = { type: 'reasoning', reasoning: block.thinking ?? '' };
+        // Preserve signature for multi-turn conversations (critical for Claude 4+)
+        if (block.signature) {
+            result.meta = { signature: block.signature };
+        }
+        return result;
+    }
+    if (block.type === 'text') {
+        return { type: 'text', text: block.text ?? '' };
+    }
+    if (block.type === 'image' && block.source?.type === 'base64') {
+        return {
+            type: 'image',
+            base64: block.source.data,
+            mime_type: block.source.media_type,
+        };
+    }
+    if (block.type === 'document' && block.source?.type === 'file') {
+        return {
+            type: 'file',
+            file_id: block.source.file_id,
+            mime_type: block.source.media_type,
+        };
+    }
+    if (block.type === 'tool_use') {
+        return {
+            type: 'tool_use',
+            id: block.id,
+            name: block.name,
+            input: block.input ?? {},
+        };
+    }
+    if (block.type === 'tool_result') {
+        return {
+            type: 'tool_result',
+            tool_use_id: block.tool_use_id,
+            content: block.content,
+            is_error: block.is_error,
+        };
+    }
+    return null;
+}
+/**
+ * Normalize Anthropic streaming delta.
+ */
+function normalizeAnthropicDelta(delta) {
+    if (!delta) {
+        return { type: 'text_delta', text: '' };
+    }
+    if (delta.type === 'thinking_delta') {
+        return { type: 'reasoning_delta', text: delta.thinking ?? '' };
+    }
+    if (delta.type === 'input_json_delta') {
+        return { type: 'input_json_delta', partial_json: delta.partial_json ?? '' };
+    }
+    return { type: 'text_delta', text: delta.text ?? '' };
+}

package/dist/infra/sandbox-factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFactory = void 0;
+const sandbox_1 = require("./sandbox");
+const e2b_sandbox_1 = require("./e2b/e2b-sandbox");
+class SandboxFactory {
+    constructor() {
+        this.factories = new Map();
+        this.factories.set('local', (config) => new sandbox_1.LocalSandbox(config));
+        this.factories.set('e2b', (config) => new e2b_sandbox_1.E2BSandbox(config));
+    }
+    register(kind, factory) {
+        this.factories.set(kind, factory);
+    }
+    create(config) {
+        const factory = this.factories.get(config.kind);
+        if (!factory) {
+            throw new Error(`Sandbox factory not registered: ${config.kind}`);
+        }
+        return factory(config);
+    }
+    async createAsync(config) {
+        const sandbox = this.create(config);
+        if (config.kind === 'e2b' && sandbox instanceof e2b_sandbox_1.E2BSandbox) {
+            await sandbox.init();
+        }
+        return sandbox;
+    }
+}
+exports.SandboxFactory = SandboxFactory;

package/dist/infra/sandbox.js

@@ -0,0 +1,243 @@
+"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;
+        this.allowPaths = (opts.allowPaths || []).map((p) => path.resolve(p));
+        this.watchEnabled = opts.watchFiles !== false; // default true
+        this.fs = new LocalFS(this.workDir, {
+            enforceBoundary: this.enforceBoundary,
+            allowPaths: this.allowPaths,
+        });
+    }
+    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))
+                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) {
+        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 防止绕过）
+        return this.options.allowPaths.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)) {
+            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)) {
+            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');
+    }
+    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)) {
+            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));
+        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);
+}