@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

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

@@ -1,342 +0,0 @@
-"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/vscode-session-store.js

@@ -1,22 +0,0 @@
-"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;