@shareai-lab/kode-sdk 1.0.0-beta.0

package/dist/infra/store.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONStore = void 0;
+class JSONStore {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    getPath(sessionId, file) {
+        const fs = require('fs');
+        const path = require('path');
+        const dir = path.join(this.baseDir, sessionId);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return path.join(dir, file);
+    }
+    async saveMessages(sessionId, messages) {
+        const fs = require('fs').promises;
+        await fs.writeFile(this.getPath(sessionId, 'messages.json'), JSON.stringify(messages, null, 2));
+    }
+    async loadMessages(sessionId) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getPath(sessionId, 'messages.json'), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async appendEvent(sessionId, timeline) {
+        const fs = require('fs').promises;
+        const path = this.getPath(sessionId, 'events.jsonl');
+        await fs.appendFile(path, JSON.stringify(timeline) + '\n');
+    }
+    async *readEvents(sessionId, since) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getPath(sessionId, 'events.jsonl'), 'utf-8');
+            const events = data
+                .trim()
+                .split('\n')
+                .filter((line) => line)
+                .map((line) => JSON.parse(line));
+            const filtered = since !== undefined ? events.filter((e) => e.cursor >= since) : events;
+            for (const event of filtered) {
+                yield event;
+            }
+        }
+        catch {
+            // No events file, return empty
+            return;
+        }
+    }
+    async saveSnapshot(sessionId, snapshot) {
+        const fs = require('fs').promises;
+        const path = this.getPath(sessionId, `snapshot-${snapshot.id}.json`);
+        await fs.writeFile(path, JSON.stringify(snapshot, null, 2));
+    }
+    async loadSnapshot(sessionId, snapshotId) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getPath(sessionId, `snapshot-${snapshotId}.json`), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async listSnapshots(sessionId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dir = path.join(this.baseDir, sessionId);
+            const files = await fs.readdir(dir);
+            const snapshots = [];
+            for (const file of files) {
+                if (file.startsWith('snapshot-') && file.endsWith('.json')) {
+                    const data = await fs.readFile(path.join(dir, file), 'utf-8');
+                    snapshots.push(JSON.parse(data));
+                }
+            }
+            return snapshots;
+        }
+        catch {
+            return [];
+        }
+    }
+    async saveInfo(sessionId, info) {
+        const fs = require('fs').promises;
+        await fs.writeFile(this.getPath(sessionId, 'info.json'), JSON.stringify(info, null, 2));
+    }
+    async loadInfo(sessionId) {
+        const fs = require('fs').promises;
+        try {
+            const data = await fs.readFile(this.getPath(sessionId, 'info.json'), 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async exists(sessionId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            await fs.access(path.join(this.baseDir, sessionId));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async delete(sessionId) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const dir = path.join(this.baseDir, sessionId);
+        await fs.rm(dir, { recursive: true, force: true });
+    }
+    async list(prefix) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        try {
+            const dirs = await fs.readdir(this.baseDir);
+            return prefix ? dirs.filter((d) => d.startsWith(prefix)) : dirs;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.JSONStore = JSONStore;

package/dist/tools/bash.d.ts

@@ -0,0 +1,63 @@
+import { ToolContext } from '../core/types';
+import { Tool } from './fs';
+export declare class BashRun implements Tool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            cmd: {
+                type: string;
+                description: string;
+            };
+            timeout_ms: {
+                type: string;
+                description: string;
+            };
+            background: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    exec(args: {
+        cmd: string;
+        timeout_ms?: number;
+        background?: boolean;
+    }, ctx: ToolContext): Promise<any>;
+}
+export declare class BashLogs implements Tool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            shell_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    exec(args: {
+        shell_id: string;
+    }, ctx: ToolContext): Promise<any>;
+}
+export declare class BashKill implements Tool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            shell_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    exec(args: {
+        shell_id: string;
+    }, ctx: ToolContext): Promise<any>;
+}

package/dist/tools/bash.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BashKill = exports.BashLogs = exports.BashRun = void 0;
+const processes = new Map();
+class BashRun {
+    constructor() {
+        this.name = 'bash_run';
+        this.description = 'Execute a bash command';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                cmd: { type: 'string', description: 'Command to execute' },
+                timeout_ms: { type: 'number', description: 'Timeout in milliseconds (default: 120000)' },
+                background: { type: 'boolean', description: 'Run in background and return shell_id' },
+            },
+            required: ['cmd'],
+        };
+    }
+    async exec(args, ctx) {
+        if (args.background) {
+            const id = `shell-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+            const promise = ctx.sandbox.exec(args.cmd, { timeoutMs: args.timeout_ms });
+            const proc = {
+                id,
+                cmd: args.cmd,
+                startTime: Date.now(),
+                promise,
+                stdout: '',
+                stderr: '',
+            };
+            processes.set(id, proc);
+            promise.then((result) => {
+                proc.code = result.code;
+                proc.stdout = result.stdout;
+                proc.stderr = result.stderr;
+            });
+            return { shell_id: id, status: 'running' };
+        }
+        else {
+            const result = await ctx.sandbox.exec(args.cmd, { timeoutMs: args.timeout_ms });
+            return {
+                code: result.code,
+                stdout: result.stdout,
+                stderr: result.stderr,
+            };
+        }
+    }
+}
+exports.BashRun = BashRun;
+class BashLogs {
+    constructor() {
+        this.name = 'bash_logs';
+        this.description = 'Get output from a background bash shell';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                shell_id: { type: 'string', description: 'Shell ID from bash_run' },
+            },
+            required: ['shell_id'],
+        };
+    }
+    async exec(args, ctx) {
+        const proc = processes.get(args.shell_id);
+        if (!proc) {
+            throw new Error(`Shell not found: ${args.shell_id}`);
+        }
+        const isRunning = proc.code === undefined;
+        return {
+            shell_id: args.shell_id,
+            status: isRunning ? 'running' : 'completed',
+            code: proc.code,
+            stdout: proc.stdout,
+            stderr: proc.stderr,
+        };
+    }
+}
+exports.BashLogs = BashLogs;
+class BashKill {
+    constructor() {
+        this.name = 'bash_kill';
+        this.description = 'Kill a background bash shell';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                shell_id: { type: 'string', description: 'Shell ID from Bash.Run' },
+            },
+            required: ['shell_id'],
+        };
+    }
+    async exec(args, ctx) {
+        const proc = processes.get(args.shell_id);
+        if (!proc) {
+            throw new Error(`Shell not found: ${args.shell_id}`);
+        }
+        processes.delete(args.shell_id);
+        return { shell_id: args.shell_id, status: 'killed' };
+    }
+}
+exports.BashKill = BashKill;

package/dist/tools/builtin.d.ts

@@ -0,0 +1,15 @@
+import { Tool } from './fs';
+import { AgentTemplate } from './task';
+export declare const builtin: {
+    fs(opts?: {
+        workDir?: string;
+    }): Tool[];
+    bash(opts?: {
+        allow?: RegExp[];
+        block?: RegExp[];
+        approval?: boolean;
+    }): Tool[];
+    task(opts?: {
+        subAgents?: AgentTemplate[];
+    }): Tool;
+};

package/dist/tools/builtin.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtin = void 0;
+const fs_1 = require("./fs");
+const bash_1 = require("./bash");
+const task_1 = require("./task");
+exports.builtin = {
+    fs(opts) {
+        return [new fs_1.FsRead(), new fs_1.FsWrite(), new fs_1.FsEdit()].map((tool) => {
+            if (opts?.workDir) {
+                return (0, fs_1.toolTune)(tool, {
+                    preToolUse(call, ctx) {
+                        if ('file' in call.args) {
+                            call.args.file = ctx.sandbox.fs.resolve(call.args.file);
+                            if (!ctx.sandbox.fs.isInside(call.args.file)) {
+                                return { decision: 'deny', reason: `Path outside sandbox: ${call.args.file}` };
+                            }
+                        }
+                    },
+                    postToolUse(outcome, ctx) {
+                        const content = String(outcome.content || '');
+                        if (content.length > 100000) {
+                            const tempPath = ctx.sandbox.fs.temp(`tool-${outcome.id}.log`);
+                            ctx.sandbox.fs.write(tempPath, content);
+                            return {
+                                update: {
+                                    content: content.slice(0, 100000) + `\n\n[Full output at ./${tempPath}]`,
+                                },
+                            };
+                        }
+                    },
+                });
+            }
+            return tool;
+        });
+    },
+    bash(opts) {
+        const tools = [new bash_1.BashRun(), new bash_1.BashLogs(), new bash_1.BashKill()];
+        if (opts?.allow || opts?.block || opts?.approval) {
+            return tools.map((tool) => {
+                if (tool.name === 'bash_run') {
+                    return (0, fs_1.toolTune)(tool, {
+                        preToolUse(call, ctx) {
+                            const cmd = call.args.cmd;
+                            if (opts.block) {
+                                for (const pattern of opts.block) {
+                                    if (pattern.test(cmd)) {
+                                        return { decision: 'deny', reason: `Blocked command pattern: ${pattern}` };
+                                    }
+                                }
+                            }
+                            if (opts.allow) {
+                                let allowed = false;
+                                for (const pattern of opts.allow) {
+                                    if (pattern.test(cmd)) {
+                                        allowed = true;
+                                        break;
+                                    }
+                                }
+                                if (!allowed) {
+                                    return { decision: 'deny', reason: 'Command not in allow list' };
+                                }
+                            }
+                            if (opts.approval) {
+                                return { decision: 'ask', meta: { title: 'Bash Command Approval', cmd } };
+                            }
+                        },
+                        postToolUse(outcome, ctx) {
+                            const stdout = String(outcome.content?.stdout || '');
+                            const stderr = String(outcome.content?.stderr || '');
+                            const combined = stdout + stderr;
+                            if (combined.length > 100000) {
+                                const tempPath = ctx.sandbox.fs.temp(`bash-${outcome.id}.log`);
+                                ctx.sandbox.fs.write(tempPath, combined);
+                                return {
+                                    update: {
+                                        content: {
+                                            ...outcome.content,
+                                            stdout: stdout.slice(0, 50000) + `\n\n[Full stdout at ./${tempPath}]`,
+                                            stderr: stderr.slice(0, 50000),
+                                        },
+                                    },
+                                };
+                            }
+                        },
+                    });
+                }
+                return tool;
+            });
+        }
+        return tools;
+    },
+    task(opts) {
+        return new task_1.TaskRun(opts?.subAgents || []);
+    },
+};

package/dist/tools/fs.d.ts

@@ -0,0 +1,96 @@
+import { ToolContext, ToolOutcome, HookDecision, PostHookResult } from '../core/types';
+import { Hooks } from '../core/hooks';
+export interface Tool {
+    name: string;
+    description: string;
+    input_schema: any;
+    exec(args: any, ctx: ToolContext): Promise<any>;
+    hooks?: Hooks;
+    permissionDetails?: (call: any, ctx: ToolContext) => any;
+}
+export declare class FsRead implements Tool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            file: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    exec(args: {
+        file: string;
+        offset?: number;
+        limit?: number;
+    }, ctx: ToolContext): Promise<any>;
+}
+export declare class FsWrite implements Tool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            file: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    exec(args: {
+        file: string;
+        content: string;
+    }, ctx: ToolContext): Promise<any>;
+}
+export declare class FsEdit implements Tool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            file: {
+                type: string;
+                description: string;
+            };
+            old_string: {
+                type: string;
+                description: string;
+            };
+            new_string: {
+                type: string;
+                description: string;
+            };
+            replace_all: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    exec(args: {
+        file: string;
+        old_string: string;
+        new_string: string;
+        replace_all?: boolean;
+    }, ctx: ToolContext): Promise<any>;
+}
+export declare function toolTune(tool: Tool, hooks: {
+    preToolUse?: (call: any, ctx: ToolContext) => HookDecision | Promise<HookDecision>;
+    postToolUse?: (outcome: ToolOutcome, ctx: ToolContext) => PostHookResult | Promise<PostHookResult>;
+    permissionDetails?: (call: any, ctx: ToolContext) => any;
+}): Tool;

package/dist/tools/fs.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsEdit = exports.FsWrite = exports.FsRead = void 0;
+exports.toolTune = toolTune;
+class FsRead {
+    constructor() {
+        this.name = 'fs_read';
+        this.description = 'Read contents from a file';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Path to file' },
+                offset: { type: 'number', description: 'Line offset (optional)' },
+                limit: { type: 'number', description: 'Max lines to read (optional)' },
+            },
+            required: ['file'],
+        };
+    }
+    async exec(args, ctx) {
+        const content = await ctx.sandbox.fs.read(args.file);
+        const lines = content.split('\n');
+        const offset = args.offset || 0;
+        const limit = args.limit || lines.length;
+        const selected = lines.slice(offset, offset + limit);
+        return selected.join('\n');
+    }
+}
+exports.FsRead = FsRead;
+class FsWrite {
+    constructor() {
+        this.name = 'fs_write';
+        this.description = 'Write contents to a file (creates or overwrites)';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Path to file' },
+                content: { type: 'string', description: 'Content to write' },
+            },
+            required: ['file', 'content'],
+        };
+    }
+    async exec(args, ctx) {
+        await ctx.sandbox.fs.write(args.file, args.content);
+        return { success: true, file: args.file };
+    }
+}
+exports.FsWrite = FsWrite;
+class FsEdit {
+    constructor() {
+        this.name = 'fs_edit';
+        this.description = 'Edit a file by replacing old_string with new_string';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                file: { type: 'string', description: 'Path to file' },
+                old_string: { type: 'string', description: 'String to replace' },
+                new_string: { type: 'string', description: 'Replacement string' },
+                replace_all: { type: 'boolean', description: 'Replace all occurrences (default: false)' },
+            },
+            required: ['file', 'old_string', 'new_string'],
+        };
+    }
+    async exec(args, ctx) {
+        const content = await ctx.sandbox.fs.read(args.file);
+        if (args.replace_all) {
+            const updated = content.split(args.old_string).join(args.new_string);
+            await ctx.sandbox.fs.write(args.file, updated);
+            const count = content.split(args.old_string).length - 1;
+            return { success: true, file: args.file, replacements: count };
+        }
+        else {
+            const occurrences = content.split(args.old_string).length - 1;
+            if (occurrences === 0) {
+                throw new Error(`old_string not found in ${args.file}`);
+            }
+            if (occurrences > 1) {
+                throw new Error(`old_string appears ${occurrences} times; use replace_all=true or provide unique string`);
+            }
+            const updated = content.replace(args.old_string, args.new_string);
+            await ctx.sandbox.fs.write(args.file, updated);
+            return { success: true, file: args.file, replacements: 1 };
+        }
+    }
+}
+exports.FsEdit = FsEdit;
+function toolTune(tool, hooks) {
+    return {
+        ...tool,
+        hooks: {
+            ...tool.hooks,
+            preToolUse: hooks.preToolUse,
+            postToolUse: hooks.postToolUse,
+        },
+        permissionDetails: hooks.permissionDetails || tool.permissionDetails,
+    };
+}

package/dist/tools/task.d.ts

@@ -0,0 +1,38 @@
+import { ToolContext } from '../core/types';
+import { Tool } from './fs';
+export interface AgentTemplate {
+    id: string;
+    system?: string;
+    tools?: Tool[];
+    whenToUse?: string;
+}
+export declare class TaskRun implements Tool {
+    private subAgents;
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: {
+            task: {
+                type: string;
+                description: string;
+            };
+            with: {
+                type: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    constructor(subAgents: AgentTemplate[]);
+    exec(args: {
+        task: string;
+        with?: string;
+        context?: string;
+    }, ctx: ToolContext): Promise<any>;
+    private selectTemplate;
+}

package/dist/tools/task.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRun = void 0;
+class TaskRun {
+    constructor(subAgents) {
+        this.subAgents = subAgents;
+        this.name = 'task_run';
+        this.description = 'Delegate a task to a sub-agent';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                task: { type: 'string', description: 'Task description for the sub-agent' },
+                with: { type: 'string', description: 'Template ID to use (optional, will auto-select if omitted)' },
+                context: { type: 'string', description: 'Additional context (optional)' },
+            },
+            required: ['task'],
+        };
+    }
+    async exec(args, ctx) {
+        // This will be implemented when Agent class is ready
+        // For now, return a placeholder
+        const template = args.with
+            ? this.subAgents.find((t) => t.id === args.with)
+            : this.selectTemplate(args.task);
+        if (!template) {
+            throw new Error(`Template not found: ${args.with || 'auto'}`);
+        }
+        return {
+            status: 'delegated',
+            template: template.id,
+            task: args.task,
+            note: 'Sub-agent execution will be implemented in Agent class',
+        };
+    }
+    selectTemplate(task) {
+        // Simple heuristic selection based on whenToUse hints
+        for (const template of this.subAgents) {
+            if (template.whenToUse && task.toLowerCase().includes(template.whenToUse.toLowerCase())) {
+                return template;
+            }
+        }
+        return this.subAgents[0];
+    }
+}
+exports.TaskRun = TaskRun;