@shareai-lab/kode-sdk 2.7.1 → 2.7.2

package/dist/infra/e2b/e2b-fs.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2BFS = void 0;
+class E2BFS {
+    constructor(host) {
+        this.host = host;
+    }
+    resolve(p) {
+        if (p.startsWith('/'))
+            return p;
+        return `${this.host.workDir}/${p}`.replace(/\/+/g, '/');
+    }
+    isInside(_p) {
+        // E2B sandbox is fully isolated, all paths are safe
+        return true;
+    }
+    async read(p) {
+        const e2b = this.host.getE2BInstance();
+        const resolved = this.resolve(p);
+        return await e2b.files.read(resolved, { format: 'text' });
+    }
+    async write(p, content) {
+        const e2b = this.host.getE2BInstance();
+        const resolved = this.resolve(p);
+        // Ensure parent directory exists
+        const dir = resolved.replace(/\/[^/]+$/, '');
+        if (dir && dir !== '/') {
+            await e2b.commands.run(`mkdir -p "${dir}"`, { timeoutMs: 5000 }).catch(() => { });
+        }
+        await e2b.files.write(resolved, content);
+    }
+    temp(name) {
+        const tempName = name || `temp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        return `/tmp/${tempName}`;
+    }
+    async stat(p) {
+        const e2b = this.host.getE2BInstance();
+        const resolved = this.resolve(p);
+        const info = await e2b.files.getInfo(resolved);
+        return { mtimeMs: info.modifiedTime?.getTime() || Date.now() };
+    }
+    async glob(pattern, opts) {
+        const cwd = opts?.cwd ? this.resolve(opts.cwd) : this.host.workDir;
+        // Strategy 1: prefer find command (better performance)
+        try {
+            return await this.globViaFind(pattern, cwd, opts);
+        }
+        catch {
+            // Strategy 2: fallback to files.list recursion
+            return await this.globViaList(pattern, cwd, opts);
+        }
+    }
+    async globViaFind(pattern, cwd, opts) {
+        const e2b = this.host.getE2BInstance();
+        const findPattern = this.globToFindPattern(pattern);
+        let cmd = `find "${cwd}" ${findPattern} -type f`;
+        if (!opts?.dot) {
+            cmd += ' -not -path "*/.*"';
+        }
+        if (opts?.ignore?.length) {
+            for (const ig of opts.ignore) {
+                cmd += ` -not -path "${ig}"`;
+            }
+        }
+        const result = await e2b.commands.run(cmd, { timeoutMs: 30000 });
+        if (result.exitCode !== 0)
+            throw new Error(result.stderr);
+        const paths = result.stdout.split('\n').filter(Boolean);
+        if (opts?.absolute)
+            return paths;
+        return paths.map((p) => {
+            const rel = p.startsWith(cwd) ? p.slice(cwd.length).replace(/^\//, '') : p;
+            return rel;
+        });
+    }
+    async globViaList(pattern, cwd, opts) {
+        const e2b = this.host.getE2BInstance();
+        const results = [];
+        const walk = async (dir) => {
+            let entries;
+            try {
+                entries = await e2b.files.list(dir);
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const fullPath = `${dir}/${entry.name}`.replace(/\/+/g, '/');
+                if (!opts?.dot && entry.name.startsWith('.'))
+                    continue;
+                const rel = fullPath.startsWith(cwd)
+                    ? fullPath.slice(cwd.length).replace(/^\//, '')
+                    : fullPath;
+                if (this.matchGlob(pattern, rel)) {
+                    const ignored = opts?.ignore?.some((ig) => this.matchGlob(ig, rel));
+                    if (!ignored) {
+                        results.push(opts?.absolute ? fullPath : rel);
+                    }
+                }
+                if (entry.type === 'dir') {
+                    await walk(fullPath);
+                }
+            }
+        };
+        await walk(cwd);
+        return results;
+    }
+    /** @internal */
+    globToFindPattern(pattern) {
+        if (pattern.includes('/')) {
+            const findPat = pattern.replace(/\*\*/g, '*');
+            return `-path "*/${findPat}"`;
+        }
+        return `-name "${pattern}"`;
+    }
+    /** @internal */
+    matchGlob(pattern, target) {
+        const regex = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\?/g, '.')
+            .replace(/\*\*\//g, '<<<GLOBSTAR_SLASH>>>')
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*')
+            .replace(/<<<GLOBSTAR_SLASH>>>/g, '(.*/)?');
+        return new RegExp(`^${regex}$`).test(target);
+    }
+}
+exports.E2BFS = E2BFS;

package/dist/infra/e2b/e2b-sandbox.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2BSandbox = void 0;
+const e2b_1 = require("e2b");
+const e2b_fs_1 = require("./e2b-fs");
+class E2BSandbox {
+    constructor(options = {}) {
+        this.kind = 'e2b';
+        this.e2b = null;
+        this.watchers = new Map();
+        this.options = options;
+        this.workDir = options.workDir || '/home/user';
+        this.fs = new e2b_fs_1.E2BFS(this);
+    }
+    /** Initialize sandbox connection (create or resume) */
+    async init() {
+        if (this.options.sandboxId) {
+            this.e2b = await e2b_1.Sandbox.connect(this.options.sandboxId, {
+                apiKey: this.options.apiKey,
+                domain: this.options.domain,
+            });
+        }
+        else {
+            this.e2b = await e2b_1.Sandbox.create(this.options.template || 'base', {
+                apiKey: this.options.apiKey,
+                timeoutMs: this.options.timeoutMs || 300000,
+                envs: this.options.envs,
+                metadata: this.options.metadata,
+                domain: this.options.domain,
+            });
+        }
+    }
+    /** Get underlying E2B SDK instance */
+    getE2BInstance() {
+        if (!this.e2b)
+            throw new Error('E2BSandbox not initialized. Call init() first.');
+        return this.e2b;
+    }
+    /** Get sandbox ID (for persistence and resume) */
+    getSandboxId() {
+        return this.getE2BInstance().sandboxId;
+    }
+    /** Get accessible URL for a given port */
+    getHostUrl(port) {
+        return `https://${this.getE2BInstance().getHost(port)}`;
+    }
+    async exec(cmd, opts) {
+        const e2b = this.getE2BInstance();
+        const timeout = opts?.timeoutMs || this.options.execTimeoutMs || 120000;
+        try {
+            const result = await this.withRetry(() => e2b.commands.run(cmd, {
+                cwd: this.workDir,
+                timeoutMs: timeout,
+            }));
+            return {
+                code: result.exitCode,
+                stdout: result.stdout || '',
+                stderr: result.stderr || '',
+            };
+        }
+        catch (error) {
+            if (error.exitCode !== undefined) {
+                return {
+                    code: error.exitCode,
+                    stdout: error.stdout || '',
+                    stderr: error.stderr || error.message || '',
+                };
+            }
+            return {
+                code: 1,
+                stdout: '',
+                stderr: error.message || 'E2B command execution failed',
+            };
+        }
+    }
+    async watchFiles(paths, listener) {
+        const e2b = this.getE2BInstance();
+        const id = `e2b-watch-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        // E2B watchDir is directory-based, group paths by parent directory
+        const dirs = [...new Set(paths.map((p) => {
+                const resolved = this.fs.resolve(p);
+                return resolved.replace(/\/[^/]+$/, '') || '/';
+            }))];
+        const handles = [];
+        for (const dir of dirs) {
+            const handle = await e2b.files.watchDir(dir, (event) => {
+                const fullPath = `${dir}/${event.name}`.replace(/\/+/g, '/');
+                listener({ path: fullPath, mtimeMs: Date.now() });
+            }, { recursive: true });
+            handles.push(handle);
+        }
+        this.watchers.set(id, {
+            stop: async () => {
+                for (const h of handles)
+                    await h.stop();
+            },
+        });
+        return id;
+    }
+    unwatchFiles(id) {
+        const entry = this.watchers.get(id);
+        if (entry) {
+            entry.stop().catch(() => { });
+            this.watchers.delete(id);
+        }
+    }
+    async dispose() {
+        for (const entry of this.watchers.values()) {
+            await entry.stop().catch(() => { });
+        }
+        this.watchers.clear();
+        if (this.e2b) {
+            await this.e2b.kill();
+            this.e2b = null;
+        }
+    }
+    /** Extend sandbox lifetime */
+    async setTimeout(timeoutMs) {
+        await this.getE2BInstance().setTimeout(timeoutMs);
+    }
+    /** Check if sandbox is running */
+    async isRunning() {
+        try {
+            return await this.getE2BInstance().isRunning();
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Custom JSON serialization to avoid circular reference */
+    toJSON() {
+        return {
+            kind: this.kind,
+            workDir: this.workDir,
+            sandboxId: this.e2b?.sandboxId ?? null,
+            template: this.options.template,
+        };
+    }
+    async withRetry(fn, maxRetries = 3) {
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                const isRateLimit = error.name === 'RateLimitError' || error.status === 429;
+                if (isRateLimit && i < maxRetries - 1) {
+                    await new Promise((r) => setTimeout(r, Math.pow(2, i) * 1000));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error('Max retries exceeded');
+    }
+}
+exports.E2BSandbox = E2BSandbox;

package/dist/infra/e2b/e2b-template.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2BTemplateBuilder = void 0;
+/**
+ * Build E2B custom templates.
+ * Uses E2B Template API to create pre-configured sandbox environments.
+ */
+class E2BTemplateBuilder {
+    /**
+     * Build a template from config.
+     * @returns Build result containing templateId
+     */
+    static async build(config, opts) {
+        const { Template } = await Promise.resolve().then(() => __importStar(require('e2b')));
+        let template;
+        switch (config.base) {
+            case 'python':
+                template = Template().fromPythonImage(config.baseVersion || '3');
+                break;
+            case 'node':
+                template = Template().fromNodeImage(config.baseVersion || '20');
+                break;
+            case 'debian':
+                template = Template().fromDebianImage(config.baseVersion);
+                break;
+            case 'ubuntu':
+                template = Template().fromUbuntuImage(config.baseVersion);
+                break;
+            case 'custom':
+                if (!config.dockerfile)
+                    throw new Error('Custom base requires dockerfile content');
+                template = Template().fromDockerfile(config.dockerfile);
+                break;
+            default:
+                template = Template().fromBaseImage();
+        }
+        if (config.aptPackages?.length) {
+            template = template.aptInstall(config.aptPackages);
+        }
+        if (config.pipPackages?.length) {
+            template = template.pipInstall(config.pipPackages);
+        }
+        if (config.npmPackages?.length) {
+            template = template.npmInstall(config.npmPackages, { g: true });
+        }
+        if (config.buildCommands?.length) {
+            template = template.runCmd(config.buildCommands);
+        }
+        if (config.workDir) {
+            template = template.setWorkdir(config.workDir);
+        }
+        const buildInfo = await Template.build(template, {
+            alias: config.alias,
+            cpuCount: config.cpuCount || 2,
+            memoryMB: config.memoryMB || 512,
+            apiKey: opts?.apiKey,
+            onBuildLogs: opts?.onLog ? (log) => opts.onLog(String(log)) : undefined,
+        });
+        return {
+            templateId: buildInfo.templateId || config.alias,
+            alias: config.alias,
+        };
+    }
+    /**
+     * Check if a template alias already exists.
+     */
+    static async exists(alias, opts) {
+        const { Template } = await Promise.resolve().then(() => __importStar(require('e2b')));
+        return await Template.aliasExists(alias, { apiKey: opts?.apiKey });
+    }
+}
+exports.E2BTemplateBuilder = E2BTemplateBuilder;

package/dist/infra/e2b/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2BTemplateBuilder = exports.E2BFS = exports.E2BSandbox = void 0;
+var e2b_sandbox_1 = require("./e2b-sandbox");
+Object.defineProperty(exports, "E2BSandbox", { enumerable: true, get: function () { return e2b_sandbox_1.E2BSandbox; } });
+var e2b_fs_1 = require("./e2b-fs");
+Object.defineProperty(exports, "E2BFS", { enumerable: true, get: function () { return e2b_fs_1.E2BFS; } });
+var e2b_template_1 = require("./e2b-template");
+Object.defineProperty(exports, "E2BTemplateBuilder", { enumerable: true, get: function () { return e2b_template_1.E2BTemplateBuilder; } });

package/dist/infra/e2b/types.js

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

package/dist/infra/provider.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Provider Module
+ *
+ * Re-exports from the providers module for backward compatibility.
+ * The actual implementations are in src/infra/providers/.
+ *
+ * Usage:
+ * ```typescript
+ * import { AnthropicProvider, OpenAIProvider, GeminiProvider } from './infra/provider';
+ * // or
+ * import { AnthropicProvider } from './infra/providers';
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAnthropicDelta = exports.normalizeAnthropicContentBlock = exports.normalizeAnthropicContent = exports.mergeAnthropicBetaHeader = exports.hasAnthropicFileBlocks = exports.sanitizeGeminiSchema = exports.buildGeminiFilePart = exports.buildGeminiImagePart = exports.extractReasoningDetails = exports.splitThinkText = exports.normalizeThinkBlocks = exports.joinReasoningBlocks = exports.concatTextWithReasoning = exports.AUDIO_UNSUPPORTED_TEXT = exports.IMAGE_UNSUPPORTED_TEXT = exports.FILE_UNSUPPORTED_TEXT = exports.safeJsonStringify = exports.formatToolResult = exports.joinTextBlocks = exports.markTransportIfDegraded = exports.getMessageBlocks = exports.normalizeGeminiBaseUrl = exports.normalizeAnthropicBaseUrl = exports.normalizeOpenAIBaseUrl = exports.normalizeBaseUrl = exports.withProxy = exports.getProxyDispatcher = exports.resolveProxyUrl = exports.GeminiProvider = exports.OpenAIProvider = exports.AnthropicProvider = void 0;
+// Re-export provider implementations
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return providers_1.AnthropicProvider; } });
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return providers_1.OpenAIProvider; } });
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return providers_1.GeminiProvider; } });
+// Re-export utilities for backward compatibility
+var providers_2 = require("./providers");
+Object.defineProperty(exports, "resolveProxyUrl", { enumerable: true, get: function () { return providers_2.resolveProxyUrl; } });
+Object.defineProperty(exports, "getProxyDispatcher", { enumerable: true, get: function () { return providers_2.getProxyDispatcher; } });
+Object.defineProperty(exports, "withProxy", { enumerable: true, get: function () { return providers_2.withProxy; } });
+Object.defineProperty(exports, "normalizeBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeBaseUrl; } });
+Object.defineProperty(exports, "normalizeOpenAIBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeOpenAIBaseUrl; } });
+Object.defineProperty(exports, "normalizeAnthropicBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeAnthropicBaseUrl; } });
+Object.defineProperty(exports, "normalizeGeminiBaseUrl", { enumerable: true, get: function () { return providers_2.normalizeGeminiBaseUrl; } });
+Object.defineProperty(exports, "getMessageBlocks", { enumerable: true, get: function () { return providers_2.getMessageBlocks; } });
+Object.defineProperty(exports, "markTransportIfDegraded", { enumerable: true, get: function () { return providers_2.markTransportIfDegraded; } });
+Object.defineProperty(exports, "joinTextBlocks", { enumerable: true, get: function () { return providers_2.joinTextBlocks; } });
+Object.defineProperty(exports, "formatToolResult", { enumerable: true, get: function () { return providers_2.formatToolResult; } });
+Object.defineProperty(exports, "safeJsonStringify", { enumerable: true, get: function () { return providers_2.safeJsonStringify; } });
+Object.defineProperty(exports, "FILE_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return providers_2.FILE_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "IMAGE_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return providers_2.IMAGE_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "AUDIO_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return providers_2.AUDIO_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "concatTextWithReasoning", { enumerable: true, get: function () { return providers_2.concatTextWithReasoning; } });
+Object.defineProperty(exports, "joinReasoningBlocks", { enumerable: true, get: function () { return providers_2.joinReasoningBlocks; } });
+Object.defineProperty(exports, "normalizeThinkBlocks", { enumerable: true, get: function () { return providers_2.normalizeThinkBlocks; } });
+Object.defineProperty(exports, "splitThinkText", { enumerable: true, get: function () { return providers_2.splitThinkText; } });
+Object.defineProperty(exports, "extractReasoningDetails", { enumerable: true, get: function () { return providers_2.extractReasoningDetails; } });
+Object.defineProperty(exports, "buildGeminiImagePart", { enumerable: true, get: function () { return providers_2.buildGeminiImagePart; } });
+Object.defineProperty(exports, "buildGeminiFilePart", { enumerable: true, get: function () { return providers_2.buildGeminiFilePart; } });
+Object.defineProperty(exports, "sanitizeGeminiSchema", { enumerable: true, get: function () { return providers_2.sanitizeGeminiSchema; } });
+Object.defineProperty(exports, "hasAnthropicFileBlocks", { enumerable: true, get: function () { return providers_2.hasAnthropicFileBlocks; } });
+Object.defineProperty(exports, "mergeAnthropicBetaHeader", { enumerable: true, get: function () { return providers_2.mergeAnthropicBetaHeader; } });
+Object.defineProperty(exports, "normalizeAnthropicContent", { enumerable: true, get: function () { return providers_2.normalizeAnthropicContent; } });
+Object.defineProperty(exports, "normalizeAnthropicContentBlock", { enumerable: true, get: function () { return providers_2.normalizeAnthropicContentBlock; } });
+Object.defineProperty(exports, "normalizeAnthropicDelta", { enumerable: true, get: function () { return providers_2.normalizeAnthropicDelta; } });
+// Re-export core module (errors, usage, retry, logging, fork)
+__exportStar(require("./providers/core"), exports);