@auxiora/sessions 1.0.0

package/src/manager.ts

@@ -0,0 +1,343 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as crypto from 'node:crypto';
+import { getSessionsDir } from '@auxiora/core';
+import { audit } from '@auxiora/audit';
+import { SessionDatabase } from './db.js';
+import type { Session, SessionConfig, Message, MessageRole, SessionMetadata, Chat, ListChatsOptions } from './types.js';
+
+function generateMessageId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = crypto.randomBytes(4).toString('hex');
+  return `${timestamp}-${random}`;
+}
+
+export class SessionManager {
+  private sessions: Map<string, Session> = new Map();
+  private config: SessionConfig;
+  private db: SessionDatabase;
+  private sessionsDir: string;
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(config: SessionConfig) {
+    this.config = config;
+    this.sessionsDir = config.sessionsDir ?? getSessionsDir();
+    const dbPath = config.dbPath ?? path.join(this.sessionsDir, 'sessions.db');
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    this.db = new SessionDatabase(dbPath);
+
+    // Cleanup expired sessions every 5 minutes (non-webchat channels only)
+    this.cleanupInterval = setInterval(() => this.cleanupExpired(), 5 * 60 * 1000);
+  }
+
+  async initialize(): Promise<void> {
+    // Migrate legacy JSON session files to SQLite
+    let files: string[];
+    try {
+      files = fs.readdirSync(this.sessionsDir).filter(f => f.endsWith('.json'));
+    } catch {
+      return; // Directory doesn't exist or not readable
+    }
+
+    if (files.length === 0) return;
+
+    const migratedDir = path.join(this.sessionsDir, 'migrated');
+    fs.mkdirSync(migratedDir, { recursive: true });
+
+    for (const file of files) {
+      const filePath = path.join(this.sessionsDir, file);
+      try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(raw) as {
+          id: string;
+          messages: Array<{ id: string; role: string; content: string; timestamp: number; tokens?: { input?: number; output?: number } }>;
+          metadata: { channelType: string; senderId?: string; createdAt: number; lastActiveAt: number };
+        };
+
+        const title = data.metadata.channelType === 'webchat' ? 'New Chat' : `${data.metadata.channelType} session`;
+        this.db.insertChatWithId(
+          data.id,
+          title,
+          data.metadata.channelType,
+          data.metadata.createdAt,
+          data.metadata.lastActiveAt,
+          data.metadata.senderId,
+        );
+
+        for (const msg of data.messages) {
+          this.db.addMessage(
+            data.id,
+            msg.id,
+            msg.role,
+            msg.content,
+            msg.timestamp,
+            msg.tokens?.input,
+            msg.tokens?.output,
+          );
+        }
+
+        // Move original to migrated/
+        fs.renameSync(filePath, path.join(migratedDir, file));
+      } catch {
+        // Skip corrupt files — leave them in place
+      }
+    }
+  }
+
+  async create(metadata: Partial<SessionMetadata> & { channelType: string }): Promise<Session> {
+    const title = metadata.channelType === 'webchat' ? 'New Chat' : `${metadata.channelType} session`;
+    const chat = this.db.createChat(title, metadata.channelType, metadata.senderId);
+
+    const now = Date.now();
+    const session: Session = {
+      id: chat.id,
+      messages: [],
+      metadata: {
+        channelType: metadata.channelType,
+        senderId: metadata.senderId,
+        clientId: metadata.clientId,
+        createdAt: now,
+        lastActiveAt: now,
+      },
+    };
+
+    this.sessions.set(chat.id, session);
+    await audit('session.created', { sessionId: chat.id, channelType: metadata.channelType });
+    return session;
+  }
+
+  async get(id: string): Promise<Session | null> {
+    // Check in-memory cache
+    if (this.sessions.has(id)) {
+      return this.sessions.get(id)!;
+    }
+
+    // Check DB
+    const chat = this.db.getChat(id);
+    if (!chat) return null;
+
+    const messages = this.db.getMessages(id);
+    const session: Session = {
+      id: chat.id,
+      messages,
+      metadata: {
+        channelType: chat.channel,
+        senderId: (chat.metadata?.senderId as string | undefined),
+        clientId: (chat.metadata?.clientId as string | undefined),
+        createdAt: chat.createdAt,
+        lastActiveAt: chat.updatedAt,
+      },
+    };
+
+    this.sessions.set(id, session);
+    return session;
+  }
+
+  async getOrCreate(
+    key: string,
+    metadata: Partial<SessionMetadata> & { channelType: string },
+  ): Promise<Session> {
+    // Check in-memory cache first
+    for (const session of this.sessions.values()) {
+      if (
+        session.metadata.senderId === metadata.senderId &&
+        session.metadata.channelType === metadata.channelType
+      ) {
+        session.metadata.lastActiveAt = Date.now();
+        return session;
+      }
+    }
+
+    // Check DB
+    if (metadata.senderId) {
+      const chat = this.db.getOrCreateSessionChat(metadata.senderId, metadata.channelType);
+      const existing = this.sessions.get(chat.id);
+      if (existing) {
+        existing.metadata.lastActiveAt = Date.now();
+        return existing;
+      }
+
+      const messages = this.db.getMessages(chat.id);
+      const session: Session = {
+        id: chat.id,
+        messages,
+        metadata: {
+          channelType: metadata.channelType,
+          senderId: metadata.senderId,
+          clientId: metadata.clientId,
+          createdAt: chat.createdAt,
+          lastActiveAt: Date.now(),
+        },
+      };
+      this.sessions.set(chat.id, session);
+      return session;
+    }
+
+    // No senderId — create new
+    return this.create(metadata);
+  }
+
+  async addMessage(
+    sessionId: string,
+    role: MessageRole,
+    content: string,
+    tokens?: { input?: number; output?: number },
+  ): Promise<Message> {
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const message: Message = {
+      id: generateMessageId(),
+      role,
+      content,
+      timestamp: Date.now(),
+      tokens,
+    };
+
+    session.messages.push(message);
+    session.metadata.lastActiveAt = Date.now();
+
+    // Persist to DB
+    this.db.addMessage(sessionId, message.id, role, content, message.timestamp, tokens?.input, tokens?.output);
+
+    return message;
+  }
+
+  getMessages(sessionId: string): Message[] {
+    const session = this.sessions.get(sessionId);
+    if (session) return session.messages;
+
+    // Fall back to DB
+    return this.db.getMessages(sessionId);
+  }
+
+  getContextMessages(sessionId: string, maxTokens?: number): Message[] {
+    const limit = maxTokens || this.config.maxContextTokens;
+
+    // Try in-memory first
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      const messages: Message[] = [];
+      let tokenCount = 0;
+      for (let i = session.messages.length - 1; i >= 0; i--) {
+        const msg = session.messages[i];
+        const msgTokens = Math.ceil(msg.content.length / 4);
+        if (tokenCount + msgTokens > limit) break;
+        messages.unshift(msg);
+        tokenCount += msgTokens;
+      }
+      return messages;
+    }
+
+    // Fall back to DB
+    return this.db.getContextMessages(sessionId, limit);
+  }
+
+  async setSystemPrompt(sessionId: string, prompt: string): Promise<void> {
+    const session = await this.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    session.systemPrompt = prompt;
+  }
+
+  async save(_sessionId: string): Promise<void> {
+    // No-op — writes are immediate with SQLite
+  }
+
+  async delete(sessionId: string): Promise<boolean> {
+    const existed = this.sessions.delete(sessionId);
+    this.db.deleteChat(sessionId);
+
+    if (existed) {
+      await audit('session.destroyed', { sessionId });
+    }
+    return existed;
+  }
+
+  async clear(sessionId: string): Promise<void> {
+    const session = await this.get(sessionId);
+    if (!session) return;
+
+    session.messages = [];
+    session.metadata.lastActiveAt = Date.now();
+    this.db.clearMessages(sessionId);
+  }
+
+  async compact(sessionId: string, summary: string): Promise<void> {
+    const session = await this.get(sessionId);
+    if (!session || !this.config.compactionEnabled) return;
+
+    const originalCount = session.messages.length;
+    this.db.clearMessages(sessionId);
+
+    const summaryMessage: Message = {
+      id: generateMessageId(),
+      role: 'system',
+      content: `[Previous conversation summary]\n${summary}`,
+      timestamp: Date.now(),
+    };
+
+    session.messages = [summaryMessage];
+    session.metadata.lastActiveAt = Date.now();
+    this.db.addMessage(sessionId, summaryMessage.id, 'system', summaryMessage.content, summaryMessage.timestamp);
+
+    await audit('session.compacted', { sessionId, originalCount });
+  }
+
+  private cleanupExpired(): void {
+    const now = Date.now();
+    const ttlMs = this.config.ttlMinutes * 60 * 1000;
+
+    for (const [id, session] of this.sessions) {
+      // Only expire non-webchat sessions from memory
+      if (session.metadata.channelType === 'webchat') continue;
+      if (now - session.metadata.lastActiveAt > ttlMs) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+
+  getActiveSessions(): Session[] {
+    return Array.from(this.sessions.values());
+  }
+
+  // ── Chat management ──
+
+  createChat(title?: string): Chat {
+    return this.db.createChat(title ?? 'New Chat', 'webchat');
+  }
+
+  listChats(options?: ListChatsOptions): Chat[] {
+    return this.db.listChats(options);
+  }
+
+  renameChat(chatId: string, title: string): void {
+    this.db.renameChat(chatId, title);
+  }
+
+  archiveChat(chatId: string): void {
+    this.db.archiveChat(chatId);
+    this.sessions.delete(chatId);
+  }
+
+  deleteChat(chatId: string): void {
+    this.db.deleteChat(chatId);
+    this.sessions.delete(chatId);
+  }
+
+  getChatMessages(chatId: string): Message[] {
+    return this.db.getMessages(chatId);
+  }
+
+  destroy(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.sessions.clear();
+    this.db.close();
+  }
+}

package/src/types.ts

@@ -0,0 +1,56 @@
+export type MessageRole = 'user' | 'assistant' | 'system';
+
+export interface Message {
+  id: string;
+  role: MessageRole;
+  content: string;
+  timestamp: number;
+  tokens?: {
+    input?: number;
+    output?: number;
+  };
+}
+
+export interface SessionMetadata {
+  channelType: string;
+  senderId?: string;
+  clientId?: string;
+  createdAt: number;
+  lastActiveAt: number;
+  activeMode?: string;
+  modeAutoDetected?: boolean;
+  escalationLevel?: string;
+  suspendedMode?: string;
+}
+
+export interface Session {
+  id: string;
+  messages: Message[];
+  metadata: SessionMetadata;
+  systemPrompt?: string;
+}
+
+export interface SessionConfig {
+  maxContextTokens: number;
+  ttlMinutes: number;
+  autoSave: boolean;
+  compactionEnabled: boolean;
+  dbPath?: string;
+  sessionsDir?: string;
+}
+
+export interface Chat {
+  id: string;
+  title: string;
+  channel: string;
+  createdAt: number;
+  updatedAt: number;
+  archived: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ListChatsOptions {
+  archived?: boolean;
+  limit?: number;
+  offset?: number;
+}

package/tests/db.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { SessionDatabase } from '../src/db.js';
+
+const testDir = path.join(os.tmpdir(), 'auxiora-db-test-' + Date.now());
+const dbPath = path.join(testDir, 'test.db');
+
+describe('SessionDatabase', () => {
+  let db: SessionDatabase;
+
+  beforeEach(() => {
+    fs.mkdirSync(testDir, { recursive: true });
+    db = new SessionDatabase(dbPath);
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('chats', () => {
+    it('should create a chat', () => {
+      const chat = db.createChat('Test Chat', 'webchat');
+      expect(chat.id).toBeDefined();
+      expect(chat.title).toBe('Test Chat');
+      expect(chat.channel).toBe('webchat');
+      expect(chat.archived).toBe(false);
+    });
+
+    it('should list chats ordered by updatedAt descending', () => {
+      const chat1 = db.createChat('First', 'webchat');
+      const chat2 = db.createChat('Second', 'webchat');
+      db.addMessage(chat1.id, 'msg-1', 'user', 'hello', Date.now() + 1000);
+
+      const chats = db.listChats();
+      expect(chats).toHaveLength(2);
+      expect(chats[0].id).toBe(chat1.id);
+    });
+
+    it('should filter out archived chats by default', () => {
+      db.createChat('Active', 'webchat');
+      const archived = db.createChat('Archived', 'webchat');
+      db.archiveChat(archived.id);
+
+      const chats = db.listChats();
+      expect(chats).toHaveLength(1);
+      expect(chats[0].title).toBe('Active');
+    });
+
+    it('should include archived chats when requested', () => {
+      db.createChat('Active', 'webchat');
+      const archived = db.createChat('Archived', 'webchat');
+      db.archiveChat(archived.id);
+
+      const chats = db.listChats({ archived: true });
+      expect(chats).toHaveLength(2);
+    });
+
+    it('should rename a chat', () => {
+      const chat = db.createChat('Old Name', 'webchat');
+      db.renameChat(chat.id, 'New Name');
+      const updated = db.getChat(chat.id);
+      expect(updated?.title).toBe('New Name');
+    });
+
+    it('should delete a chat and its messages', () => {
+      const chat = db.createChat('To Delete', 'webchat');
+      db.addMessage(chat.id, 'msg-1', 'user', 'hello', Date.now());
+      db.deleteChat(chat.id);
+      expect(db.getChat(chat.id)).toBeUndefined();
+      expect(db.getMessages(chat.id)).toEqual([]);
+    });
+
+    it('should support pagination', () => {
+      for (let i = 0; i < 5; i++) {
+        db.createChat(`Chat ${i}`, 'webchat');
+      }
+      const page1 = db.listChats({ limit: 2 });
+      expect(page1).toHaveLength(2);
+      const page2 = db.listChats({ limit: 2, offset: 2 });
+      expect(page2).toHaveLength(2);
+      const page3 = db.listChats({ limit: 2, offset: 4 });
+      expect(page3).toHaveLength(1);
+    });
+  });
+
+  describe('messages', () => {
+    it('should add and retrieve messages', () => {
+      const chat = db.createChat('Test', 'webchat');
+      db.addMessage(chat.id, 'msg-1', 'user', 'Hello', 1000);
+      db.addMessage(chat.id, 'msg-2', 'assistant', 'Hi there', 2000);
+
+      const messages = db.getMessages(chat.id);
+      expect(messages).toHaveLength(2);
+      expect(messages[0].role).toBe('user');
+      expect(messages[0].content).toBe('Hello');
+      expect(messages[1].role).toBe('assistant');
+    });
+
+    it('should store token counts', () => {
+      const chat = db.createChat('Test', 'webchat');
+      db.addMessage(chat.id, 'msg-1', 'assistant', 'response', 1000, 100, 50);
+      const messages = db.getMessages(chat.id);
+      expect(messages[0].tokens).toEqual({ input: 100, output: 50 });
+    });
+
+    it('should update chat updatedAt when adding messages', () => {
+      const chat = db.createChat('Test', 'webchat');
+      const originalUpdatedAt = chat.updatedAt;
+      db.addMessage(chat.id, 'msg-1', 'user', 'Hello', originalUpdatedAt + 5000);
+      const updated = db.getChat(chat.id);
+      expect(updated!.updatedAt).toBeGreaterThan(originalUpdatedAt);
+    });
+
+    it('should get context messages within token budget', () => {
+      const chat = db.createChat('Test', 'webchat');
+      for (let i = 0; i < 20; i++) {
+        db.addMessage(chat.id, `msg-${i}`, 'user', 'x'.repeat(100), i * 1000);
+      }
+      const context = db.getContextMessages(chat.id, 100);
+      expect(context.length).toBeLessThan(20);
+      expect(context.length).toBeGreaterThan(0);
+      expect(context[context.length - 1].id).toBe('msg-19');
+    });
+  });
+
+  describe('session compatibility', () => {
+    it('should get or create a session-style chat by sender+channel', () => {
+      const chat1 = db.getOrCreateSessionChat('user123', 'telegram');
+      expect(chat1.id).toBeDefined();
+      const chat2 = db.getOrCreateSessionChat('user123', 'telegram');
+      expect(chat2.id).toBe(chat1.id);
+      const chat3 = db.getOrCreateSessionChat('user456', 'telegram');
+      expect(chat3.id).not.toBe(chat1.id);
+    });
+  });
+});

package/tests/migration.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { SessionManager } from '../src/manager.js';
+
+const testDir = path.join(os.tmpdir(), 'auxiora-migration-test-' + Date.now());
+
+describe('JSON-to-SQLite migration', () => {
+  let manager: SessionManager;
+
+  beforeEach(() => {
+    fs.mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    manager?.destroy();
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('should migrate JSON session files to SQLite', async () => {
+    // Create a fake JSON session file
+    const sessionId = 'test-session-123';
+    const sessionData = {
+      id: sessionId,
+      messages: [
+        { id: 'msg-1', role: 'user', content: 'Hello', timestamp: 1000 },
+        { id: 'msg-2', role: 'assistant', content: 'Hi there!', timestamp: 2000 },
+      ],
+      metadata: {
+        channelType: 'telegram',
+        senderId: 'user456',
+        createdAt: 1000,
+        lastActiveAt: 2000,
+      },
+    };
+
+    fs.writeFileSync(
+      path.join(testDir, `${sessionId}.json`),
+      JSON.stringify(sessionData),
+    );
+
+    manager = new SessionManager({
+      maxContextTokens: 10000,
+      ttlMinutes: 60,
+      autoSave: true,
+      compactionEnabled: true,
+      dbPath: path.join(testDir, 'sessions.db'),
+      sessionsDir: testDir,
+    });
+
+    await manager.initialize();
+
+    // Verify session is now in SQLite
+    const session = await manager.get(sessionId);
+    expect(session).not.toBeNull();
+    expect(session!.messages).toHaveLength(2);
+    expect(session!.messages[0].content).toBe('Hello');
+    expect(session!.messages[1].content).toBe('Hi there!');
+    expect(session!.metadata.channelType).toBe('telegram');
+
+    // Verify JSON file moved to migrated/
+    expect(fs.existsSync(path.join(testDir, `${sessionId}.json`))).toBe(false);
+    expect(fs.existsSync(path.join(testDir, 'migrated', `${sessionId}.json`))).toBe(true);
+  });
+
+  it('should be a no-op when no JSON files exist', async () => {
+    manager = new SessionManager({
+      maxContextTokens: 10000,
+      ttlMinutes: 60,
+      autoSave: true,
+      compactionEnabled: true,
+      dbPath: path.join(testDir, 'sessions.db'),
+      sessionsDir: testDir,
+    });
+
+    await manager.initialize();
+
+    // Should not throw and no migrated/ dir created
+    expect(fs.existsSync(path.join(testDir, 'migrated'))).toBe(false);
+  });
+
+  it('should skip corrupt JSON files without crashing', async () => {
+    // Write a corrupt file and a valid file
+    fs.writeFileSync(path.join(testDir, 'corrupt.json'), '{invalid json!!!');
+    fs.writeFileSync(
+      path.join(testDir, 'valid-session.json'),
+      JSON.stringify({
+        id: 'valid-session',
+        messages: [{ id: 'msg-1', role: 'user', content: 'Works', timestamp: 1000 }],
+        metadata: { channelType: 'webchat', createdAt: 1000, lastActiveAt: 1000 },
+      }),
+    );
+
+    manager = new SessionManager({
+      maxContextTokens: 10000,
+      ttlMinutes: 60,
+      autoSave: true,
+      compactionEnabled: true,
+      dbPath: path.join(testDir, 'sessions.db'),
+      sessionsDir: testDir,
+    });
+
+    await manager.initialize();
+
+    // Valid session should be migrated
+    const session = await manager.get('valid-session');
+    expect(session).not.toBeNull();
+    expect(session!.messages).toHaveLength(1);
+
+    // Corrupt file should remain (not moved to migrated/)
+    expect(fs.existsSync(path.join(testDir, 'corrupt.json'))).toBe(true);
+  });
+});