@sna-sdk/core 0.2.3 → 0.3.0

package/dist/server/routes/chat.js

@@ -1,6 +1,8 @@
 import { Hono } from "hono";
+import fs from "fs";
 import { getDb } from "../../db/schema.js";
 import { httpJson } from "../api-types.js";
+import { resolveImagePath } from "../image-store.js";
 function createChatRoutes() {
   const app = new Hono();
   app.get("/sessions", (c) => {
@@ -89,6 +91,26 @@ function createChatRoutes() {
       return c.json({ status: "error", message: e.message }, 500);
     }
   });
+  app.get("/images/:sessionId/:filename", (c) => {
+    const sessionId = c.req.param("sessionId");
+    const filename = c.req.param("filename");
+    const filePath = resolveImagePath(sessionId, filename);
+    if (!filePath) {
+      return c.json({ status: "error", message: "Image not found" }, 404);
+    }
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeMap = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml"
+    };
+    const contentType = mimeMap[ext ?? ""] ?? "application/octet-stream";
+    const data = fs.readFileSync(filePath);
+    return new Response(data, { headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" } });
+  });
   return app;
 }
 export {

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

@@ -24,6 +24,8 @@ interface Session {
     meta: Record<string, unknown> | null;
     state: SessionState;
     lastStartConfig: StartConfig | null;
+    /** Claude Code's own session ID (from system.init event). Used for --resume. */
+    ccSessionId: string | null;
     createdAt: number;
     lastActivityAt: number;
 }
@@ -34,6 +36,8 @@ interface SessionInfo {
     state: SessionState;
     cwd: string;
     meta: Record<string, unknown> | null;
+    config: StartConfig | null;
+    ccSessionId: string | null;
     eventCount: number;
     createdAt: number;
     lastActivityAt: number;
@@ -47,6 +51,10 @@ interface SessionLifecycleEvent {
     state: SessionLifecycleState;
     code?: number | null;
 }
+interface SessionConfigChangedEvent {
+    session: string;
+    config: StartConfig;
+}
 declare class SessionManager {
     private sessions;
     private maxSessions;
@@ -55,6 +63,7 @@ declare class SessionManager {
     private skillEventListeners;
     private permissionRequestListeners;
     private lifecycleListeners;
+    private configChangedListeners;
     constructor(options?: SessionManagerOptions);
     /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
     private restoreFromDb;
@@ -87,6 +96,9 @@ declare class SessionManager {
     /** Subscribe to session lifecycle events (started/killed/exited/crashed). Returns unsubscribe function. */
     onSessionLifecycle(cb: (event: SessionLifecycleEvent) => void): () => void;
     private emitLifecycle;
+    /** Subscribe to session config changes. Returns unsubscribe function. */
+    onConfigChanged(cb: (event: SessionConfigChangedEvent) => void): () => void;
+    private emitConfigChanged;
     /** 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. */
@@ -109,8 +121,12 @@ declare class SessionManager {
     restartSession(id: string, overrides: Partial<StartConfig>, spawnFn: (config: StartConfig) => AgentProcess): {
         config: StartConfig;
     };
-    /** Interrupt the current turn (SIGINT). Process stays alive, returns to waiting. */
+    /** Interrupt the current turn. Process stays alive, returns to waiting. */
     interruptSession(id: string): boolean;
+    /** Change model. Sends control message if alive, always persists to config. */
+    setSessionModel(id: string, model: string): boolean;
+    /** Change permission mode. Sends control message if alive, always persists to config. */
+    setSessionPermissionMode(id: string, mode: string): boolean;
     /** Kill the agent process in a session (session stays, can be restarted). */
     killSession(id: string): boolean;
     /** Remove a session entirely. Cannot remove "default". */
@@ -126,4 +142,4 @@ declare class SessionManager {
     get size(): number;
 }
 
-export { type Session, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };
+export { type Session, type SessionConfigChangedEvent, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };

package/dist/server/session-manager.js

@@ -10,6 +10,7 @@ class SessionManager {
     this.skillEventListeners = /* @__PURE__ */ new Set();
     this.permissionRequestListeners = /* @__PURE__ */ new Set();
     this.lifecycleListeners = /* @__PURE__ */ new Set();
+    this.configChangedListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.restoreFromDb();
   }
@@ -32,6 +33,7 @@ class SessionManager {
           meta: row.meta ? JSON.parse(row.meta) : null,
           state: "idle",
           lastStartConfig: row.last_start_config ? JSON.parse(row.last_start_config) : null,
+          ccSessionId: null,
           createdAt: new Date(row.created_at).getTime() || Date.now(),
           lastActivityAt: Date.now()
         });
@@ -44,7 +46,13 @@ class SessionManager {
     try {
       const db = getDb();
       db.prepare(
-        `INSERT OR REPLACE INTO chat_sessions (id, label, type, meta, cwd, last_start_config) VALUES (?, ?, 'main', ?, ?, ?)`
+        `INSERT INTO chat_sessions (id, label, type, meta, cwd, last_start_config)
+         VALUES (?, ?, 'main', ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           label = excluded.label,
+           meta = excluded.meta,
+           cwd = excluded.cwd,
+           last_start_config = excluded.last_start_config`
       ).run(
         session.id,
         session.label,
@@ -90,6 +98,7 @@ class SessionManager {
       meta: opts.meta ?? null,
       state: "idle",
       lastStartConfig: null,
+      ccSessionId: null,
       createdAt: Date.now(),
       lastActivityAt: Date.now()
     };
@@ -121,12 +130,16 @@ class SessionManager {
     session.state = "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 === "complete" || e.type === "error") {
+      if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
         session.state = "waiting";
       }
       this.persistEvent(sessionId, e);
@@ -184,6 +197,15 @@ class SessionManager {
   emitLifecycle(event) {
     for (const cb of this.lifecycleListeners) cb(event);
   }
+  // ── Config changed pub/sub ────────────────────────────────────
+  /** Subscribe to session config changes. Returns unsubscribe function. */
+  onConfigChanged(cb) {
+    this.configChangedListeners.add(cb);
+    return () => this.configChangedListeners.delete(cb);
+  }
+  emitConfigChanged(sessionId, config) {
+    for (const cb of this.configChangedListeners) cb({ session: sessionId, config });
+  }
   // ── Permission management ─────────────────────────────────────
   /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
   createPendingPermission(sessionId, request) {
@@ -252,9 +274,10 @@ class SessionManager {
     session.lastStartConfig = config;
     this.persistSession(session);
     this.emitLifecycle({ session: id, state: "restarted" });
+    this.emitConfigChanged(id, config);
     return { config };
   }
-  /** Interrupt the current turn (SIGINT). Process stays alive, returns to waiting. */
+  /** Interrupt the current turn. Process stays alive, returns to waiting. */
   interruptSession(id) {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
@@ -262,6 +285,34 @@ class SessionManager {
     session.state = "waiting";
     return true;
   }
+  /** Change model. Sends control message if alive, always persists to config. */
+  setSessionModel(id, model) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setModel(model);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.model = model;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model, permissionMode: "acceptEdits" };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
+  }
+  /** Change permission mode. Sends control message if alive, always persists to config. */
+  setSessionPermissionMode(id, mode) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setPermissionMode(mode);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.permissionMode = mode;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model: "claude-sonnet-4-6", permissionMode: mode };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
+  }
   /** Kill the agent process in a session (session stays, can be restarted). */
   killSession(id) {
     const session = this.sessions.get(id);
@@ -290,6 +341,8 @@ class SessionManager {
       state: s.state,
       cwd: s.cwd,
       meta: s.meta,
+      config: s.lastStartConfig,
+      ccSessionId: s.ccSessionId,
       eventCount: s.eventCounter,
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt