@soleri/core 2.10.0 → 2.11.0

package/src/chat/browser-session.ts

@@ -0,0 +1,188 @@
+/**
+ * Browser Session Manager — per-chat Playwright isolation.
+ *
+ * Manages a pool of Playwright MCP client sessions, one per chat.
+ * Lazy initialization on first use, idle timeout eviction, FIFO
+ * eviction when max sessions reached.
+ *
+ * The actual Playwright MCP server is spawned as a child process
+ * via stdio transport. This module manages the lifecycle.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+
+// ─── Types ────────────────────────────────────────────────────────────
+
+export interface BrowserSessionConfig {
+  /** Idle timeout before closing a session (ms). Default: 5 minutes. */
+  idleTimeoutMs?: number;
+  /** Max concurrent browser sessions. Default: 3. */
+  maxSessions?: number;
+  /** Command to spawn Playwright MCP. Default: 'npx'. */
+  command?: string;
+  /** Args for the command. Default: ['@playwright/mcp', '--headless']. */
+  args?: string[];
+}
+
+export interface BrowserSession {
+  chatId: string;
+  process: ChildProcess;
+  lastUsed: number;
+  idleTimer: ReturnType<typeof setTimeout> | null;
+}
+
+export interface BrowserTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface BrowserToolResult {
+  content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+  isError?: boolean;
+}
+
+// ─── Session Manager ─────────────────────────────────────────────────
+
+const DEFAULT_IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+const DEFAULT_MAX_SESSIONS = 3;
+
+export class BrowserSessionManager {
+  private sessions = new Map<string, BrowserSession>();
+  private readonly idleTimeoutMs: number;
+  private readonly maxSessions: number;
+  private readonly command: string;
+  private readonly args: string[];
+
+  constructor(config: BrowserSessionConfig = {}) {
+    this.idleTimeoutMs = config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT;
+    this.maxSessions = config.maxSessions ?? DEFAULT_MAX_SESSIONS;
+    this.command = config.command ?? 'npx';
+    this.args = config.args ?? ['@playwright/mcp', '--headless'];
+  }
+
+  /**
+   * Get or create a browser session for a chat.
+   * Returns the session, spawning a new process if needed.
+   */
+  acquire(chatId: string): BrowserSession {
+    const existing = this.sessions.get(chatId);
+    if (existing) {
+      // Reset idle timer
+      if (existing.idleTimer) clearTimeout(existing.idleTimer);
+      existing.lastUsed = Date.now();
+      existing.idleTimer = setTimeout(() => this.release(chatId), this.idleTimeoutMs);
+      return existing;
+    }
+
+    // Evict if at capacity
+    if (this.sessions.size >= this.maxSessions) {
+      this.evictOldest();
+    }
+
+    // Spawn new Playwright MCP process
+    const proc = spawn(this.command, this.args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    const session: BrowserSession = {
+      chatId,
+      process: proc,
+      lastUsed: Date.now(),
+      idleTimer: setTimeout(() => this.release(chatId), this.idleTimeoutMs),
+    };
+
+    proc.on('exit', () => {
+      // Clean up if process dies unexpectedly
+      const s = this.sessions.get(chatId);
+      if (s && s.process === proc) {
+        if (s.idleTimer) clearTimeout(s.idleTimer);
+        this.sessions.delete(chatId);
+      }
+    });
+
+    this.sessions.set(chatId, session);
+    return session;
+  }
+
+  /**
+   * Release a browser session (close process, remove from pool).
+   */
+  release(chatId: string): boolean {
+    const session = this.sessions.get(chatId);
+    if (!session) return false;
+
+    if (session.idleTimer) clearTimeout(session.idleTimer);
+
+    try {
+      session.process.kill();
+    } catch {
+      // Process may already be dead
+    }
+
+    this.sessions.delete(chatId);
+    return true;
+  }
+
+  /**
+   * Check if a chat has an active browser session.
+   */
+  has(chatId: string): boolean {
+    return this.sessions.has(chatId);
+  }
+
+  /**
+   * Close all browser sessions.
+   */
+  closeAll(): number {
+    let count = 0;
+    for (const chatId of this.sessions.keys()) {
+      if (this.release(chatId)) count++;
+    }
+    return count;
+  }
+
+  /**
+   * Get number of active sessions.
+   */
+  get size(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * List active session chat IDs.
+   */
+  listSessions(): string[] {
+    return [...this.sessions.keys()];
+  }
+
+  /**
+   * Get session info.
+   */
+  getInfo(chatId: string): { lastUsed: number; pid: number | null } | null {
+    const session = this.sessions.get(chatId);
+    if (!session) return null;
+    return {
+      lastUsed: session.lastUsed,
+      pid: session.process.pid ?? null,
+    };
+  }
+
+  /**
+   * Evict the oldest (least recently used) session.
+   */
+  private evictOldest(): void {
+    let oldest: string | null = null;
+    let oldestTime = Infinity;
+
+    for (const [chatId, session] of this.sessions) {
+      if (session.lastUsed < oldestTime) {
+        oldestTime = session.lastUsed;
+        oldest = chatId;
+      }
+    }
+
+    if (oldest) this.release(oldest);
+  }
+}

package/src/chat/cancellation.ts

@@ -0,0 +1,99 @@
+/**
+ * Task Cancellation Manager — per-chat AbortController management.
+ *
+ * Maps chat/session IDs to AbortControllers so running tasks can be
+ * cancelled from commands (e.g. /stop) or inline buttons.
+ *
+ * The agent loop already accepts AbortSignal — this provides the
+ * lifecycle management layer on top.
+ */
+
+export interface CancellationInfo {
+  /** The AbortController for this task. */
+  controller: AbortController;
+  /** Unix timestamp ms when the task started. */
+  startedAt: number;
+  /** Optional description of what's running. */
+  description?: string;
+}
+
+export class TaskCancellationManager {
+  private active = new Map<string, CancellationInfo>();
+
+  /**
+   * Create a new AbortController for a chat/session.
+   * If one already exists, it is cancelled first.
+   */
+  create(chatId: string, description?: string): AbortSignal {
+    // Cancel existing task if any
+    this.cancel(chatId);
+
+    const controller = new AbortController();
+    this.active.set(chatId, {
+      controller,
+      startedAt: Date.now(),
+      description,
+    });
+
+    return controller.signal;
+  }
+
+  /**
+   * Cancel the running task for a chat. Returns info about what was cancelled.
+   */
+  cancel(chatId: string): CancellationInfo | null {
+    const info = this.active.get(chatId);
+    if (!info) return null;
+
+    info.controller.abort();
+    this.active.delete(chatId);
+    return info;
+  }
+
+  /**
+   * Mark a task as complete (remove without aborting).
+   */
+  complete(chatId: string): void {
+    this.active.delete(chatId);
+  }
+
+  /**
+   * Check if a chat has a running task.
+   */
+  isRunning(chatId: string): boolean {
+    return this.active.has(chatId);
+  }
+
+  /**
+   * Get info about a running task.
+   */
+  getInfo(chatId: string): CancellationInfo | null {
+    return this.active.get(chatId) ?? null;
+  }
+
+  /**
+   * Get all running task IDs.
+   */
+  listRunning(): string[] {
+    return [...this.active.keys()];
+  }
+
+  /**
+   * Number of active tasks.
+   */
+  get size(): number {
+    return this.active.size;
+  }
+
+  /**
+   * Cancel all running tasks.
+   */
+  cancelAll(): number {
+    let count = 0;
+    for (const [chatId] of this.active) {
+      this.cancel(chatId);
+      count++;
+    }
+    return count;
+  }
+}

package/src/chat/chat-session.ts

@@ -0,0 +1,283 @@
+/**
+ * Chat Session Manager — per-conversation history with disk persistence.
+ *
+ * Ported from Salvador's session-manager.ts with improvements:
+ * - Transport-agnostic (no Telegram coupling)
+ * - Synchronous persistence (matches Soleri's better-sqlite3 heritage)
+ * - Simpler compaction (no personality tracking)
+ * - TTL-based reaping with unref'd timer
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ChatSession, ChatSessionConfig, ChatMessage } from './types.js';
+
+const DEFAULT_TTL_MS = 7_200_000; // 2 hours
+const DEFAULT_COMPACTION_THRESHOLD = 100;
+const DEFAULT_COMPACTION_KEEP = 40;
+const REAPER_INTERVAL_MS = 60_000; // 1 minute
+
+export class ChatSessionManager {
+  private sessions = new Map<string, ChatSession>();
+  private config: Required<ChatSessionConfig>;
+  private reaperTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(config: ChatSessionConfig) {
+    this.config = {
+      storageDir: config.storageDir,
+      ttlMs: config.ttlMs ?? DEFAULT_TTL_MS,
+      compactionThreshold: config.compactionThreshold ?? DEFAULT_COMPACTION_THRESHOLD,
+      compactionKeep: config.compactionKeep ?? DEFAULT_COMPACTION_KEEP,
+    };
+
+    mkdirSync(this.config.storageDir, { recursive: true });
+  }
+
+  // ─── Lifecycle ──────────────────────────────────────────────────
+
+  /**
+   * Get or create a session. Loads from disk if not in memory.
+   */
+  getOrCreate(sessionId: string): ChatSession {
+    let session = this.sessions.get(sessionId);
+    if (session) {
+      session.lastActiveAt = Date.now();
+      return session;
+    }
+
+    // Try loading from disk
+    session = this.loadFromDisk(sessionId);
+    if (session) {
+      session.lastActiveAt = Date.now();
+      this.sessions.set(sessionId, session);
+      return session;
+    }
+
+    // Create new
+    const now = Date.now();
+    session = {
+      id: sessionId,
+      messages: [],
+      createdAt: now,
+      lastActiveAt: now,
+    };
+    this.sessions.set(sessionId, session);
+    this.persistToDisk(session);
+    return session;
+  }
+
+  /**
+   * Get a session without creating one.
+   */
+  get(sessionId: string): ChatSession | undefined {
+    return this.sessions.get(sessionId) ?? this.loadFromDisk(sessionId);
+  }
+
+  /**
+   * Check if a session exists (memory or disk).
+   */
+  has(sessionId: string): boolean {
+    if (this.sessions.has(sessionId)) return true;
+    return existsSync(this.sessionPath(sessionId));
+  }
+
+  // ─── Message Management ─────────────────────────────────────────
+
+  /**
+   * Append a message and persist.
+   */
+  appendMessage(sessionId: string, message: ChatMessage): void {
+    const session = this.getOrCreate(sessionId);
+    session.messages.push(message);
+    session.lastActiveAt = Date.now();
+
+    // Auto-compact if threshold exceeded
+    if (session.messages.length > this.config.compactionThreshold) {
+      this.compact(session);
+    }
+
+    this.persistToDisk(session);
+  }
+
+  /**
+   * Append multiple messages (e.g. assistant response + tool blocks).
+   */
+  appendMessages(sessionId: string, messages: ChatMessage[]): void {
+    const session = this.getOrCreate(sessionId);
+    session.messages.push(...messages);
+    session.lastActiveAt = Date.now();
+
+    if (session.messages.length > this.config.compactionThreshold) {
+      this.compact(session);
+    }
+
+    this.persistToDisk(session);
+  }
+
+  /**
+   * Get message count for a session.
+   */
+  messageCount(sessionId: string): number {
+    const session = this.sessions.get(sessionId);
+    return session?.messages.length ?? 0;
+  }
+
+  // ─── Session Operations ─────────────────────────────────────────
+
+  /**
+   * Clear session history (keep session alive, wipe messages).
+   */
+  clear(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.messages = [];
+      session.lastActiveAt = Date.now();
+      this.persistToDisk(session);
+    } else {
+      // Remove from disk
+      this.removeFromDisk(sessionId);
+    }
+  }
+
+  /**
+   * Delete a session entirely (memory + disk).
+   */
+  delete(sessionId: string): void {
+    this.sessions.delete(sessionId);
+    this.removeFromDisk(sessionId);
+  }
+
+  /**
+   * List all active session IDs (memory only — disk sessions not loaded).
+   */
+  listActive(): string[] {
+    return [...this.sessions.keys()];
+  }
+
+  /**
+   * List all session IDs (memory + disk).
+   */
+  listAll(): string[] {
+    const memoryIds = new Set(this.sessions.keys());
+    try {
+      const files = readdirSync(this.config.storageDir);
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          memoryIds.add(f.replace('.json', ''));
+        }
+      }
+    } catch {
+      // Directory may not exist yet
+    }
+    return [...memoryIds];
+  }
+
+  /**
+   * Number of active (in-memory) sessions.
+   */
+  get size(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * Update session metadata.
+   */
+  setMeta(sessionId: string, meta: Record<string, unknown>): void {
+    const session = this.getOrCreate(sessionId);
+    session.meta = { ...session.meta, ...meta };
+    this.persistToDisk(session);
+  }
+
+  // ─── Reaping (TTL cleanup) ─────────────────────────────────────
+
+  /**
+   * Start periodic TTL-based session cleanup.
+   */
+  startReaper(): void {
+    if (this.reaperTimer) return;
+    this.reaperTimer = setInterval(() => this.reap(), REAPER_INTERVAL_MS);
+    this.reaperTimer.unref();
+  }
+
+  /**
+   * Stop the reaper.
+   */
+  stopReaper(): void {
+    if (this.reaperTimer) {
+      clearInterval(this.reaperTimer);
+      this.reaperTimer = null;
+    }
+  }
+
+  /**
+   * Reap expired sessions. Returns number of sessions reaped.
+   */
+  reap(): number {
+    if (this.config.ttlMs <= 0) return 0;
+
+    const now = Date.now();
+    const cutoff = now - this.config.ttlMs;
+    let reaped = 0;
+
+    for (const [id, session] of this.sessions) {
+      if (session.lastActiveAt < cutoff) {
+        this.sessions.delete(id);
+        this.removeFromDisk(id);
+        reaped++;
+      }
+    }
+
+    return reaped;
+  }
+
+  /**
+   * Close all sessions and stop reaper.
+   */
+  close(): void {
+    this.stopReaper();
+    this.sessions.clear();
+  }
+
+  // ─── Private ───────────────────────────────────────────────────
+
+  private compact(session: ChatSession): void {
+    const keep = this.config.compactionKeep;
+    if (session.messages.length <= keep) return;
+    session.messages = session.messages.slice(-keep);
+  }
+
+  private sessionPath(sessionId: string): string {
+    // Sanitize ID for filesystem safety
+    const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(this.config.storageDir, `${safe}.json`);
+  }
+
+  private persistToDisk(session: ChatSession): void {
+    try {
+      writeFileSync(this.sessionPath(session.id), JSON.stringify(session), 'utf-8');
+    } catch {
+      // Disk write failure is non-critical — session lives in memory
+    }
+  }
+
+  private loadFromDisk(sessionId: string): ChatSession | undefined {
+    const path = this.sessionPath(sessionId);
+    if (!existsSync(path)) return undefined;
+
+    try {
+      const data = readFileSync(path, 'utf-8');
+      return JSON.parse(data) as ChatSession;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private removeFromDisk(sessionId: string): void {
+    const path = this.sessionPath(sessionId);
+    try {
+      rmSync(path, { force: true });
+    } catch {
+      // Removal failure is non-critical
+    }
+  }
+}