@sna-sdk/core 0.1.1 → 0.2.3

package/dist/server/session-manager.js

@@ -1,16 +1,80 @@
 import { getDb } from "../db/schema.js";
 const DEFAULT_MAX_SESSIONS = 5;
 const MAX_EVENT_BUFFER = 500;
+const PERMISSION_TIMEOUT_MS = 3e5;
 class SessionManager {
   constructor(options = {}) {
     this.sessions = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.pendingPermissions = /* @__PURE__ */ new Map();
+    this.skillEventListeners = /* @__PURE__ */ new Set();
+    this.permissionRequestListeners = /* @__PURE__ */ new Set();
+    this.lifecycleListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+    this.restoreFromDb();
+  }
+  /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
+  restoreFromDb() {
+    try {
+      const db = getDb();
+      const rows = db.prepare(
+        `SELECT id, label, meta, cwd, last_start_config, created_at FROM chat_sessions`
+      ).all();
+      for (const row of rows) {
+        if (this.sessions.has(row.id)) continue;
+        this.sessions.set(row.id, {
+          id: row.id,
+          process: null,
+          eventBuffer: [],
+          eventCounter: 0,
+          label: row.label,
+          cwd: row.cwd ?? process.cwd(),
+          meta: row.meta ? JSON.parse(row.meta) : null,
+          state: "idle",
+          lastStartConfig: row.last_start_config ? JSON.parse(row.last_start_config) : null,
+          createdAt: new Date(row.created_at).getTime() || Date.now(),
+          lastActivityAt: Date.now()
+        });
+      }
+    } catch {
+    }
+  }
+  /** Persist session metadata to DB. */
+  persistSession(session) {
+    try {
+      const db = getDb();
+      db.prepare(
+        `INSERT OR REPLACE INTO chat_sessions (id, label, type, meta, cwd, last_start_config) VALUES (?, ?, 'main', ?, ?, ?)`
+      ).run(
+        session.id,
+        session.label,
+        session.meta ? JSON.stringify(session.meta) : null,
+        session.cwd,
+        session.lastStartConfig ? JSON.stringify(session.lastStartConfig) : null
+      );
+    } catch {
+    }
   }
   /** Create a new session. Throws if max sessions reached. */
   createSession(opts = {}) {
     const id = opts.id ?? crypto.randomUUID().slice(0, 8);
     if (this.sessions.has(id)) {
-      return this.sessions.get(id);
+      const existing = this.sessions.get(id);
+      let changed = false;
+      if (opts.cwd && opts.cwd !== existing.cwd) {
+        existing.cwd = opts.cwd;
+        changed = true;
+      }
+      if (opts.label && opts.label !== existing.label) {
+        existing.label = opts.label;
+        changed = true;
+      }
+      if (opts.meta !== void 0 && opts.meta !== existing.meta) {
+        existing.meta = opts.meta ?? null;
+        changed = true;
+      }
+      if (changed) this.persistSession(existing);
+      return existing;
     }
     const aliveCount = Array.from(this.sessions.values()).filter((s) => s.process?.alive).length;
     if (aliveCount >= this.maxSessions) {
@@ -25,10 +89,12 @@ class SessionManager {
       cwd: opts.cwd ?? process.cwd(),
       meta: opts.meta ?? null,
       state: "idle",
+      lastStartConfig: null,
       createdAt: Date.now(),
       lastActivityAt: Date.now()
     };
     this.sessions.set(id, session);
+    this.persistSession(session);
     return session;
   }
   /** Get a session by ID. */
@@ -38,7 +104,13 @@ class SessionManager {
   /** Get or create a session (used for "default" backward compat). */
   getOrCreateSession(id, opts) {
     const existing = this.sessions.get(id);
-    if (existing) return existing;
+    if (existing) {
+      if (opts?.cwd && opts.cwd !== existing.cwd) {
+        existing.cwd = opts.cwd;
+        this.persistSession(existing);
+      }
+      return existing;
+    }
     return this.createSession({ id, ...opts });
   }
   /** Set the agent process for a session. Subscribes to events. */
@@ -58,13 +130,144 @@ class SessionManager {
         session.state = "waiting";
       }
       this.persistEvent(sessionId, e);
+      const listeners = this.eventListeners.get(sessionId);
+      if (listeners) {
+        for (const cb of listeners) cb(session.eventCounter, e);
+      }
+    });
+    proc.on("exit", (code) => {
+      session.state = "idle";
+      this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
+    });
+    proc.on("error", () => {
+      session.state = "idle";
+      this.emitLifecycle({ session: sessionId, state: "crashed" });
+    });
+    this.emitLifecycle({ session: sessionId, state: "started" });
+  }
+  // ── Event pub/sub (for WebSocket) ─────────────────────────────
+  /** Subscribe to real-time events for a session. Returns unsubscribe function. */
+  onSessionEvent(sessionId, cb) {
+    let set = this.eventListeners.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventListeners.set(sessionId, set);
+    }
+    set.add(cb);
+    return () => {
+      set.delete(cb);
+      if (set.size === 0) this.eventListeners.delete(sessionId);
+    };
+  }
+  // ── Skill event pub/sub ────────────────────────────────────────
+  /** Subscribe to skill events broadcast. Returns unsubscribe function. */
+  onSkillEvent(cb) {
+    this.skillEventListeners.add(cb);
+    return () => this.skillEventListeners.delete(cb);
+  }
+  /** Broadcast a skill event to all subscribers (called after DB insert). */
+  broadcastSkillEvent(event) {
+    for (const cb of this.skillEventListeners) cb(event);
+  }
+  // ── Permission pub/sub ────────────────────────────────────────
+  /** Subscribe to permission request notifications. Returns unsubscribe function. */
+  onPermissionRequest(cb) {
+    this.permissionRequestListeners.add(cb);
+    return () => this.permissionRequestListeners.delete(cb);
+  }
+  // ── Session lifecycle pub/sub ──────────────────────────────────
+  /** Subscribe to session lifecycle events (started/killed/exited/crashed). Returns unsubscribe function. */
+  onSessionLifecycle(cb) {
+    this.lifecycleListeners.add(cb);
+    return () => this.lifecycleListeners.delete(cb);
+  }
+  emitLifecycle(event) {
+    for (const cb of this.lifecycleListeners) cb(event);
+  }
+  // ── Permission management ─────────────────────────────────────
+  /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
+  createPendingPermission(sessionId, request) {
+    const session = this.sessions.get(sessionId);
+    if (session) session.state = "permission";
+    return new Promise((resolve) => {
+      const createdAt = Date.now();
+      this.pendingPermissions.set(sessionId, { resolve, request, createdAt });
+      for (const cb of this.permissionRequestListeners) cb(sessionId, request, createdAt);
+      setTimeout(() => {
+        if (this.pendingPermissions.has(sessionId)) {
+          this.pendingPermissions.delete(sessionId);
+          resolve(false);
+        }
+      }, PERMISSION_TIMEOUT_MS);
     });
   }
