@sna-sdk/core 0.3.0 → 0.5.0

package/dist/server/routes/agent.js

@@ -5,6 +5,7 @@ import {
 } from "../../core/providers/index.js";
 import { logger } from "../../lib/logger.js";
 import { getDb } from "../../db/schema.js";
+import { buildHistoryFromDb } from "../history-builder.js";
 import { httpJson } from "../api-types.js";
 import { saveImages } from "../image-store.js";
 function getSessionId(c) {
@@ -194,7 +195,13 @@ function createAgentRoutes(sessionManager) {
       db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, textContent, Object.keys(meta).length > 0 ? JSON.stringify(meta) : null);
     } catch {
     }
-    session.state = "processing";
+    sessionManager.pushEvent(sessionId, {
+      type: "user_message",
+      message: textContent,
+      data: Object.keys(meta).length > 0 ? meta : void 0,
+      timestamp: Date.now()
+    });
+    sessionManager.updateSessionState(sessionId, "processing");
     sessionManager.touch(sessionId);
     if (body.images?.length) {
       const content = [
@@ -216,32 +223,59 @@ function createAgentRoutes(sessionManager) {
     const sessionId = getSessionId(c);
     const session = sessionManager.getOrCreateSession(sessionId);
     const sinceParam = c.req.query("since");
-    let cursor = sinceParam ? parseInt(sinceParam, 10) : session.eventCounter;
+    const sinceCursor = sinceParam ? parseInt(sinceParam, 10) : session.eventCounter;
     return streamSSE(c, async (stream) => {
-      const POLL_MS = 300;
       const KEEPALIVE_MS = 15e3;
-      let lastSend = Date.now();
-      while (true) {
+      const signal = c.req.raw.signal;
+      const queue = [];
+      let wakeUp = null;
+      const unsub = sessionManager.onSessionEvent(sessionId, (eventCursor, event) => {
+        queue.push({ cursor: eventCursor, event });
+        const fn = wakeUp;
+        wakeUp = null;
+        fn?.();
+      });
+      signal.addEventListener("abort", () => {
+        const fn = wakeUp;
+        wakeUp = null;
+        fn?.();
+      });
+      try {
+        let cursor = sinceCursor;
         if (cursor < session.eventCounter) {
           const startIdx = Math.max(
             0,
             session.eventBuffer.length - (session.eventCounter - cursor)
           );
-          const newEvents = session.eventBuffer.slice(startIdx);
-          for (const event of newEvents) {
+          for (const event of session.eventBuffer.slice(startIdx)) {
             cursor++;
-            await stream.writeSSE({
-              id: String(cursor),
-              data: JSON.stringify(event)
-            });
-            lastSend = Date.now();
+            await stream.writeSSE({ id: String(cursor), data: JSON.stringify(event) });
           }
+        } else {
+          cursor = session.eventCounter;
         }
-        if (Date.now() - lastSend > KEEPALIVE_MS) {
-          await stream.writeSSE({ data: "" });
-          lastSend = Date.now();
+        while (queue.length > 0 && queue[0].cursor <= cursor) queue.shift();
+        while (!signal.aborted) {
+          if (queue.length === 0) {
+            await Promise.race([
+              new Promise((r) => {
+                wakeUp = r;
+              }),
+              new Promise((r) => setTimeout(r, KEEPALIVE_MS))
+            ]);
+          }
+          if (signal.aborted) break;
+          if (queue.length > 0) {
+            while (queue.length > 0) {
+              const item = queue.shift();
+              await stream.writeSSE({ id: String(item.cursor), data: JSON.stringify(item.event) });
+            }
+          } else {
+            await stream.writeSSE({ data: "" });
+          }
         }
-        await new Promise((r) => setTimeout(r, POLL_MS));
+      } finally {
+        unsub();
       }
     });
   });
@@ -272,6 +306,46 @@ function createAgentRoutes(sessionManager) {
       return c.json({ status: "error", message: e.message }, 500);
     }
   });
+  app.post("/resume", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    const session = sessionManager.getOrCreateSession(sessionId);
+    if (session.process?.alive) {
+      return c.json({ status: "error", message: "Session already running. Use agent.send instead." }, 400);
+    }
+    const history = buildHistoryFromDb(sessionId);
+    if (history.length === 0 && !body.prompt) {
+      return c.json({ status: "error", message: "No history in DB \u2014 nothing to resume." }, 400);
+    }
+    const providerName = body.provider ?? "claude-code";
+    const model = body.model ?? session.lastStartConfig?.model ?? "claude-sonnet-4-6";
+    const permissionMode = body.permissionMode ?? session.lastStartConfig?.permissionMode ?? "acceptEdits";
+    const extraArgs = body.extraArgs ?? session.lastStartConfig?.extraArgs;
+    const provider = getProvider(providerName);
+    try {
+      const proc = provider.spawn({
+        cwd: session.cwd,
+        prompt: body.prompt,
+        model,
+        permissionMode,
+        env: { SNA_SESSION_ID: sessionId },
+        history: history.length > 0 ? history : void 0,
+        extraArgs
+      });
+      sessionManager.setProcess(sessionId, proc, "resumed");
+      sessionManager.saveStartConfig(sessionId, { provider: providerName, model, permissionMode, extraArgs });
+      logger.log("route", `POST /resume?session=${sessionId} \u2192 resumed (${history.length} history msgs)`);
+      return httpJson(c, "agent.resume", {
+        status: "resumed",
+        provider: providerName,
+        sessionId: session.id,
+        historyCount: history.length
+      });
+    } catch (e) {
+      logger.err("err", `POST /resume?session=${sessionId} \u2192 ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 500);
+    }
+  });
   app.post("/interrupt", async (c) => {
     const sessionId = getSessionId(c);
     const interrupted = sessionManager.interruptSession(sessionId);
@@ -299,11 +373,25 @@ function createAgentRoutes(sessionManager) {
   app.get("/status", (c) => {
     const sessionId = getSessionId(c);
     const session = sessionManager.getSession(sessionId);
+    const alive = session?.process?.alive ?? false;
+    let messageCount = 0;
+    let lastMessage = null;
+    try {
+      const db = getDb();
+      const count = db.prepare("SELECT COUNT(*) as c FROM chat_messages WHERE session_id = ?").get(sessionId);
+      messageCount = count?.c ?? 0;
+      const last = db.prepare("SELECT role, content, created_at FROM chat_messages WHERE session_id = ? ORDER BY id DESC LIMIT 1").get(sessionId);
+      if (last) lastMessage = { role: last.role, content: last.content, created_at: last.created_at };
+    } catch {
+    }
     return httpJson(c, "agent.status", {
-      alive: session?.process?.alive ?? false,
+      alive,
+      agentStatus: !alive ? "disconnected" : session?.state === "processing" ? "busy" : "idle",
       sessionId: session?.process?.sessionId ?? null,
       ccSessionId: session?.ccSessionId ?? null,
       eventCount: session?.eventCounter ?? 0,
+      messageCount,
+      lastMessage,
       config: session?.lastStartConfig ?? null
     });
   });

package/dist/server/session-manager.d.ts

@@ -29,23 +29,31 @@ interface Session {
     createdAt: number;
     lastActivityAt: number;
 }
+type AgentStatus = "idle" | "busy" | "disconnected";
 interface SessionInfo {
     id: string;
     label: string;
     alive: boolean;
     state: SessionState;
+    agentStatus: AgentStatus;
     cwd: string;
     meta: Record<string, unknown> | null;
     config: StartConfig | null;
     ccSessionId: string | null;
     eventCount: number;
+    messageCount: number;
+    lastMessage: {
+        role: string;
+        content: string;
+        created_at: string;
+    } | null;
     createdAt: number;
     lastActivityAt: number;
 }
 interface SessionManagerOptions {
     maxSessions?: number;
 }
-type SessionLifecycleState = "started" | "killed" | "exited" | "crashed" | "restarted";
+type SessionLifecycleState = "started" | "resumed" | "killed" | "exited" | "crashed" | "restarted";
 interface SessionLifecycleEvent {
     session: string;
     state: SessionLifecycleState;
@@ -64,6 +72,7 @@ declare class SessionManager {
     private permissionRequestListeners;
     private lifecycleListeners;
     private configChangedListeners;
+    private stateChangedListeners;
     constructor(options?: SessionManagerOptions);
     /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
     private restoreFromDb;
@@ -84,13 +93,15 @@ declare class SessionManager {
         cwd?: string;
     }): Session;
     /** Set the agent process for a session. Subscribes to events. */
-    setProcess(sessionId: string, proc: AgentProcess): void;
+    setProcess(sessionId: string, proc: AgentProcess, lifecycleState?: SessionLifecycleState): void;
     /** Subscribe to real-time events for a session. Returns unsubscribe function. */
     onSessionEvent(sessionId: string, cb: (cursor: number, event: AgentEvent) => void): () => void;
     /** Subscribe to skill events broadcast. Returns unsubscribe function. */
     onSkillEvent(cb: (event: Record<string, unknown>) => void): () => void;
     /** Broadcast a skill event to all subscribers (called after DB insert). */
     broadcastSkillEvent(event: Record<string, unknown>): void;
+    /** Push a synthetic event into a session's event stream (for user message broadcast). */
+    pushEvent(sessionId: string, event: AgentEvent): void;
     /** Subscribe to permission request notifications. Returns unsubscribe function. */
     onPermissionRequest(cb: (sessionId: string, request: Record<string, unknown>, createdAt: number) => void): () => void;
     /** Subscribe to session lifecycle events (started/killed/exited/crashed). Returns unsubscribe function. */
@@ -99,6 +110,14 @@ declare class SessionManager {
     /** Subscribe to session config changes. Returns unsubscribe function. */
     onConfigChanged(cb: (event: SessionConfigChangedEvent) => void): () => void;
     private emitConfigChanged;
+    onStateChanged(cb: (event: {
+        session: string;
+        agentStatus: AgentStatus;
+        state: SessionState;
+    }) => void): () => void;
+    /** Update session state and push agentStatus change to subscribers. */
+    updateSessionState(sessionId: string, newState: SessionState): void;
+    private setSessionState;
     /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
     createPendingPermission(sessionId: string, request: Record<string, unknown>): Promise<boolean>;
     /** Resolve a pending permission request. Returns false if no pending request. */
@@ -136,10 +155,11 @@ declare class SessionManager {
     /** Touch a session's lastActivityAt timestamp. */
     touch(id: string): void;
     /** Persist an agent event to chat_messages. */
+    private getMessageStats;
     private persistEvent;
     /** Kill all sessions. Used during shutdown. */
     killAll(): void;
     get size(): number;
 }
 
-export { type Session, type SessionConfigChangedEvent, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };
+export { type AgentStatus, type Session, type SessionConfigChangedEvent, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };

package/dist/server/session-manager.js

@@ -11,6 +11,7 @@ class SessionManager {
     this.permissionRequestListeners = /* @__PURE__ */ new Set();
     this.lifecycleListeners = /* @__PURE__ */ new Set();
     this.configChangedListeners = /* @__PURE__ */ new Set();
+    this.stateChangedListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.restoreFromDb();
   }
@@ -123,24 +124,26 @@ class SessionManager {
     return this.createSession({ id, ...opts });
   }
   /** Set the agent process for a session. Subscribes to events. */
-  setProcess(sessionId, proc) {
+  setProcess(sessionId, proc, lifecycleState) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session "${sessionId}" not found`);
     session.process = proc;
-    session.state = "processing";
+    this.setSessionState(sessionId, session, "processing");
     session.lastActivityAt = Date.now();
     proc.on("event", (e) => {
       if (e.type === "init" && e.data?.sessionId && !session.ccSessionId) {
         session.ccSessionId = e.data.sessionId;
         this.persistSession(session);
       }
-      session.eventBuffer.push(e);
-      session.eventCounter++;
-      if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
-        session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+      if (e.type !== "assistant_delta") {
+        session.eventBuffer.push(e);
+        if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
+          session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+        }
       }
+      session.eventCounter++;
       if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
-        session.state = "waiting";
+        this.setSessionState(sessionId, session, "waiting");
       }
       this.persistEvent(sessionId, e);
       const listeners = this.eventListeners.get(sessionId);
@@ -149,14 +152,14 @@ class SessionManager {
       }
     });
     proc.on("exit", (code) => {
-      session.state = "idle";
+      this.setSessionState(sessionId, session, "idle");
       this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
     });
     proc.on("error", () => {
-      session.state = "idle";
+      this.setSessionState(sessionId, session, "idle");
       this.emitLifecycle({ session: sessionId, state: "crashed" });
     });
-    this.emitLifecycle({ session: sessionId, state: "started" });
+    this.emitLifecycle({ session: sessionId, state: lifecycleState ?? "started" });
   }
   // ── Event pub/sub (for WebSocket) ─────────────────────────────
   /** Subscribe to real-time events for a session. Returns unsubscribe function. */
@@ -182,6 +185,20 @@ class SessionManager {
   broadcastSkillEvent(event) {
     for (const cb of this.skillEventListeners) cb(event);
   }
+  /** Push a synthetic event into a session's event stream (for user message broadcast). */
+  pushEvent(sessionId, event) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.eventBuffer.push(event);
+    session.eventCounter++;
+    if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
+      session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+    }
+    const listeners = this.eventListeners.get(sessionId);
+    if (listeners) {
+      for (const cb of listeners) cb(session.eventCounter, event);
+    }
+  }
   // ── Permission pub/sub ────────────────────────────────────────
   /** Subscribe to permission request notifications. Returns unsubscribe function. */
   onPermissionRequest(cb) {
@@ -206,11 +223,29 @@ class SessionManager {
   emitConfigChanged(sessionId, config) {
     for (const cb of this.configChangedListeners) cb({ session: sessionId, config });
   }
+  // ── Agent status change pub/sub ────────────────────────────────
+  onStateChanged(cb) {
+    this.stateChangedListeners.add(cb);
+    return () => this.stateChangedListeners.delete(cb);
+  }
+  /** Update session state and push agentStatus change to subscribers. */
+  updateSessionState(sessionId, newState) {
+    const session = this.sessions.get(sessionId);
+    if (session) this.setSessionState(sessionId, session, newState);
+  }
+  setSessionState(sessionId, session, newState) {
+    const oldState = session.state;
+    session.state = newState;
+    const newStatus = !session.process?.alive ? "disconnected" : newState === "processing" ? "busy" : "idle";
+    if (oldState !== newState) {
+      for (const cb of this.stateChangedListeners) cb({ session: sessionId, agentStatus: newStatus, state: newState });
+    }
+  }
   // ── 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";
+    if (session) this.setSessionState(sessionId, session, "permission");
     return new Promise((resolve) => {
       const createdAt = Date.now();
       this.pendingPermissions.set(sessionId, { resolve, request, createdAt });
@@ -230,7 +265,7 @@ class SessionManager {
     pending.resolve(approved);
     this.pendingPermissions.delete(sessionId);
     const session = this.sessions.get(sessionId);
-    if (session) session.state = "processing";
+    if (session) this.setSessionState(sessionId, session, "processing");
     return true;
   }
   /** Get a pending permission for a specific session. */
@@ -282,7 +317,7 @@ class SessionManager {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
     session.process.interrupt();
-    session.state = "waiting";
+    this.setSessionState(id, session, "waiting");
     return true;
   }
   /** Change model. Sends control message if alive, always persists to config. */
@@ -339,11 +374,13 @@ class SessionManager {
       label: s.label,
       alive: s.process?.alive ?? false,
       state: s.state,
+      agentStatus: !s.process?.alive ? "disconnected" : s.state === "processing" ? "busy" : "idle",
       cwd: s.cwd,
       meta: s.meta,
       config: s.lastStartConfig,
       ccSessionId: s.ccSessionId,
       eventCount: s.eventCounter,
+      ...this.getMessageStats(s.id),
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt
     }));
@@ -354,6 +391,23 @@ class SessionManager {
     if (session) session.lastActivityAt = Date.now();
   }
   /** Persist an agent event to chat_messages. */
+  getMessageStats(sessionId) {
+    try {
+      const db = getDb();
+      const count = db.prepare(
+        `SELECT COUNT(*) as c FROM chat_messages WHERE session_id = ?`
+      ).get(sessionId);
+      const last = db.prepare(
+        `SELECT role, content, created_at FROM chat_messages WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+      ).get(sessionId);
+      return {
+        messageCount: count.c,
+        lastMessage: last ? { role: last.role, content: last.content, created_at: last.created_at } : null
+      };
+    } catch {
+      return { messageCount: 0, lastMessage: null };
+    }
+  }
   persistEvent(sessionId, e) {
     try {
       const db = getDb();