@defai.digital/session-domain 13.0.3

package/src/store.ts

@@ -0,0 +1,240 @@
+/**
+ * Session Store Implementation
+ *
+ * Provides storage for session state.
+ */
+
+import type {
+  Session,
+  CreateSessionInput,
+} from '@defai.digital/contracts';
+import type { SessionStore, SessionFilter } from './types.js';
+
+/**
+ * In-memory session store implementation
+ */
+export class InMemorySessionStore implements SessionStore {
+  private readonly sessions = new Map<string, Session>();
+
+  /**
+   * Create a new session
+   */
+  async create(input: CreateSessionInput): Promise<Session> {
+    const now = new Date().toISOString();
+    const sessionId = crypto.randomUUID();
+
+    const session: Session = {
+      sessionId,
+      initiator: input.initiator,
+      task: input.task,
+      participants: [
+        {
+          agentId: input.initiator,
+          role: 'initiator',
+          joinedAt: now,
+          tasks: [],
+        },
+      ],
+      status: 'active',
+      createdAt: now,
+      updatedAt: now,
+      version: 1,
+      workspace: input.workspace,
+      metadata: input.metadata,
+      appliedPolicies: [],
+    };
+
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+
+  /**
+   * Get a session by ID
+   */
+  async get(sessionId: string): Promise<Session | undefined> {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Update a session
+   */
+  async update(sessionId: string, session: Session): Promise<void> {
+    if (!this.sessions.has(sessionId)) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    // Check version for optimistic concurrency
+    const existing = this.sessions.get(sessionId)!;
+    if (existing.version !== session.version - 1) {
+      throw new SessionVersionConflictError(sessionId, existing.version, session.version);
+    }
+
+    this.sessions.set(sessionId, {
+      ...session,
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * Delete a session
+   */
+  async delete(sessionId: string): Promise<void> {
+    this.sessions.delete(sessionId);
+  }
+
+  /**
+   * List sessions with optional filters
+   */
+  async list(filter?: SessionFilter): Promise<Session[]> {
+    let sessions = Array.from(this.sessions.values());
+
+    if (filter !== undefined) {
+      if (filter.status !== undefined) {
+        sessions = sessions.filter((s) => s.status === filter.status);
+      }
+
+      if (filter.initiator !== undefined) {
+        sessions = sessions.filter((s) => s.initiator === filter.initiator);
+      }
+
+      if (filter.participant !== undefined) {
+        sessions = sessions.filter((s) =>
+          s.participants.some((p) => p.agentId === filter.participant)
+        );
+      }
+
+      if (filter.workspace !== undefined) {
+        sessions = sessions.filter((s) => s.workspace === filter.workspace);
+      }
+
+      if (filter.createdAfter !== undefined) {
+        const after = new Date(filter.createdAfter).getTime();
+        sessions = sessions.filter(
+          (s) => new Date(s.createdAt).getTime() > after
+        );
+      }
+
+      if (filter.createdBefore !== undefined) {
+        const before = new Date(filter.createdBefore).getTime();
+        sessions = sessions.filter(
+          (s) => new Date(s.createdAt).getTime() < before
+        );
+      }
+
+      if (filter.limit !== undefined) {
+        sessions = sessions.slice(0, filter.limit);
+      }
+    }
+
+    // Sort by createdAt descending
+    sessions.sort(
+      (a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+
+    return sessions;
+  }
+
+  /**
+   * Find active session for an agent
+   */
+  async findActiveForAgent(
+    agentId: string,
+    workspace?: string
+  ): Promise<Session | undefined> {
+    for (const session of this.sessions.values()) {
+      if (session.status !== 'active') {
+        continue;
+      }
+
+      if (workspace !== undefined && session.workspace !== workspace) {
+        continue;
+      }
+
+      const isParticipant = session.participants.some(
+        (p) => p.agentId === agentId && p.leftAt === undefined
+      );
+
+      if (isParticipant) {
+        return session;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Apply a governance policy to a session
+   */
+  async applyPolicy(sessionId: string, policyId: string): Promise<Session> {
+    const session = this.sessions.get(sessionId);
+    if (session === undefined) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    // Check if policy already applied
+    const appliedPolicies = session.appliedPolicies ?? [];
+    if (appliedPolicies.includes(policyId)) {
+      return session; // Already applied, return as-is
+    }
+
+    // Apply policy and increment version
+    const updatedSession: Session = {
+      ...session,
+      appliedPolicies: [...appliedPolicies, policyId],
+      updatedAt: new Date().toISOString(),
+      version: session.version + 1,
+    };
+
+    this.sessions.set(sessionId, updatedSession);
+    return updatedSession;
+  }
+
+  /**
+   * Get applied policies for a session
+   */
+  async getAppliedPolicies(sessionId: string): Promise<string[]> {
+    const session = this.sessions.get(sessionId);
+    if (session === undefined) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    return session.appliedPolicies ?? [];
+  }
+
+  /**
+   * Clear all sessions (useful for testing)
+   */
+  clear(): void {
+    this.sessions.clear();
+  }
+
+  /**
+   * Get the count of sessions
+   */
+  get size(): number {
+    return this.sessions.size;
+  }
+}
+
+/**
+ * Session version conflict error
+ */
+export class SessionVersionConflictError extends Error {
+  constructor(
+    public readonly sessionId: string,
+    public readonly expectedVersion: number,
+    public readonly actualVersion: number
+  ) {
+    super(
+      `Version conflict for session ${sessionId}: expected ${expectedVersion}, got ${actualVersion}`
+    );
+    this.name = 'SessionVersionConflictError';
+  }
+}
+
+/**
+ * Creates a new in-memory session store
+ */
+export function createSessionStore(): SessionStore {
+  return new InMemorySessionStore();
+}

package/src/types.ts

@@ -0,0 +1,214 @@
+/**
+ * Session Domain Types
+ */
+
+import {
+  type Session,
+  type SessionTask,
+  type SessionStatus,
+  type SessionEvent,
+  type CreateSessionInput,
+  type JoinSessionInput,
+  type StartTaskInput,
+  type CompleteTaskInput,
+  type FailTaskInput,
+  // Run history types from CLI contracts
+  type RunRecord,
+  type HistoryQuery,
+  // Constants
+  TIMEOUT_SESSION,
+  LIMIT_EVENT_BUFFER,
+} from '@defai.digital/contracts';
+
+/**
+ * Session store interface
+ */
+export interface SessionStore {
+  /**
+   * Create a new session
+   */
+  create(input: CreateSessionInput): Promise<Session>;
+
+  /**
+   * Get a session by ID
+   */
+  get(sessionId: string): Promise<Session | undefined>;
+
+  /**
+   * Update a session
+   */
+  update(sessionId: string, session: Session): Promise<void>;
+
+  /**
+   * Delete a session
+   */
+  delete(sessionId: string): Promise<void>;
+
+  /**
+   * List sessions with optional filters
+   */
+  list(filter?: SessionFilter): Promise<Session[]>;
+
+  /**
+   * Find active session for an agent
+   */
+  findActiveForAgent(agentId: string, workspace?: string): Promise<Session | undefined>;
+
+  /**
+   * Apply a governance policy to a session
+   */
+  applyPolicy(sessionId: string, policyId: string): Promise<Session>;
+
+  /**
+   * Get applied policies for a session
+   */
+  getAppliedPolicies(sessionId: string): Promise<string[]>;
+}
+
+/**
+ * Filter options for listing sessions
+ */
+export interface SessionFilter {
+  status?: SessionStatus;
+  initiator?: string;
+  participant?: string;
+  workspace?: string;
+  createdAfter?: string;
+  createdBefore?: string;
+  limit?: number;
+}
+
+/**
+ * Session manager interface
+ */
+export interface SessionManager {
+  /**
+   * Create a new session
+   */
+  createSession(input: CreateSessionInput): Promise<Session>;
+
+  /**
+   * Get a session by ID
+   */
+  getSession(sessionId: string): Promise<Session | undefined>;
+
+  /**
+   * Join an existing session
+   */
+  joinSession(input: JoinSessionInput): Promise<Session>;
+
+  /**
+   * Leave a session
+   */
+  leaveSession(sessionId: string, agentId: string): Promise<Session>;
+
+  /**
+   * Start a task within a session
+   */
+  startTask(input: StartTaskInput): Promise<SessionTask>;
+
+  /**
+   * Complete a task
+   */
+  completeTask(input: CompleteTaskInput): Promise<SessionTask>;
+
+  /**
+   * Fail a task
+   */
+  failTask(input: FailTaskInput): Promise<SessionTask>;
+
+  /**
+   * Complete a session
+   */
+  completeSession(sessionId: string, summary?: string): Promise<Session>;
+
+  /**
+   * Fail a session
+   */
+  failSession(sessionId: string, error: SessionFailure): Promise<Session>;
+
+  /**
+   * List sessions
+   */
+  listSessions(filter?: SessionFilter): Promise<Session[]>;
+
+  /**
+   * Get run history across all sessions
+   * Aggregates tasks from all participants across sessions
+   */
+  getRunHistory(options?: HistoryQuery): Promise<RunRecord[]>;
+
+  /**
+   * Count active sessions
+   */
+  countActiveSessions(): Promise<number>;
+}
+
+/**
+ * Session failure info
+ * Matches SessionErrorSchema from contracts
+ */
+export interface SessionFailure {
+  code: string;
+  message: string;
+  taskId?: string;
+  retryable?: boolean;
+  details?: Record<string, unknown>;
+}
+
+/**
+ * Session event handler
+ */
+export type SessionEventHandler = (event: SessionEvent) => void | Promise<void>;
+
+/**
+ * Session event emitter interface
+ */
+export interface SessionEventEmitter {
+  /**
+   * Subscribe to session events
+   */
+  on(type: SessionEvent['type'] | '*', handler: SessionEventHandler): void;
+
+  /**
+   * Unsubscribe from session events
+   */
+  off(type: SessionEvent['type'] | '*', handler: SessionEventHandler): void;
+
+  /**
+   * Emit a session event
+   */
+  emit(event: SessionEvent): void;
+}
+
+/**
+ * Session domain configuration
+ */
+export interface SessionDomainConfig {
+  maxParticipants: number;
+  maxTasksPerParticipant: number;
+  sessionTimeout: number;
+  eventBufferSize: number;
+}
+
+/**
+ * Default session domain configuration
+ */
+export const DEFAULT_SESSION_DOMAIN_CONFIG: SessionDomainConfig = {
+  maxParticipants: 10,
+  maxTasksPerParticipant: 50,
+  sessionTimeout: TIMEOUT_SESSION,
+  eventBufferSize: LIMIT_EVENT_BUFFER,
+};
+
+// ============================================================================
+// Run History Types - Re-exported from contracts for convenience
+// The authoritative definitions are in @defai.digital/contracts (cli/v1)
+// ============================================================================
+
+// Re-export contract types to maintain backwards compatibility
+// and provide a convenient import path for session-domain consumers
+export type { RunRecord, RunStatus, HistoryQuery } from '@defai.digital/contracts';
+
+// Backwards compatibility alias
+export type RunHistoryOptions = HistoryQuery;