hakimi 0.1.0

package/dist/services/chatRouter.js

@@ -0,0 +1,246 @@
+import { readHakimiConfig } from '../utils/config.js';
+import { SessionCache } from './sessionCache.js';
+import { TheAgent } from './theAgent.js';
+export class ChatRouter {
+    ctx = null;
+    sessionCache;
+    options;
+    isRunning = false;
+    agentName = 'Hakimi';
+    retryTimeouts = new Map();
+    constructor(options) {
+        this.options = options;
+        this.sessionCache = new SessionCache((sessionId) => {
+            this.options.onSessionEnd(sessionId);
+        });
+    }
+    log(message) {
+        this.options.onLog?.(message);
+    }
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async sendWithRetry(fn, maxRetries) {
+        let lastError = null;
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                await fn();
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                const delay = Math.min(3000 * (i + 1), 30000); // 3s, 6s, 9s, ... up to 30s
+                this.log(`Send failed (${i + 1}/${maxRetries}), retry in ${delay / 1000}s...`);
+                await this.sleep(delay);
+            }
+        }
+        this.log(`Send failed after ${maxRetries} retries: ${lastError?.message}`);
+    }
+    async start() {
+        const config = await readHakimiConfig();
+        if (!config?.adapters || config.adapters.length === 0) {
+            throw new Error('No adapters configured');
+        }
+        this.agentName = config.agentName || 'Hakimi';
+        // Dynamic import koishi to avoid Node.js v24 compatibility issues at load time
+        const { Context, HTTP } = await import('koishi');
+        this.ctx = new Context();
+        // Register HTTP service (required by bot adapters)
+        this.ctx.plugin(HTTP);
+        for (const adapter of config.adapters) {
+            await this.loadAdapter(adapter);
+        }
+        // Listen for bot status updates
+        this.ctx.on('bot-status-updated', (bot) => {
+            this.log(`Bot ${bot.selfId || 'unknown'} status: ${bot.status}`);
+            // Status 3 = offline, try to reconnect
+            if (bot.status === 3) {
+                this.scheduleReconnect(bot);
+            }
+        });
+        // Listen for errors - don't crash, just log
+        this.ctx.on('internal/error', (error) => {
+            this.log(`Error: ${error.message || error}`);
+        });
+        this.ctx.on('message', (session) => {
+            this.log(`Message from ${session.userId}: ${session.content}`);
+            this.handleMessage(session);
+        });
+        this.log('Starting Koishi context...');
+        // Start with retry
+        await this.startWithRetry();
+        this.isRunning = true;
+    }
+    async startWithRetry(maxRetries = Infinity) {
+        let retries = 0;
+        while (retries < maxRetries) {
+            try {
+                await this.ctx.start();
+                // Log created bots
+                const bots = this.ctx.bots || [];
+                this.log(`Koishi started with ${bots.length} bot(s)`);
+                for (const bot of bots) {
+                    this.log(`Bot: ${bot.platform}/${bot.selfId || 'connecting...'} - ${bot.status}`);
+                }
+                return;
+            }
+            catch (error) {
+                retries++;
+                const delay = Math.min(5000 * retries, 30000); // Max 30s delay
+                this.log(`Start failed (${retries}), retrying in ${delay / 1000}s: ${error}`);
+                await this.sleep(delay);
+            }
+        }
+    }
+    scheduleReconnect(bot) {
+        const botKey = `${bot.platform}-${bot.selfId}`;
+        // Clear existing retry timeout
+        const existing = this.retryTimeouts.get(botKey);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        // Schedule reconnect
+        const timeout = setTimeout(async () => {
+            this.retryTimeouts.delete(botKey);
+            this.log(`Attempting to reconnect bot ${botKey}...`);
+            try {
+                await bot.start();
+                this.log(`Bot ${botKey} reconnected`);
+            }
+            catch (error) {
+                this.log(`Reconnect failed for ${botKey}: ${error}`);
+                // Schedule another retry
+                this.scheduleReconnect(bot);
+            }
+        }, 5000);
+        this.retryTimeouts.set(botKey, timeout);
+    }
+    async loadAdapter(adapter) {
+        if (!this.ctx)
+            return;
+        this.log(`Loading ${adapter.type} adapter...`);
+        switch (adapter.type) {
+            case 'telegram': {
+                const mod = await import('@koishijs/plugin-adapter-telegram');
+                const TelegramBot = mod.TelegramBot || mod.default;
+                this.ctx.plugin(TelegramBot, adapter.config);
+                this.log(`Telegram adapter loaded`);
+                break;
+            }
+            case 'slack': {
+                const mod = await import('@koishijs/plugin-adapter-slack');
+                const SlackBot = mod.SlackBot || mod.default;
+                this.ctx.plugin(SlackBot, adapter.config);
+                this.log(`Slack adapter loaded`);
+                break;
+            }
+            case 'feishu': {
+                const mod = await import('@koishijs/plugin-adapter-lark');
+                const LarkBot = mod.LarkBot || mod.default;
+                this.ctx.plugin(LarkBot, adapter.config);
+                this.log(`Feishu adapter loaded`);
+                break;
+            }
+        }
+    }
+    handleMessage(koishiSession) {
+        // Only handle private messages
+        if (koishiSession.guildId)
+            return;
+        const sessionId = `${koishiSession.platform}-${koishiSession.selfId}-${koishiSession.userId}`;
+        const content = koishiSession.content || '';
+        let chatSession = this.sessionCache.get(sessionId);
+        if (!chatSession) {
+            chatSession = {
+                sessionId,
+                platform: koishiSession.platform,
+                userId: koishiSession.userId || '',
+                botId: koishiSession.selfId || '',
+                isProcessing: false,
+                sendFn: async (message) => {
+                    await this.sendWithRetry(() => koishiSession.send(message), 10);
+                },
+                agent: null,
+                pendingMessage: null,
+            };
+            this.sessionCache.set(sessionId, chatSession);
+            this.options.onSessionStart(chatSession);
+        }
+        this.options.onMessage(sessionId, content);
+        // Process message with agent
+        this.processMessage(chatSession, content);
+    }
+    async processMessage(session, content) {
+        // If already processing, interrupt and queue the new message
+        if (session.isProcessing) {
+            this.log(`Interrupting current turn for ${session.sessionId}`);
+            session.pendingMessage = content;
+            if (session.agent) {
+                await session.agent.interrupt();
+            }
+            return;
+        }
+        session.isProcessing = true;
+        try {
+            // Create agent if not exists
+            if (!session.agent) {
+                this.log(`Creating agent for ${session.sessionId}`);
+                session.agent = new TheAgent(session.sessionId, this.agentName, {
+                    onSend: async (message) => {
+                        await session.sendFn(message);
+                    },
+                    onLog: (msg) => this.log(msg),
+                });
+                await session.agent.start();
+            }
+            // Process the message
+            await session.agent.sendMessage(content);
+            // Check for pending messages (new message came in while processing)
+            while (session.pendingMessage) {
+                const pending = session.pendingMessage;
+                session.pendingMessage = null;
+                this.log(`Processing pending message: ${pending}`);
+                await session.agent.sendMessage(pending);
+            }
+        }
+        catch (error) {
+            this.log(`Error processing message: ${error}`);
+        }
+        finally {
+            session.isProcessing = false;
+        }
+    }
+    getSession(sessionId) {
+        return this.sessionCache.get(sessionId);
+    }
+    async stop() {
+        // Clear all retry timeouts
+        for (const timeout of this.retryTimeouts.values()) {
+            clearTimeout(timeout);
+        }
+        this.retryTimeouts.clear();
+        // Close all agents
+        for (const session of this.sessionCache.values()) {
+            if (session.agent) {
+                await session.agent.close();
+            }
+        }
+        this.sessionCache.clear();
+        if (this.ctx) {
+            try {
+                await this.ctx.stop();
+            }
+            catch {
+                // Ignore stop errors
+            }
+            this.ctx = null;
+        }
+        this.isRunning = false;
+    }
+    get running() {
+        return this.isRunning;
+    }
+    get activeSessions() {
+        return this.sessionCache.size;
+    }
+}

