Class SessionManager

coding-agent/src/core/session.ts:68–242

}

export class SessionManager {
  private sessions = new Map<string, Session>();
  private storage = new AsyncLocalStorage<Session>();
  private persistencePath: string | null = null;

  configurePersistence(filePath?: string | null): void {
    this.persistencePath = filePath || null;
    this.sessions.clear();

    if (!this.persistencePath || !existsSync(this.persistencePath)) {
      return;
    }

    try {
      const parsed = JSON.parse(readFileSync(this.persistencePath, 'utf8'));
      const records = Array.isArray(parsed?.sessions) ? parsed.sessions as PersistedSessionRecord[] : [];

      for (const record of records) {
        if (!record?.id || !record?.agentId) continue;
        this.sessions.set(record.id, {
          id: record.id,
          parentId: record.parentId,
          agentId: record.agentId,
          messages: Array.isArray(record.messages) ? record.messages : [],
          context: record.context || {},
          metadata: record.metadata || {},
          abort: new AbortController(),
          createdAt: record.createdAt || Date.now(),
          updatedAt: record.updatedAt || Date.now(),
        });
      }
    } catch (error) {
      console.warn(`Failed to load persisted sessions from ${this.persistencePath}:`, error);
    }
  }

  create(agentId: string, parentId?: string): Session {
    const session: Session = {
      id: randomUUID(),
      parentId,
      agentId,
      messages: [],
      context: {},
      metadata: {},
      abort: new AbortController(),
      createdAt: Date.now(),
      updatedAt: Date.now()
    };

    this.sessions.set(session.id, session);
    this.persist();
    return session;
  }

  get(id: string): Session | undefined {
    return this.sessions.get(id);
  }