+  /** Resolve a pending permission request. Returns false if no pending request. */
+  resolvePendingPermission(sessionId, approved) {
+    const pending = this.pendingPermissions.get(sessionId);
+    if (!pending) return false;
+    pending.resolve(approved);
+    this.pendingPermissions.delete(sessionId);
+    const session = this.sessions.get(sessionId);
+    if (session) session.state = "processing";
+    return true;
+  }
+  /** Get a pending permission for a specific session. */
+  getPendingPermission(sessionId) {
+    const p = this.pendingPermissions.get(sessionId);
+    return p ? { request: p.request, createdAt: p.createdAt } : null;
+  }
+  /** Get all pending permissions across sessions. */
+  getAllPendingPermissions() {
+    return Array.from(this.pendingPermissions.entries()).map(([id, p]) => ({
+      sessionId: id,
+      request: p.request,
+      createdAt: p.createdAt
+    }));
+  }
+  // ── Session lifecycle ─────────────────────────────────────────
+  /** Kill the agent process in a session (session stays, can be restarted). */
+  /** Save the start config for a session (called by start handlers). */
+  saveStartConfig(id, config) {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    session.lastStartConfig = config;
+    this.persistSession(session);
+  }
+  /** Restart session: kill → re-spawn with merged config + --resume. */
+  restartSession(id, overrides, spawnFn) {
+    const session = this.sessions.get(id);
+    if (!session) throw new Error(`Session "${id}" not found`);
+    const base = session.lastStartConfig;
+    if (!base) throw new Error(`Session "${id}" has no previous start config`);
+    const config = {
+      provider: overrides.provider ?? base.provider,
+      model: overrides.model ?? base.model,
+      permissionMode: overrides.permissionMode ?? base.permissionMode,
+      extraArgs: overrides.extraArgs ?? base.extraArgs
+    };
+    if (session.process?.alive) session.process.kill();
+    session.eventBuffer.length = 0;
+    const proc = spawnFn(config);
+    this.setProcess(id, proc);
+    session.lastStartConfig = config;
+    this.persistSession(session);
+    this.emitLifecycle({ session: id, state: "restarted" });
+    return { config };
+  }
+  /** Interrupt the current turn (SIGINT). Process stays alive, returns to waiting. */
+  interruptSession(id) {
+    const session = this.sessions.get(id);
+    if (!session?.process?.alive) return false;
+    session.process.interrupt();
+    session.state = "waiting";
+    return true;
+  }
   /** Kill the agent process in a session (session stays, can be restarted). */
   killSession(id) {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
     session.process.kill();
+    this.emitLifecycle({ session: id, state: "killed" });
     return true;
   }
   /** Remove a session entirely. Cannot remove "default". */
@@ -73,6 +276,8 @@ class SessionManager {
     const session = this.sessions.get(id);
     if (!session) return false;
     if (session.process?.alive) session.process.kill();
+    this.eventListeners.delete(id);
+    this.pendingPermissions.delete(id);
     this.sessions.delete(id);
     return true;
   }