package/dist/services/configAgent.d.ts

@@ -0,0 +1,18 @@
+export interface ConfigAgentCallbacks {
+    onText: (text: string) => void;
+    onAskUser: (question: string) => Promise<string>;
+    onFinished: () => void;
+    onError: (error: Error) => void;
+}
+export declare function loadConfigPrompt(): Promise<string>;
+export declare class ConfigAgent {
+    private session;
+    private currentTurn;
+    private callbacks;
+    private systemPrompt;
+    constructor(callbacks: ConfigAgentCallbacks);
+    start(): Promise<void>;
+    sendMessage(content: string): Promise<void>;
+    private handleEvent;
+    close(): Promise<void>;
+}

package/dist/services/configAgent.js

@@ -0,0 +1,125 @@
+import { readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createSession, createExternalTool } from '@moonshot-ai/kimi-agent-sdk';
+import { z } from 'zod';
+import { writeHakimiConfig } from '../utils/config.js';
+import { HAKIMI_DIR } from '../utils/paths.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CONFIG_SESSION_ID = 'hakimi-config-wizard';
+export async function loadConfigPrompt() {
+    const promptPath = join(__dirname, '../../prompts/config-agent.md');
+    return readFile(promptPath, 'utf-8');
+}
+export class ConfigAgent {
+    session = null;
+    currentTurn = null;
+    callbacks;
+    systemPrompt = '';
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+    }
+    async start() {
+        this.systemPrompt = await loadConfigPrompt();
+        // Ensure work directory exists
+        if (!existsSync(HAKIMI_DIR)) {
+            await mkdir(HAKIMI_DIR, { recursive: true });
+        }
+        const askUserTool = createExternalTool({
+            name: 'AskUser',
+            description: 'Ask user for input like API tokens or configuration values',
+            parameters: z.object({
+                question: z.string().describe('The question to ask the user'),
+            }),
+            handler: async (params) => {
+                const answer = await this.callbacks.onAskUser(params.question);
+                return { output: answer, message: '' };
+            },
+        });
+        const finishConfigTool = createExternalTool({
+            name: 'FinishConfig',
+            description: 'Save configuration and finish the wizard',
+            parameters: z.object({
+                agentName: z.string().optional().describe('Name for the AI assistant (default: Hakimi)'),
+                adapters: z.array(z.object({
+                    type: z.enum(['telegram', 'slack', 'feishu']),
+                    config: z.record(z.any()),
+                })).describe('List of adapter configurations to save'),
+            }),
+            handler: async (params) => {
+                await writeHakimiConfig({
+                    agentName: params.agentName || 'Hakimi',
+                    adapters: params.adapters,
+                });
+                this.callbacks.onFinished();
+                return { output: `Saved configuration: agent "${params.agentName || 'Hakimi'}" with ${params.adapters.length} adapter(s)`, message: '' };
+            },
+        });
+        this.session = createSession({
+            workDir: HAKIMI_DIR,
+            sessionId: CONFIG_SESSION_ID,
+            thinking: false,
+            yoloMode: true,
+            externalTools: [askUserTool, finishConfigTool],
+        });
+        // Clear previous session context
+        await this.sendMessage('/clear');
+        // Send initial prompt with system instructions
+        await this.sendMessage(this.systemPrompt + '\n\nPlease start by asking the user what they want to name their AI assistant.');
+    }
+    async sendMessage(content) {
+        if (!this.session) {
+            throw new Error('Session not started');
+        }
+        const turn = this.session.prompt(content);
+        this.currentTurn = turn;
+        try {
+            for await (const event of turn) {
+                this.handleEvent(event);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('interrupted')) {
+                return;
+            }
+            this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+        }
+        finally {
+            // Clear turn reference after completion
+            if (this.currentTurn === turn) {
+                this.currentTurn = null;
+            }
+        }
+    }
+    handleEvent(event) {
+        switch (event.type) {
+            case 'ContentPart':
+                if (event.payload.type === 'text') {
+                    this.callbacks.onText(event.payload.text);
+                }
+                break;
+            case 'ApprovalRequest':
+                // Auto-approve any pending requests
+                if (this.currentTurn) {
+                    this.currentTurn.approve(event.payload.id, 'approve').catch(() => { });
+                }
+                break;
+        }
+    }
+    async close() {
+        if (this.currentTurn) {
+            try {
+                await this.currentTurn.interrupt();
+            }
+            catch {
+                // Ignore interrupt errors on close
+            }
+            this.currentTurn = null;
+        }
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+    }
+}

