@agenthippo-ai/agenthippo 0.1.0

package/out/remote/serveClient.js

@@ -0,0 +1,216 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildServeAuthHeaders = buildServeAuthHeaders;
+exports.normalizeServeBaseUrl = normalizeServeBaseUrl;
+exports.getRemoteServeUrl = getRemoteServeUrl;
+exports.streamRemoteServeChat = streamRemoteServeChat;
+/** Abort if the stream sends no data for this long (reset on every chunk). */
+const IDLE_TIMEOUT_MS = 120_000;
+/** Safety net so a runaway stream can't hold the conversation open forever. */
+const HARD_CAP_MS = 30 * 60_000;
+function buildServeAuthHeaders(auth) {
+    const headers = {};
+    if (!auth?.accessToken) {
+        return headers;
+    }
+    headers.Authorization = `Bearer ${auth.accessToken}`;
+    if (auth.userEmail?.trim()) {
+        headers['X-Agent-User'] = auth.userEmail.trim();
+    }
+    return headers;
+}
+function normalizeServeBaseUrl(url) {
+    return url.trim().replace(/\/+$/, '');
+}
+function getRemoteServeUrl(manifest) {
+    const url = manifest?.spec?.remote?.url?.trim();
+    return url || undefined;
+}
+async function streamRemoteServeChat(options, emitter) {
+    const base = normalizeServeBaseUrl(options.baseUrl);
+    const url = `${base}/v1/chat/stream`;
+    const body = { message: options.message };
+    if (options.sessionId?.trim()) {
+        body.session_id = options.sessionId.trim();
+    }
+    // Idle-based timeout: a stalled remote aborts, but a long turn that keeps streaming
+    // (slow model, long tool execution) is not cut off mid-stream. A hard cap guards against
+    // a runaway. Both abort via the same controller; the caller maps the abort into an error.
+    const ac = new AbortController();
+    const hardCap = setTimeout(() => ac.abort(new Error('Remote serve exceeded max duration')), HARD_CAP_MS);
+    let idleTimer;
+    const resetIdle = () => {
+        if (idleTimer) {
+            clearTimeout(idleTimer);
+        }
+        idleTimer = setTimeout(() => ac.abort(new Error('Remote serve timed out (idle)')), IDLE_TIMEOUT_MS);
+    };
+    const clearTimers = () => {
+        if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = undefined;
+        }
+        clearTimeout(hardCap);
+    };
+    resetIdle();
+    if (options.signal) {
+        options.signal.addEventListener('abort', () => ac.abort(options.signal.reason), { once: true });
+    }
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+                ...buildServeAuthHeaders(options.auth),
+            },
+            body: JSON.stringify(body),
+            signal: ac.signal,
+        });
+    }
+    catch (err) {
+        clearTimers();
+        const message = err instanceof Error ? err.message : 'Remote serve connection failed';
+        await emitter.error(message);
+        await emitter.done();
+        return;
+    }
+    if (!response.ok) {
+        clearTimers();
+        let errorMessage = `Remote serve returned ${response.status}`;
+        try {
+            const errBody = (await response.json());
+            if (errBody.error) {
+                errorMessage = errBody.error;
+            }
+        }
+        catch {
+            // ignore non-JSON error bodies
+        }
+        await emitter.error(errorMessage);
+        await emitter.done();
+        return;
+    }
+    if (!response.body) {
+        clearTimers();
+        await emitter.error('Remote serve returned empty body');
+        await emitter.done();
+        return;
+    }
+    try {
+        await consumeServeSse(response.body, emitter, resetIdle);
+    }
+    finally {
+        clearTimers();
+    }
+}
+async function consumeServeSse(body, emitter, resetIdle) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let doneEmitted = false;
+    const markDone = () => {
+        doneEmitted = true;
+    };
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            // Any data on the wire means the turn is progressing — push the idle window out.
+            resetIdle();
+            buffer += decoder.decode(value, { stream: true });
+            buffer = await drainServeSseBuffer(buffer, emitter, markDone);
+            if (doneEmitted) {
+                return;
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.trim()) {
+            await drainServeSseBuffer(`${buffer}\n`, emitter, markDone);
+        }
+        if (!doneEmitted) {
+            await emitter.done();
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function drainServeSseBuffer(buffer, emitter, markDone) {
+    const lines = buffer.split('\n');
+    const remainder = lines.pop() ?? '';
+    for (const line of lines) {
+        if (!line.startsWith('data: ')) {
+            continue;
+        }
+        const payload = line.slice(6).trim();
+        if (!payload) {
+            continue;
+        }
+        let event;
+        try {
+            event = JSON.parse(payload);
+        }
+        catch {
+            continue;
+        }
+        const finished = await dispatchServeEvent(event, emitter);
+        if (finished) {
+            markDone();
+            return '';
+        }
+    }
+    return remainder;
+}
+async function dispatchServeEvent(event, emitter) {
+    const type = typeof event.type === 'string' ? event.type : '';
+    switch (type) {
+        case 'thinking':
+            if (typeof event.delta === 'string') {
+                await emitter.thinking(event.delta);
+            }
+            return false;
+        case 'text':
+            if (typeof event.delta === 'string') {
+                await emitter.text(event.delta);
+            }
+            return false;
+        case 'tool_start':
+            await emitter.toolStart(typeof event.name === 'string' ? event.name : 'tool', typeof event.input === 'string' ? event.input : undefined, typeof event.tool_call_id === 'string' ? event.tool_call_id : undefined);
+            return false;
+        case 'tool_end':
+            await emitter.toolEnd(typeof event.name === 'string' ? event.name : 'tool', typeof event.tool_call_id === 'string' ? event.tool_call_id : '', typeof event.result === 'string' ? event.result : undefined, event.is_error === true);
+            return false;
+        case 'progress':
+            if (typeof event.message === 'string') {
+                await emitter.progress(event.message);
+            }
+            return false;
+        case 'question': {
+            // Remote serve auto-declines questions server-side and continues the run —
+            // the one-way SSE stream has no back-channel to deliver an answer. Surface the
+            // prompt for visibility rather than dropping it (default case) or blocking on an
+            // answer that can never reach the remote.
+            const payload = event.payload;
+            const prompt = typeof payload?.prompt === 'string' ? payload.prompt.trim() : '';
+            if (prompt) {
+                await emitter.progress(`Agent asked (auto-skipped on remote): ${prompt}`);
+            }
+            return false;
+        }
+        case 'error':
+            await emitter.error(typeof event.message === 'string' ? event.message : 'Remote serve error');
+            return false;
+        case 'done':
+            await emitter.done();
+            return true;
+        default:
+            return false;
+    }
+}

package/out/remoteSkills.js

@@ -0,0 +1,191 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+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.syncRemoteSkillsToAgentideSkillsDir = syncRemoteSkillsToAgentideSkillsDir;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const url_1 = require("url");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const REMOTE_MARKER_FILE = '.agentide-remote-skill.json';
+function requestText(url, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const u = new url_1.URL(url);
+        const lib = u.protocol === 'https:' ? https : http;
+        const req = lib.request({
+            method: 'GET',
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            headers: {
+                'accept': 'application/json, text/plain;q=0.9, */*;q=0.1',
+                'user-agent': 'AgentIDE/skills-sync',
+            },
+        }, res => {
+            const status = res.statusCode ?? 0;
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => resolve({ status, body: Buffer.concat(chunks).toString('utf8') }));
+        });
+        req.on('error', reject);
+        req.setTimeout(timeoutMs, () => req.destroy(new Error(`Request timed out after ${timeoutMs}ms`)));
+        req.end();
+    });
+}
+function requestBytes(url, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const u = new url_1.URL(url);
+        const lib = u.protocol === 'https:' ? https : http;
+        const req = lib.request({
+            method: 'GET',
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            headers: {
+                'accept': '*/*',
+                'user-agent': 'AgentIDE/skills-sync',
+            },
+        }, res => {
+            const status = res.statusCode ?? 0;
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => resolve({ status, body: Buffer.concat(chunks) }));
+        });
+        req.on('error', reject);
+        req.setTimeout(timeoutMs, () => req.destroy(new Error(`Request timed out after ${timeoutMs}ms`)));
+        req.end();
+    });
+}
+async function isAgentideManagedRemoteSkillDir(skillDir) {
+    try {
+        const markerPath = path.join(skillDir, REMOTE_MARKER_FILE);
+        const raw = await fs_1.promises.readFile(markerPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.registryUrl === 'string' && typeof parsed.id === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+async function writeRemoteMarker(skillDir, marker) {
+    const markerPath = path.join(skillDir, REMOTE_MARKER_FILE);
+    await fs_1.promises.writeFile(markerPath, JSON.stringify(marker, null, 2) + '\n', 'utf8');
+}
+/**
+ * Sync remote skills into the specified agentide skills directory.
+ *
+ * Notes:
+ * - This only pulls files declared by the registry (at minimum SKILL.md).
+ * - It avoids overwriting local project skills unless allowOverwriteLocal=true OR
+ *   the destination directory is already marked as a remote-managed skill.
+ */
+async function syncRemoteSkillsToAgentideSkillsDir(agentideSkillsDir, options, log) {
+    const { registryUrl, timeoutMs, allowOverwriteLocal } = options;
+    const base = registryUrl.replace(/\/+$/, '');
+    const indexUrl = `${base}/v1/skills`;
+    let index;
+    try {
+        const res = await requestText(indexUrl, timeoutMs);
+        if (res.status < 200 || res.status >= 300) {
+            log(`[AgentIDE] Remote skills: registry returned HTTP ${res.status} for ${indexUrl}`);
+            return { updated: 0, skipped: 0, errors: 1 };
+        }
+        index = JSON.parse(res.body);
+    }
+    catch (e) {
+        log(`[AgentIDE] Remote skills: failed to fetch index from ${indexUrl}: ${e instanceof Error ? e.message : String(e)}`);
+        return { updated: 0, skipped: 0, errors: 1 };
+    }
+    const skills = Array.isArray(index.skills) ? index.skills : [];
+    if (skills.length === 0) {
+        log('[AgentIDE] Remote skills: no skills returned by registry');
+        return { updated: 0, skipped: 0, errors: 0 };
+    }
+    await fs_1.promises.mkdir(agentideSkillsDir, { recursive: true });
+    let updated = 0;
+    let skipped = 0;
+    let errors = 0;
+    for (const skill of skills) {
+        if (!skill?.id || typeof skill.id !== 'string') {
+            continue;
+        }
+        const skillId = skill.id;
+        const skillDir = path.join(agentideSkillsDir, skillId);
+        const files = (skill.files && Array.isArray(skill.files) ? skill.files : ['SKILL.md'])
+            .filter(f => typeof f === 'string' && f.length > 0);
+        try {
+            const exists = await fs_1.promises.stat(skillDir).then(() => true).catch(() => false);
+            const isRemoteManaged = exists ? await isAgentideManagedRemoteSkillDir(skillDir) : false;
+            if (exists && !allowOverwriteLocal && !isRemoteManaged) {
+                skipped++;
+                log(`[AgentIDE] Remote skills: skipping ${skillId} (local skill dir exists and is not remote-managed)`);
+                continue;
+            }
+            await fs_1.promises.mkdir(skillDir, { recursive: true });
+            // Pull each declared file
+            for (const relPath of files) {
+                // Prevent directory traversal
+                if (relPath.includes('..') || relPath.startsWith('/') || relPath.startsWith('\\')) {
+                    continue;
+                }
+                const fileUrl = `${base}/v1/skills/${encodeURIComponent(skillId)}/files/${relPath.split('/').map(encodeURIComponent).join('/')}`;
+                const res = await requestBytes(fileUrl, timeoutMs);
+                if (res.status < 200 || res.status >= 300) {
+                    throw new Error(`HTTP ${res.status} for ${fileUrl}`);
+                }
+                const dst = path.join(skillDir, relPath);
+                await fs_1.promises.mkdir(path.dirname(dst), { recursive: true });
+                await fs_1.promises.writeFile(dst, res.body);
+            }
+            await writeRemoteMarker(skillDir, {
+                registryUrl: base,
+                id: skillId,
+                version: skill.version,
+                sha256: skill.sha256,
+                lastSyncedAt: new Date().toISOString(),
+            });
+            updated++;
+            log(`[AgentIDE] Remote skills: synced ${skillId} (${files.length} file(s))`);
+        }
+        catch (e) {
+            errors++;
+            log(`[AgentIDE] Remote skills: failed to sync ${skillId}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { updated, skipped, errors };
+}

package/out/runtime/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+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 });
+/**
+ * AgentIDE Runtime
+ *
+ * This module provides runtime abstractions for agent engines,
+ * enabling execution in different environments:
+ * - VS Code extension (production)
+ * - Eval mode (fresh state, auto-approve)
+ * - CLI/server (headless)
+ */
+// Re-export all interfaces
+__exportStar(require("./interfaces"), exports);
+// Re-export VS Code implementations
+__exportStar(require("./vscode"), exports);

package/out/runtime/interfaces/config-provider.js

@@ -0,0 +1,32 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticConfigProvider = void 0;
+/**
+ * Static configuration provider.
+ * Suitable for CLI, testing, and production where config is passed explicitly.
+ */
+class StaticConfigProvider {
+    config;
+    customProviders;
+    engineSettings;
+    constructor(config = {}, customProviders = {}, engineSettings = {}) {
+        this.config = config;
+        this.customProviders = customProviders;
+        this.engineSettings = engineSettings;
+    }
+    get(section, key, defaultValue) {
+        const fullKey = `${section}.${key}`;
+        const value = this.config[fullKey];
+        return (value !== undefined ? value : defaultValue);
+    }
+    getCustomProviders() {
+        return this.customProviders;
+    }
+    getEngineSettings() {
+        return this.engineSettings;
+    }
+}
+exports.StaticConfigProvider = StaticConfigProvider;

package/out/runtime/interfaces/edit-tracker.js

@@ -0,0 +1,22 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpEditTracker = void 0;
+/**
+ * No-op edit tracker.
+ * Suitable for eval mode, CLI, and production where edit tracking is not needed.
+ */
+class NoOpEditTracker {
+    async startTracking(_sessionId, _files) {
+        return undefined;
+    }
+    async stopTracking(_sessionId, _operationId) {
+        // No-op
+    }
+    async applyEdit(_sessionId, _filePath, _content, _isNewFile) {
+        // No-op
+    }
+}
+exports.NoOpEditTracker = NoOpEditTracker;

package/out/runtime/interfaces/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticConfigProvider = exports.DirectorySessionStore = exports.FileSessionStore = exports.MemorySessionStore = exports.NoOpEditTracker = exports.CLIPermissionHandler = exports.AutoDenyPermissionHandler = exports.AutoApprovePermissionHandler = exports.NoOpLogger = exports.ConsoleLogger = void 0;
+/**
+ * Runtime interfaces for AgentIDE engine abstraction.
+ *
+ * These interfaces abstract VS Code-specific dependencies to enable:
+ * - Eval mode execution (fresh state, auto-approve)
+ * - CLI/production server usage
+ * - Testing without VS Code
+ */
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return logger_1.ConsoleLogger; } });
+Object.defineProperty(exports, "NoOpLogger", { enumerable: true, get: function () { return logger_1.NoOpLogger; } });
+var permission_handler_1 = require("./permission-handler");
+Object.defineProperty(exports, "AutoApprovePermissionHandler", { enumerable: true, get: function () { return permission_handler_1.AutoApprovePermissionHandler; } });
+Object.defineProperty(exports, "AutoDenyPermissionHandler", { enumerable: true, get: function () { return permission_handler_1.AutoDenyPermissionHandler; } });
+Object.defineProperty(exports, "CLIPermissionHandler", { enumerable: true, get: function () { return permission_handler_1.CLIPermissionHandler; } });
+var edit_tracker_1 = require("./edit-tracker");
+Object.defineProperty(exports, "NoOpEditTracker", { enumerable: true, get: function () { return edit_tracker_1.NoOpEditTracker; } });
+var session_store_1 = require("./session-store");
+Object.defineProperty(exports, "MemorySessionStore", { enumerable: true, get: function () { return session_store_1.MemorySessionStore; } });
+Object.defineProperty(exports, "FileSessionStore", { enumerable: true, get: function () { return session_store_1.FileSessionStore; } });
+Object.defineProperty(exports, "DirectorySessionStore", { enumerable: true, get: function () { return session_store_1.DirectorySessionStore; } });
+var config_provider_1 = require("./config-provider");
+Object.defineProperty(exports, "StaticConfigProvider", { enumerable: true, get: function () { return config_provider_1.StaticConfigProvider; } });

package/out/runtime/interfaces/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpLogger = exports.ConsoleLogger = void 0;
+/**
+ * Console-based logger implementation.
+ * Suitable for CLI, testing, and production server use.
+ */
+class ConsoleLogger {
+    prefix;
+    constructor(prefix = '[AgentIDE]') {
+        this.prefix = prefix;
+    }
+    debug(message) {
+        console.debug(`${this.prefix} ${message}`);
+    }
+    info(message) {
+        console.log(`${this.prefix} ${message}`);
+    }
+    warn(message) {
+        console.warn(`${this.prefix} Warning: ${message}`);
+    }
+    error(message, error) {
+        console.error(`${this.prefix} Error: ${message}${error ? `: ${error.message}` : ''}`);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/**
+ * No-op logger for silent operation.
+ * Useful for testing or when logging is not desired.
+ */
+class NoOpLogger {
+    debug(_message) { }
+    info(_message) { }
+    warn(_message) { }
+    error(_message, _error) { }
+}
+exports.NoOpLogger = NoOpLogger;

package/out/runtime/interfaces/permission-handler.js

@@ -0,0 +1,66 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIPermissionHandler = exports.AutoDenyPermissionHandler = exports.AutoApprovePermissionHandler = void 0;
+/**
+ * Auto-approve permission handler.
+ * Approves all tool requests without prompting.
+ * Suitable for eval mode, trusted automation, and unrestricted agents.
+ */
+class AutoApprovePermissionHandler {
+    async requestPermission(_request) {
+        return { behavior: 'allow' };
+    }
+}
+exports.AutoApprovePermissionHandler = AutoApprovePermissionHandler;
+/**
+ * Auto-deny permission handler.
+ * Denies all tool requests.
+ * Useful for read-only modes or security testing.
+ */
+class AutoDenyPermissionHandler {
+    message;
+    constructor(message = 'All tool requests are denied') {
+        this.message = message;
+    }
+    async requestPermission(_request) {
+        return { behavior: 'deny', message: this.message };
+    }
+}
+exports.AutoDenyPermissionHandler = AutoDenyPermissionHandler;
+/**
+ * CLI permission handler that prompts the user in the terminal.
+ * Used when pack has approval: 'restricted'.
+ */
+class CLIPermissionHandler {
+    readline;
+    async requestPermission(request) {
+        // Lazy load readline to avoid issues in non-CLI contexts
+        if (!this.readline) {
+            this.readline = require('readline');
+        }
+        return new Promise((resolve) => {
+            const rl = this.readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const toolInfo = request.toolInput
+                ? `${request.toolName}: ${JSON.stringify(request.toolInput).slice(0, 100)}`
+                : request.toolName;
+            console.log(`\n⚠️  Tool permission requested: ${toolInfo}`);
+            rl.question('Allow? (y/n): ', (answer) => {
+                rl.close();
+                const allowed = answer.toLowerCase().startsWith('y');
+                if (allowed) {
+                    resolve({ behavior: 'allow' });
+                }
+                else {
+                    resolve({ behavior: 'deny', message: 'User denied permission' });
+                }
+            });
+        });
+    }
+}
+exports.CLIPermissionHandler = CLIPermissionHandler;