@agenthippo-ai/agenthippo 0.1.0

package/out/runtime/interfaces/session-store.js

@@ -0,0 +1,342 @@
+"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.DirectorySessionStore = exports.FileSessionStore = exports.MemorySessionStore = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+/**
+ * In-memory session store.
+ * Suitable for eval mode (fresh state per example) and testing.
+ */
+class MemorySessionStore {
+    store = new Map();
+    get(key) {
+        return this.store.get(key);
+    }
+    async set(key, value) {
+        this.store.set(key, value);
+    }
+    /**
+     * Clear all stored values.
+     * Useful for testing or resetting state between eval examples.
+     */
+    clear() {
+        this.store.clear();
+    }
+}
+exports.MemorySessionStore = MemorySessionStore;
+/**
+ * File-based session store.
+ * Persists session data to a JSON file on disk. Suitable for headless
+ * production servers that need session persistence across restarts.
+ *
+ * Features:
+ * - Atomic writes (write to temp file, then rename)
+ * - Lazy loading (file read on first access)
+ * - In-memory cache for fast reads
+ *
+ * @example
+ * ```typescript
+ * import { FileSessionStore } from './runtime/interfaces/session-store';
+ * import { initSessionStoreWithStore } from './session';
+ *
+ * const store = new FileSessionStore('/var/lib/agentide/sessions.json');
+ * await store.load(); // Load existing sessions from disk
+ * initSessionStoreWithStore(store);
+ *
+ * // Sessions will now persist across server restarts
+ * ```
+ */
+class FileSessionStore {
+    store = {};
+    loaded = false;
+    filePath;
+    /**
+     * Create a file-based session store.
+     * @param filePath - Path to the JSON file for persistence
+     */
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /**
+     * Load existing sessions from disk.
+     * Call this before using the store to restore previous state.
+     * Safe to call multiple times (will only load once).
+     */
+    async load() {
+        if (this.loaded) {
+            return;
+        }
+        try {
+            const content = await fs_1.promises.readFile(this.filePath, 'utf-8');
+            this.store = JSON.parse(content);
+        }
+        catch (e) {
+            // File doesn't exist or is invalid - start fresh
+            if (e.code !== 'ENOENT') {
+                // Log but don't throw for parse errors - just start fresh
+                console.warn(`[FileSessionStore] Failed to load ${this.filePath}: ${e}`);
+            }
+            this.store = {};
+        }
+        this.loaded = true;
+    }
+    get(key) {
+        if (!this.loaded) {
+            this.loadSync();
+        }
+        return this.store[key];
+    }
+    async set(key, value) {
+        this.store[key] = value;
+        await this.flush();
+    }
+    /**
+     * Clear all stored values and persist to disk.
+     */
+    async clear() {
+        this.store = {};
+        await this.flush();
+    }
+    /**
+     * Flush current state to disk.
+     * Uses atomic write (temp file + rename) for safety.
+     */
+    async flush() {
+        const dir = path.dirname(this.filePath);
+        await fs_1.promises.mkdir(dir, { recursive: true });
+        // Atomic write: write to temp file, then rename
+        const tempPath = `${this.filePath}.tmp.${Date.now()}`;
+        const content = JSON.stringify(this.store, null, 2);
+        try {
+            await fs_1.promises.writeFile(tempPath, content, 'utf-8');
+            await fs_1.promises.rename(tempPath, this.filePath);
+        }
+        catch (e) {
+            // Clean up temp file on failure
+            try {
+                await fs_1.promises.unlink(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw e;
+        }
+    }
+    loadSync() {
+        if (this.loaded) {
+            return;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(this.filePath, 'utf-8');
+            this.store = JSON.parse(content);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                console.warn(`[FileSessionStore] Failed to load ${this.filePath}: ${e}`);
+            }
+            this.store = {};
+        }
+        this.loaded = true;
+    }
+}
+exports.FileSessionStore = FileSessionStore;
+/**
+ * Directory-backed session store: one file per session entry.
+ *
+ * Why this exists (serve-v3 §A1 / Q1): the single-file FileSessionStore writes
+ * the *entire* provider-session map on every turn. Under object-store sync
+ * (`aws s3 sync`) across a sticky-routed multi-replica fleet, two replicas each
+ * rewrite that one shared file and clobber each other's session map. Sharding to
+ * one file per session means a replica only ever touches the files for the
+ * sessions it owns, so per-session deltas sync cleanly and there is no shared
+ * hot file.
+ *
+ * Designed for the headless provider-session use: a single record-valued logical
+ * key (`Record<conversationKey, PersistedSession>`). `get(key)` returns the
+ * merged record; `set(key, record)` writes only changed entries and deletes files
+ * for entries no longer present (so pruning propagates to disk). Writes are
+ * atomic (temp + rename). On first load it migrates a legacy `<dir>.json`
+ * single-file store so existing sessions survive the cutover.
+ */
+class DirectorySessionStore {
+    dir;
+    /** Current merged entry map (entryKey -> value). */
+    entries = {};
+    /** entryKey -> last-written JSON, for delta detection. */
+    serialized = new Map();
+    /** entryKey -> on-disk filename. */
+    files = new Map();
+    loaded = false;
+    /** @param dir Directory that holds one JSON file per session entry. */
+    constructor(dir) {
+        this.dir = dir;
+    }
+    get(_key) {
+        if (!this.loaded) {
+            this.loadSync();
+        }
+        // Single record-valued logical key: always return the merged entry map.
+        return this.entries;
+    }
+    async set(_key, value) {
+        if (!this.loaded) {
+            this.loadSync();
+        }
+        const next = (value && typeof value === 'object') ? value : {};
+        await fs_1.promises.mkdir(this.dir, { recursive: true });
+        // Upsert changed/new entries (delta only).
+        for (const [entryKey, entryVal] of Object.entries(next)) {
+            const json = JSON.stringify(entryVal);
+            if (this.serialized.get(entryKey) === json) {
+                continue;
+            }
+            const fileName = this.files.get(entryKey) ?? `${this.fileNameFor(entryKey)}.json`;
+            await this.writeAtomic(fileName, JSON.stringify({ key: entryKey, value: entryVal }, null, 2));
+            this.files.set(entryKey, fileName);
+            this.serialized.set(entryKey, json);
+        }
+        // Delete entries that disappeared (e.g. pruned/TTL'd in session.ts).
+        for (const entryKey of [...this.serialized.keys()]) {
+            if (Object.prototype.hasOwnProperty.call(next, entryKey)) {
+                continue;
+            }
+            const fileName = this.files.get(entryKey);
+            if (fileName) {
+                try {
+                    await fs_1.promises.unlink(path.join(this.dir, fileName));
+                }
+                catch {
+                    // Already gone — fine.
+                }
+            }
+            this.files.delete(entryKey);
+            this.serialized.delete(entryKey);
+        }
+        this.entries = { ...next };
+    }
+    fileNameFor(entryKey) {
+        return (0, crypto_1.createHash)('sha256').update(entryKey).digest('hex').slice(0, 40);
+    }
+    async writeAtomic(fileName, content) {
+        const target = path.join(this.dir, fileName);
+        const tempPath = `${target}.tmp.${process.pid}.${Date.now()}`;
+        try {
+            await fs_1.promises.writeFile(tempPath, content, 'utf-8');
+            await fs_1.promises.rename(tempPath, target);
+        }
+        catch (e) {
+            try {
+                await fs_1.promises.unlink(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors.
+            }
+            throw e;
+        }
+    }
+    loadSync() {
+        if (this.loaded) {
+            return;
+        }
+        this.loaded = true;
+        this.migrateLegacySingleFileSync();
+        let names;
+        try {
+            names = (0, fs_1.readdirSync)(this.dir).filter((n) => n.endsWith('.json'));
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                console.warn(`[DirectorySessionStore] Failed to list ${this.dir}: ${e}`);
+            }
+            return; // No directory yet — start empty.
+        }
+        for (const name of names) {
+            try {
+                const raw = (0, fs_1.readFileSync)(path.join(this.dir, name), 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed.key === 'string') {
+                    this.entries[parsed.key] = parsed.value;
+                    this.serialized.set(parsed.key, JSON.stringify(parsed.value));
+                    this.files.set(parsed.key, name);
+                }
+            }
+            catch (e) {
+                console.warn(`[DirectorySessionStore] Skipping unreadable ${name}: ${e}`);
+            }
+        }
+    }
+    /**
+     * One-time import from the legacy single-file store at `<dir>.json` (the old
+     * FileSessionStore path). Runs only when the shard directory does not exist
+     * yet, so it never overwrites already-sharded state. The legacy file is
+     * `{ <logicalKey>: { <entryKey>: value } }`; we flatten the nested entries.
+     */
+    migrateLegacySingleFileSync() {
+        let dirExists = true;
+        try {
+            (0, fs_1.readdirSync)(this.dir);
+        }
+        catch {
+            dirExists = false;
+        }
+        if (dirExists) {
+            return;
+        }
+        const legacyPath = `${this.dir}.json`;
+        let parsed;
+        try {
+            parsed = JSON.parse((0, fs_1.readFileSync)(legacyPath, 'utf-8'));
+        }
+        catch {
+            return; // No legacy file — nothing to migrate.
+        }
+        for (const value of Object.values(parsed)) {
+            if (value && typeof value === 'object') {
+                for (const [entryKey, entryVal] of Object.entries(value)) {
+                    this.entries[entryKey] = entryVal;
+                }
+            }
+        }
+        // Imported entries are now in memory; the next set() writes them as shard
+        // files. If no turn happens, the legacy file stays and we re-migrate next
+        // boot (idempotent — no data loss).
+    }
+}
+exports.DirectorySessionStore = DirectorySessionStore;

package/out/runtime/vscode/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOverrideOpenAIBaseUrl = exports.VSCodeConfigProvider = exports.VSCodeSessionStore = exports.VSCodeEditTracker = exports.VSCodePermissionHandler = exports.VSCodeLogger = void 0;
+/**
+ * VS Code implementations of runtime interfaces.
+ */
+var vscode_logger_1 = require("./vscode-logger");
+Object.defineProperty(exports, "VSCodeLogger", { enumerable: true, get: function () { return vscode_logger_1.VSCodeLogger; } });
+var vscode_permission_handler_1 = require("./vscode-permission-handler");
+Object.defineProperty(exports, "VSCodePermissionHandler", { enumerable: true, get: function () { return vscode_permission_handler_1.VSCodePermissionHandler; } });
+var vscode_edit_tracker_1 = require("./vscode-edit-tracker");
+Object.defineProperty(exports, "VSCodeEditTracker", { enumerable: true, get: function () { return vscode_edit_tracker_1.VSCodeEditTracker; } });
+var vscode_session_store_1 = require("./vscode-session-store");
+Object.defineProperty(exports, "VSCodeSessionStore", { enumerable: true, get: function () { return vscode_session_store_1.VSCodeSessionStore; } });
+var vscode_config_provider_1 = require("./vscode-config-provider");
+Object.defineProperty(exports, "VSCodeConfigProvider", { enumerable: true, get: function () { return vscode_config_provider_1.VSCodeConfigProvider; } });
+Object.defineProperty(exports, "getOverrideOpenAIBaseUrl", { enumerable: true, get: function () { return vscode_config_provider_1.getOverrideOpenAIBaseUrl; } });

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

@@ -0,0 +1,77 @@
+"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.VSCodeConfigProvider = void 0;
+exports.getOverrideOpenAIBaseUrl = getOverrideOpenAIBaseUrl;
+const vscode = __importStar(require("vscode"));
+/**
+ * VS Code workspace configuration-based config provider.
+ */
+class VSCodeConfigProvider {
+    get(section, key, defaultValue) {
+        return vscode.workspace.getConfiguration(section).get(key, defaultValue);
+    }
+    getCustomProviders() {
+        return vscode.workspace.getConfiguration('agentide').get('providers.custom') || {};
+    }
+    getEngineSettings() {
+        const cfg = vscode.workspace.getConfiguration('agentide');
+        const claudeCheapModel = (cfg.get('claude.cheapModel', '') || '').trim();
+        return {
+            claudeMaxThinkingTokens: cfg.get('claude.maxThinkingTokens', 0),
+            ...(claudeCheapModel ? { claudeCheapModel } : {}),
+        };
+    }
+}
+exports.VSCodeConfigProvider = VSCodeConfigProvider;
+/**
+ * Get override OpenAI base URL for a given base URL by looking up custom provider config.
+ */
+function getOverrideOpenAIBaseUrl(configProvider, baseUrl) {
+    const customProviders = configProvider.getCustomProviders();
+    const normalizedInput = baseUrl.replace(/\/$/, '');
+    for (const providerConfig of Object.values(customProviders)) {
+        if (providerConfig.baseUrl) {
+            const normalizedProviderUrl = providerConfig.baseUrl.replace(/\/$/, '');
+            if (normalizedInput === normalizedProviderUrl && providerConfig.overrideOpenAIBaseUrl) {
+                return providerConfig.overrideOpenAIBaseUrl.trim();
+            }
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,120 @@
+"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.VSCodeEditTracker = void 0;
+const vscode = __importStar(require("vscode"));
+/**
+ * VS Code command-based edit tracker.
+ * Uses agentide.editing.* commands for file change tracking.
+ */
+class VSCodeEditTracker {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async startTracking(sessionId, files) {
+        if (files.length === 0) {
+            return undefined;
+        }
+        const timeoutMs = 5000;
+        const startTime = Date.now();
+        try {
+            const commandPromise = vscode.commands.executeCommand('agentide.editing.startExternal', { chatSessionId: sessionId, files });
+            const result = await Promise.race([
+                commandPromise,
+                new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+            ]);
+            if (result === null) {
+                this.logger?.warn(`startTracking timed out after ${timeoutMs}ms`);
+                // Fire-and-forget cleanup for late completion
+                void Promise.resolve(commandPromise).then(async (lateResult) => {
+                    if (lateResult?.operationId !== undefined) {
+                        this.logger?.debug(`Late startTracking completed, cleaning up operationId=${lateResult.operationId}`);
+                        try {
+                            await vscode.commands.executeCommand('agentide.editing.stopExternal', {
+                                chatSessionId: sessionId,
+                                operationId: lateResult.operationId,
+                            });
+                        }
+                        catch { /* ignore cleanup errors */ }
+                    }
+                }).catch(() => { });
+                return undefined;
+            }
+            if (result?.operationId !== undefined) {
+                this.logger?.debug(`startTracking completed in ${Date.now() - startTime}ms, operationId=${result.operationId}`);
+                return { operationId: result.operationId };
+            }
+            return undefined;
+        }
+        catch (e) {
+            this.logger?.warn(`startTracking failed (${Date.now() - startTime}ms): ${e}`);
+            return undefined;
+        }
+    }
+    async stopTracking(sessionId, operationId) {
+        const startTime = Date.now();
+        try {
+            // Note: No timeout here - we must wait for stopExternal to complete
+            // to ensure the editing session is properly finalized. Timing out
+            // would leave files in an incomplete/dirty state.
+            await vscode.commands.executeCommand('agentide.editing.stopExternal', {
+                chatSessionId: sessionId,
+                operationId,
+            });
+            this.logger?.debug(`stopTracking completed in ${Date.now() - startTime}ms`);
+        }
+        catch (e) {
+            this.logger?.warn(`stopTracking failed (${Date.now() - startTime}ms): ${e}`);
+        }
+    }
+    async applyEdit(sessionId, filePath, content, isNewFile) {
+        try {
+            await vscode.commands.executeCommand('agentide.editing.apply', {
+                chatSessionId: sessionId,
+                uri: vscode.Uri.file(filePath),
+                code: content,
+                isNewFile,
+            });
+        }
+        catch (e) {
+            this.logger?.warn(`applyEdit failed for ${filePath}: ${e}`);
+        }
+    }
+}
+exports.VSCodeEditTracker = VSCodeEditTracker;

package/out/runtime/vscode/vscode-logger.js

@@ -0,0 +1,30 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSCodeLogger = void 0;
+/**
+ * VS Code OutputChannel-based logger implementation.
+ */
+class VSCodeLogger {
+    channel;
+    prefix;
+    constructor(channel, prefix = '[AgentIDE]') {
+        this.channel = channel;
+        this.prefix = prefix;
+    }
+    debug(message) {
+        this.channel.appendLine(`${this.prefix} ${message}`);
+    }
+    info(message) {
+        this.channel.appendLine(`${this.prefix} ${message}`);
+    }
+    warn(message) {
+        this.channel.appendLine(`${this.prefix} Warning: ${message}`);
+    }
+    error(message, error) {
+        this.channel.appendLine(`${this.prefix} Error: ${message}${error ? `: ${error.message}` : ''}`);
+    }
+}
+exports.VSCodeLogger = VSCodeLogger;

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

@@ -0,0 +1,72 @@
+"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.VSCodePermissionHandler = void 0;
+const vscode = __importStar(require("vscode"));
+/**
+ * VS Code modal dialog-based permission handler.
+ */
+class VSCodePermissionHandler {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async requestPermission(request) {
+        this.logger?.debug(`Permission request: tool=${request.toolName}, toolUseId=${request.toolUseId ?? 'n/a'}`);
+        let detail;
+        if (request.toolInput) {
+            try {
+                const preview = JSON.stringify(request.toolInput).slice(0, 800);
+                detail = `Input: ${preview}${preview.length >= 800 ? '…' : ''}`;
+            }
+            catch {
+                // ignore non-serializable input
+            }
+        }
+        const allowLabel = 'Allow';
+        const denyLabel = 'Deny';
+        const choice = await vscode.window.showWarningMessage(`Allow agent to run the "${request.toolName}" tool?`, { modal: true, detail }, allowLabel, denyLabel);
+        if (choice === allowLabel) {
+            this.logger?.debug(`Permission granted: ${request.toolName}`);
+            return { behavior: 'allow' };
+        }
+        this.logger?.debug(`Permission denied: ${request.toolName}`);
+        return { behavior: 'deny', message: 'User denied permission request' };
+    }
+}
+exports.VSCodePermissionHandler = VSCodePermissionHandler;

package/out/runtime/vscode/vscode-session-store.js

@@ -0,0 +1,22 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSCodeSessionStore = void 0;
+/**
+ * VS Code extension globalState-based session store.
+ */
+class VSCodeSessionStore {
+    globalState;
+    constructor(globalState) {
+        this.globalState = globalState;
+    }
+    get(key) {
+        return this.globalState.get(key);
+    }
+    async set(key, value) {
+        await this.globalState.update(key, value);
+    }
+}
+exports.VSCodeSessionStore = VSCodeSessionStore;