package/dist/services/loginService.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'node:events';
+export interface LoginEvent {
+    type: 'info' | 'verification_url' | 'waiting' | 'success' | 'error';
+    message: string;
+    data?: {
+        verification_url?: string;
+        user_code?: string;
+    };
+}
+export interface LoginEmitter extends EventEmitter {
+    on(event: 'event', listener: (data: LoginEvent) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'close', listener: () => void): this;
+}
+export declare function startLogin(): LoginEmitter;

package/dist/services/loginService.js

@@ -0,0 +1,48 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+export function startLogin() {
+    const emitter = new EventEmitter();
+    const proc = spawn('kimi', ['login', '--json'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let buffer = '';
+    proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                emitter.emit('event', event);
+            }
+            catch {
+                // Ignore non-JSON lines
+            }
+        }
+    });
+    proc.stderr.on('data', (chunk) => {
+        const message = chunk.toString().trim();
+        if (message) {
+            emitter.emit('event', { type: 'error', message });
+        }
+    });
+    proc.on('error', (err) => {
+        emitter.emit('error', err);
+    });
+    proc.on('close', () => {
+        // Process remaining buffer
+        if (buffer.trim()) {
+            try {
+                const event = JSON.parse(buffer);
+                emitter.emit('event', event);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        emitter.emit('close');
+    });
+    return emitter;
+}

package/dist/services/sessionCache.d.ts

@@ -0,0 +1,18 @@
+export interface CachedSession<T> {
+    session: T;
+    lastActivity: number;
+    timer: ReturnType<typeof setTimeout>;
+}
+export declare class SessionCache<T> {
+    private sessions;
+    private onExpire;
+    constructor(onExpire: (sessionId: string, session: T) => void);
+    get(sessionId: string): T | undefined;
+    set(sessionId: string, session: T): void;
+    touch(sessionId: string): void;
+    private expire;
+    delete(sessionId: string): T | undefined;
+    clear(): void;
+    get size(): number;
+    values(): T[];
+}

package/dist/services/sessionCache.js

@@ -0,0 +1,69 @@
+const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
+export class SessionCache {
+    sessions = new Map();
+    onExpire;
+    constructor(onExpire) {
+        this.onExpire = onExpire;
+    }
+    get(sessionId) {
+        const cached = this.sessions.get(sessionId);
+        if (cached) {
+            this.touch(sessionId);
+            return cached.session;
+        }
+        return undefined;
+    }
+    set(sessionId, session) {
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            clearTimeout(existing.timer);
+        }
+        const timer = setTimeout(() => {
+            this.expire(sessionId);
+        }, SESSION_TTL_MS);
+        this.sessions.set(sessionId, {
+            session,
+            lastActivity: Date.now(),
+            timer,
+        });
+    }
+    touch(sessionId) {
+        const cached = this.sessions.get(sessionId);
+        if (cached) {
+            clearTimeout(cached.timer);
+            cached.lastActivity = Date.now();
+            cached.timer = setTimeout(() => {
+                this.expire(sessionId);
+            }, SESSION_TTL_MS);
+        }
+    }
+    expire(sessionId) {
+        const cached = this.sessions.get(sessionId);
+        if (cached) {
+            this.onExpire(sessionId, cached.session);
+            this.sessions.delete(sessionId);
+        }
+    }
+    delete(sessionId) {
+        const cached = this.sessions.get(sessionId);
+        if (cached) {
+            clearTimeout(cached.timer);
+            this.sessions.delete(sessionId);
+            return cached.session;
+        }
+        return undefined;
+    }
+    clear() {
+        for (const [sessionId, cached] of this.sessions) {
+            clearTimeout(cached.timer);
+            this.onExpire(sessionId, cached.session);
+        }
+        this.sessions.clear();
+    }
+    get size() {
+        return this.sessions.size;
+    }
+    values() {
+        return Array.from(this.sessions.values()).map((cached) => cached.session);
+    }
+}

package/dist/services/theAgent.d.ts

@@ -0,0 +1,19 @@
+export interface TheAgentCallbacks {
+    onSend: (message: string) => Promise<void>;
+    onLog?: (message: string) => void;
+}
+export declare class TheAgent {
+    private session;
+    private currentTurn;
+    private callbacks;
+    private sessionId;
+    private agentName;
+    private didSendMessage;
+    constructor(sessionId: string, agentName: string, callbacks: TheAgentCallbacks);
+    private log;
+    start(): Promise<void>;
+    sendMessage(content: string): Promise<void>;
+    private runPrompt;
+    interrupt(): Promise<void>;
+    close(): Promise<void>;
+}