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

package/dist/core/events.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+const types_1 = require("../core/types");
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+class EventBus extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.cursor = 0;
+        this.timeline = [];
+        this.subscribers = new Set();
+    }
+    setStore(store, sessionId) {
+        this.store = store;
+        this.sessionId = sessionId;
+    }
+    emitEvent(event) {
+        const cursor = this.cursor++;
+        const eventId = (0, crypto_1.randomUUID)();
+        const timestamp = Date.now();
+        const fullEvent = { ...event, cursor, eventId, timestamp };
+        const timeline = { cursor, event: fullEvent };
+        this.timeline.push(timeline);
+        // Memory management: keep only last 10k events in memory
+        if (this.timeline.length > 10000) {
+            this.timeline = this.timeline.slice(-5000);
+        }
+        // Persist to store if configured
+        if (this.store && this.sessionId) {
+            this.store.appendEvent(this.sessionId, timeline).catch((err) => {
+                // Log error but don't block event emission
+                console.error('Failed to persist event:', err);
+            });
+        }
+        // Notify all subscribers
+        for (const subscriber of this.subscribers) {
+            if (subscriber.accepts(fullEvent.type)) {
+                subscriber.push(fullEvent);
+            }
+        }
+        // Emit control plane events
+        this.emit(event.type, fullEvent);
+        return cursor;
+    }
+    subscribe(opts) {
+        const subscriber = new EventSubscriber(opts?.kinds || types_1.MINIMAL_EVENT_KINDS);
+        this.subscribers.add(subscriber);
+        // Replay past events if since is specified
+        if (opts?.since !== undefined) {
+            const past = this.timeline.filter((t) => t.cursor >= opts.since);
+            for (const t of past) {
+                if (subscriber.accepts(t.event.type)) {
+                    subscriber.push(t.event);
+                }
+            }
+        }
+        return {
+            [Symbol.asyncIterator]: () => ({
+                next: async () => {
+                    const event = await subscriber.next();
+                    if (!event) {
+                        this.subscribers.delete(subscriber);
+                        return { done: true, value: undefined };
+                    }
+                    return { done: false, value: event };
+                },
+            }),
+        };
+    }
+    getTimeline(since) {
+        return since !== undefined ? this.timeline.filter((t) => t.cursor >= since) : this.timeline;
+    }
+    getCursor() {
+        return this.cursor;
+    }
+    reset() {
+        this.cursor = 0;
+        this.timeline = [];
+        this.subscribers.clear();
+    }
+}
+exports.EventBus = EventBus;
+class EventSubscriber {
+    constructor(kinds) {
+        this.kinds = kinds;
+        this.queue = [];
+        this.waiting = null;
+        this.closed = false;
+    }
+    accepts(kind) {
+        return this.kinds.includes(kind);
+    }
+    push(event) {
+        if (this.closed)
+            return;
+        if (this.waiting) {
+            this.waiting(event);
+            this.waiting = null;
+        }
+        else {
+            this.queue.push(event);
+        }
+    }
+    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/hooks.d.ts

@@ -0,0 +1,23 @@
+import { ToolCall, ToolOutcome, HookDecision, PostHookResult, ToolContext } from '../core/types';
+import { ProviderResponse } from '../infra/provider';
+export interface Hooks {
+    preToolUse?: (call: ToolCall, ctx: ToolContext) => HookDecision | Promise<HookDecision>;
+    postToolUse?: (outcome: ToolOutcome, ctx: ToolContext) => PostHookResult | Promise<PostHookResult>;
+    preModel?: (request: any) => void | Promise<void>;
+    postModel?: (response: ProviderResponse) => void | Promise<void>;
+    messagesChanged?: (snapshot: any) => void | Promise<void>;
+}
+export interface RegisteredHook {
+    origin: 'agent' | 'toolTune';
+    names: Array<'preToolUse' | 'postToolUse' | 'preModel' | 'postModel'>;
+}
+export declare class HookManager {
+    private hooks;
+    register(hooks: Hooks, origin?: 'agent' | 'toolTune'): void;
+    getRegistered(): ReadonlyArray<RegisteredHook>;
+    runPreToolUse(call: ToolCall, ctx: ToolContext): Promise<HookDecision>;
+    runPostToolUse(outcome: ToolOutcome, ctx: ToolContext): Promise<ToolOutcome>;
+    runPreModel(request: any): Promise<void>;
+    runPostModel(response: ProviderResponse): Promise<void>;
+    runMessagesChanged(snapshot: any): Promise<void>;
+}

package/dist/core/hooks.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookManager = void 0;
+class HookManager {
+    constructor() {
+        this.hooks = [];
+    }
+    register(hooks, origin = 'agent') {
+        this.hooks.push({ hooks, origin });
+    }
+    getRegistered() {
+        return this.hooks.map(({ hooks, origin }) => ({
+            origin,
+            names: [
+                hooks.preToolUse && 'preToolUse',
+                hooks.postToolUse && 'postToolUse',
+                hooks.preModel && 'preModel',
+                hooks.postModel && 'postModel',
+            ].filter(Boolean),
+        }));
+    }
+    async runPreToolUse(call, ctx) {
+        for (const { hooks } of this.hooks) {
+            if (hooks.preToolUse) {
+                const result = await hooks.preToolUse(call, ctx);
+                if (result)
+                    return result;
+            }
+        }
+        return undefined;
+    }
+    async runPostToolUse(outcome, ctx) {
+        let current = outcome;
+        for (const { hooks } of this.hooks) {
+            if (hooks.postToolUse) {
+                const result = await hooks.postToolUse(current, ctx);
+                if (result) {
+                    if ('replace' in result) {
+                        current = result.replace;
+                    }
+                    else if ('update' in result) {
+                        current = { ...current, ...result.update };
+                    }
+                }
+            }
+        }
+        return current;
+    }
+    async runPreModel(request) {
+        for (const { hooks } of this.hooks) {
+            if (hooks.preModel) {
+                await hooks.preModel(request);
+            }
+        }
+    }
+    async runPostModel(response) {
+        for (const { hooks } of this.hooks) {
+            if (hooks.postModel) {
+                await hooks.postModel(response);
+            }
+        }
+    }
+    async runMessagesChanged(snapshot) {
+        for (const { hooks } of this.hooks) {
+            if (hooks.messagesChanged) {
+                await hooks.messagesChanged(snapshot);
+            }
+        }
+    }
+}
+exports.HookManager = HookManager;

package/dist/core/pool.d.ts

@@ -0,0 +1,33 @@
+import { Agent, AgentOptions } from '../core/agent';
+import { Store } from '../infra/store';
+import { AgentTemplate } from '../tools/task';
+import { AgentStatus, SnapshotId } from '../core/types';
+export interface AgentPoolOptions {
+    store: Store;
+    maxAgents?: number;
+}
+export declare class AgentPool {
+    private agents;
+    private store;
+    private maxAgents;
+    constructor(opts: AgentPoolOptions);
+    create(sessionId: string, templateOrOpts: AgentTemplate | AgentOptions, overrides?: Partial<AgentOptions>): Agent;
+    get(sessionId: string): Agent | undefined;
+    list(opts?: {
+        prefix?: string;
+    }): string[];
+    status(sessionId: string): Promise<AgentStatus | undefined>;
+    fork(sessionId: string, snapshotSel?: SnapshotId | {
+        at?: string;
+    }): Promise<Agent>;
+    resume(sessionId: string, opts: Omit<AgentOptions, 'sessionId' | 'store'> & {
+        autoRun?: boolean;
+        strategy?: 'crash' | 'manual';
+    }): Promise<Agent>;
+    resumeAll(configFactory: (sessionId: string) => Omit<AgentOptions, 'sessionId' | 'store'>, opts?: {
+        autoRun?: boolean;
+        strategy?: 'crash' | 'manual';
+    }): Promise<Agent[]>;
+    delete(sessionId: string): Promise<void>;
+    size(): number;
+}

package/dist/core/pool.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentPool = void 0;
+const agent_1 = require("../core/agent");
+class AgentPool {
+    constructor(opts) {
+        this.agents = new Map();
+        this.store = opts.store;
+        this.maxAgents = opts.maxAgents || 50;
+    }
+    create(sessionId, templateOrOpts, overrides) {
+        if (this.agents.has(sessionId)) {
+            throw new Error(`Agent already exists: ${sessionId}`);
+        }
+        if (this.agents.size >= this.maxAgents) {
+            throw new Error(`Pool is full (max ${this.maxAgents} agents)`);
+        }
+        const agent = new agent_1.Agent(templateOrOpts, overrides);
+        this.agents.set(sessionId, agent);
+        return agent;
+    }
+    get(sessionId) {
+        return this.agents.get(sessionId);
+    }
+    list(opts) {
+        const ids = Array.from(this.agents.keys());
+        return opts?.prefix ? ids.filter((id) => id.startsWith(opts.prefix)) : ids;
+    }
+    async status(sessionId) {
+        const agent = this.agents.get(sessionId);
+        return agent ? await agent.status() : undefined;
+    }
+    async fork(sessionId, snapshotSel) {
+        const agent = this.agents.get(sessionId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${sessionId}`);
+        }
+        return agent.fork(snapshotSel);
+    }
+    async resume(sessionId, opts) {
+        // 1. Check if already in pool
+        if (this.agents.has(sessionId)) {
+            return this.agents.get(sessionId);
+        }
+        // 2. Check pool capacity
+        if (this.agents.size >= this.maxAgents) {
+            throw new Error(`Pool is full (max ${this.maxAgents} agents)`);
+        }
+        // 3. Verify session exists
+        const exists = await this.store.exists(sessionId);
+        if (!exists) {
+            throw new Error(`Session not found in store: ${sessionId}`);
+        }
+        // 4. Use Agent.resume() to restore
+        const agent = await agent_1.Agent.resume(sessionId, {
+            ...opts,
+            sessionId,
+            store: this.store,
+        });
+        // 5. Add to pool
+        this.agents.set(sessionId, agent);
+        return agent;
+    }
+    async resumeAll(configFactory, opts) {
+        const sessionIds = await this.store.list();
+        const resumed = [];
+        for (const sessionId of sessionIds) {
+            if (this.agents.size >= this.maxAgents)
+                break;
+            if (this.agents.has(sessionId))
+                continue;
+            try {
+                const config = configFactory(sessionId);
+                const agent = await this.resume(sessionId, { ...config, ...opts });
+                resumed.push(agent);
+            }
+            catch (error) {
+                console.error(`Failed to resume ${sessionId}:`, error);
+            }
+        }
+        return resumed;
+    }
+    async delete(sessionId) {
+        this.agents.delete(sessionId);
+        await this.store.delete(sessionId);
+    }
+    size() {
+        return this.agents.size;
+    }
+}
+exports.AgentPool = AgentPool;

package/dist/core/room.d.ts

@@ -0,0 +1,15 @@
+import { AgentPool } from '../core/pool';
+export interface RoomMember {
+    name: string;
+    sessionId: string;
+}
+export declare class Room {
+    private pool;
+    private members;
+    constructor(pool: AgentPool);
+    join(name: string, sessionId: string): void;
+    leave(name: string): void;
+    say(from: string, text: string): Promise<void>;
+    getMembers(): RoomMember[];
+    private extractMentions;
+}

package/dist/core/room.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = void 0;
+class Room {
+    constructor(pool) {
+        this.pool = pool;
+        this.members = new Map();
+    }
+    join(name, sessionId) {
+        if (this.members.has(name)) {
+            throw new Error(`Member already exists: ${name}`);
+        }
+        this.members.set(name, sessionId);
+    }
+    leave(name) {
+        this.members.delete(name);
+    }
+    async say(from, text) {
+        const mentions = this.extractMentions(text);
+        if (mentions.length > 0) {
+            // Directed message
+            for (const mention of mentions) {
+                const sessionId = this.members.get(mention);
+                if (sessionId) {
+                    const agent = this.pool.get(sessionId);
+                    if (agent) {
+                        await agent.send(`[from:${from}] ${text}`);
+                    }
+                }
+            }
+        }
+        else {
+            // Broadcast to all except sender
+            for (const [name, sessionId] of this.members) {
+                if (name !== from) {
+                    const agent = this.pool.get(sessionId);
+                    if (agent) {
+                        await agent.send(`[from:${from}] ${text}`);
+                    }
+                }
+            }
+        }
+    }
+    getMembers() {
+        return Array.from(this.members.entries()).map(([name, sessionId]) => ({ name, sessionId }));
+    }
+    extractMentions(text) {
+        const regex = /@(\w+)/g;
+        const mentions = [];
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            mentions.push(match[1]);
+        }
+        return mentions;
+    }
+}
+exports.Room = Room;

package/dist/core/scheduler.d.ts

@@ -0,0 +1,26 @@
+type TimeInterval = string;
+type ScheduleCallback = (ctx?: any) => void | Promise<void>;
+export declare class Scheduler {
+    private tasks;
+    private stepCounters;
+    private timers;
+    every(interval: TimeInterval, callback: ScheduleCallback): this;
+    everySteps(steps: number, callback: ScheduleCallback, targetId?: string): this;
+    daily(time: string, callback: ScheduleCallback): this;
+    weekly(dayTime: string, callback: ScheduleCallback): this;
+    notifyStep(targetId?: string): void;
+    stop(): void;
+    private parseInterval;
+    private scheduleDailyTask;
+    private scheduleWeeklyTask;
+}
+export declare class AgentSchedulerHandle {
+    private scheduler;
+    private agentId?;
+    constructor(scheduler: Scheduler, agentId?: string | undefined);
+    every(interval: TimeInterval, callback: ScheduleCallback): this;
+    everySteps(steps: number, callback: ScheduleCallback): this;
+    daily(time: string, callback: ScheduleCallback): this;
+    weekly(dayTime: string, callback: ScheduleCallback): this;
+}
+export {};

package/dist/core/scheduler.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentSchedulerHandle = exports.Scheduler = void 0;
+class Scheduler {
+    constructor() {
+        this.tasks = new Map();
+        this.stepCounters = new Map();
+        this.timers = [];
+    }
+    every(interval, callback) {
+        const ms = this.parseInterval(interval);
+        const id = `time-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const task = {
+            id,
+            type: 'time',
+            spec: interval,
+            callback,
+            enabled: true,
+        };
+        this.tasks.set(id, task);
+        const timer = setInterval(() => {
+            if (task.enabled) {
+                task.callback({ count: 0, type: 'time', id });
+                task.lastRun = Date.now();
+            }
+        }, ms);
+        this.timers.push(timer);
+        return this;
+    }
+    everySteps(steps, callback, targetId) {
+        const id = targetId || `step-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const task = {
+            id,
+            type: 'step',
+            spec: steps,
+            callback,
+            enabled: true,
+        };
+        this.tasks.set(id, task);
+        this.stepCounters.set(id, 0);
+        return this;
+    }
+    daily(time, callback) {
+        const id = `daily-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const task = {
+            id,
+            type: 'daily',
+            spec: time,
+            callback,
+            enabled: true,
+        };
+        this.tasks.set(id, task);
+        this.scheduleDailyTask(task);
+        return this;
+    }
+    weekly(dayTime, callback) {
+        const id = `weekly-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const task = {
+            id,
+            type: 'weekly',
+            spec: dayTime,
+            callback,
+            enabled: true,
+        };
+        this.tasks.set(id, task);
+        this.scheduleWeeklyTask(task);
+        return this;
+    }
+    notifyStep(targetId) {
+        for (const [id, task] of this.tasks) {
+            if (task.type === 'step' && (!targetId || id === targetId)) {
+                const count = (this.stepCounters.get(id) || 0) + 1;
+                this.stepCounters.set(id, count);
+                if (count >= task.spec) {
+                    task.callback({ count, type: 'step', id });
+                    this.stepCounters.set(id, 0);
+                    task.lastRun = Date.now();
+                }
+            }
+        }
+    }
+    stop() {
+        for (const timer of this.timers) {
+            clearInterval(timer);
+        }
+        this.timers = [];
+        this.tasks.clear();
+        this.stepCounters.clear();
+    }
+    parseInterval(interval) {
+        const match = interval.match(/^(\d+)(s|m|h|d)$/);
+        if (!match)
+            throw new Error(`Invalid interval: ${interval}`);
+        const value = parseInt(match[1], 10);
+        const unit = match[2];
+        switch (unit) {
+            case 's':
+                return value * 1000;
+            case 'm':
+                return value * 60 * 1000;
+            case 'h':
+                return value * 60 * 60 * 1000;
+            case 'd':
+                return value * 24 * 60 * 60 * 1000;
+            default:
+                throw new Error(`Unknown unit: ${unit}`);
+        }
+    }
+    scheduleDailyTask(task) {
+        const [hours, minutes] = task.spec.split(':').map(Number);
+        const now = new Date();
+        const target = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes, 0);
+        if (target.getTime() <= now.getTime()) {
+            target.setDate(target.getDate() + 1);
+        }
+        const delay = target.getTime() - now.getTime();
+        const timeout = setTimeout(() => {
+            if (task.enabled) {
+                task.callback({ time: task.spec, type: 'daily', id: task.id });
+                task.lastRun = Date.now();
+            }
+            this.scheduleDailyTask(task);
+        }, delay);
+        this.timers.push(timeout);
+    }
+    scheduleWeeklyTask(task) {
+        const [day, time] = task.spec.split(' ');
+        const [hours, minutes] = time.split(':').map(Number);
+        const dayMap = {
+            Sun: 0,
+            Mon: 1,
+            Tue: 2,
+            Wed: 3,
+            Thu: 4,
+            Fri: 5,
+            Sat: 6,
+        };
+        const targetDay = dayMap[day];
+        if (targetDay === undefined)
+            throw new Error(`Invalid day: ${day}`);
+        const now = new Date();
+        const target = new Date(now);
+        target.setHours(hours, minutes, 0, 0);
+        const currentDay = now.getDay();
+        let daysUntilTarget = targetDay - currentDay;
+        if (daysUntilTarget < 0 || (daysUntilTarget === 0 && target.getTime() <= now.getTime())) {
+            daysUntilTarget += 7;
+        }
+        target.setDate(target.getDate() + daysUntilTarget);
+        const delay = target.getTime() - now.getTime();
+        const timeout = setTimeout(() => {
+            if (task.enabled) {
+                task.callback({ time: task.spec, type: 'weekly', id: task.id });
+                task.lastRun = Date.now();
+            }
+            this.scheduleWeeklyTask(task);
+        }, delay);
+        this.timers.push(timeout);
+    }
+}
+exports.Scheduler = Scheduler;
+class AgentSchedulerHandle {
+    constructor(scheduler, agentId) {
+        this.scheduler = scheduler;
+        this.agentId = agentId;
+    }
+    every(interval, callback) {
+        this.scheduler.every(interval, callback);
+        return this;
+    }
+    everySteps(steps, callback) {
+        this.scheduler.everySteps(steps, callback, this.agentId);
+        return this;
+    }
+    daily(time, callback) {
+        this.scheduler.daily(time, callback);
+        return this;
+    }
+    weekly(dayTime, callback) {
+        this.scheduler.weekly(dayTime, callback);
+        return this;
+    }
+}
+exports.AgentSchedulerHandle = AgentSchedulerHandle;