@sna-sdk/core 0.2.3 → 0.3.0

package/dist/server/ws.js

@@ -4,6 +4,7 @@ import { getDb } from "../db/schema.js";
 import { logger } from "../lib/logger.js";
 import { runOnce } from "./routes/agent.js";
 import { wsReply } from "./api-types.js";
+import { saveImages } from "./image-store.js";
 function send(ws, data) {
   if (ws.readyState === ws.OPEN) {
     ws.send(JSON.stringify(data));
@@ -29,10 +30,13 @@ function attachWebSocket(server, sessionManager) {
   });
   wss.on("connection", (ws) => {
     logger.log("ws", "client connected");
-    const state = { agentUnsubs: /* @__PURE__ */ new Map(), skillEventUnsub: null, skillPollTimer: null, permissionUnsub: null, lifecycleUnsub: null };
+    const state = { agentUnsubs: /* @__PURE__ */ new Map(), skillEventUnsub: null, skillPollTimer: null, permissionUnsub: null, lifecycleUnsub: null, configChangedUnsub: null };
     state.lifecycleUnsub = sessionManager.onSessionLifecycle((event) => {
       send(ws, { type: "session.lifecycle", ...event });
     });
+    state.configChangedUnsub = sessionManager.onConfigChanged((event) => {
+      send(ws, { type: "session.config-changed", ...event });
+    });
     ws.on("message", (raw) => {
       let msg;
       try {
@@ -61,6 +65,8 @@ function attachWebSocket(server, sessionManager) {
       state.permissionUnsub = null;
       state.lifecycleUnsub?.();
       state.lifecycleUnsub = null;
+      state.configChangedUnsub?.();
+      state.configChangedUnsub = null;
     });
   });
   return wss;
@@ -83,6 +89,10 @@ function handleMessage(ws, msg, sm, state) {
       return handleAgentRestart(ws, msg, sm);
     case "agent.interrupt":
       return handleAgentInterrupt(ws, msg, sm);
+    case "agent.set-model":
+      return handleAgentSetModel(ws, msg, sm);
+    case "agent.set-permission-mode":
+      return handleAgentSetPermissionMode(ws, msg, sm);
     case "agent.kill":
       return handleAgentKill(ws, msg, sm);
     case "agent.status":
@@ -184,6 +194,7 @@ function handleAgentStart(ws, msg, sm) {
       model,
       permissionMode,
       env: { SNA_SESSION_ID: sessionId },
+      history: msg.history,
       extraArgs
     });
     sm.setProcess(sessionId, proc);
@@ -199,23 +210,42 @@ function handleAgentSend(ws, msg, sm) {
   if (!session?.process?.alive) {
     return replyError(ws, msg, `No active agent session "${sessionId}". Start first.`);
   }
-  if (!msg.message) {
-    return replyError(ws, msg, "message is required");
+  const images = msg.images;
+  if (!msg.message && !images?.length) {
+    return replyError(ws, msg, "message or images required");
+  }
+  const textContent = msg.message ?? "(image)";
+  let meta = msg.meta ? { ...msg.meta } : {};
+  if (images?.length) {
+    const filenames = saveImages(sessionId, images);
+    meta.images = filenames;
   }
   try {
     const db = getDb();
     db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, session.label ?? sessionId);
-    db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, msg.message, msg.meta ? JSON.stringify(msg.meta) : null);
+    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";
   sm.touch(sessionId);
-  session.process.send(msg.message);
+  if (images?.length) {
+    const content = [
+      ...images.map((img) => ({
+        type: "image",
+        source: { type: "base64", media_type: img.mimeType, data: img.base64 }
+      })),
+      ...msg.message ? [{ type: "text", text: msg.message }] : []
+    ];
+    session.process.send(content);
+  } else {
+    session.process.send(msg.message);
+  }
   wsReply(ws, msg, { status: "sent" });
 }
 function handleAgentRestart(ws, msg, sm) {
   const sessionId = msg.session ?? "default";
   try {
+    const ccSessionId = sm.getSession(sessionId)?.ccSessionId;
     const { config } = sm.restartSession(
       sessionId,
       {
@@ -226,12 +256,13 @@ function handleAgentRestart(ws, msg, sm) {
       },
       (cfg) => {
         const prov = getProvider(cfg.provider);
+        const resumeArgs = ccSessionId ? ["--resume", ccSessionId] : ["--resume"];
         return prov.spawn({
           cwd: sm.getSession(sessionId).cwd,
           model: cfg.model,
           permissionMode: cfg.permissionMode,
           env: { SNA_SESSION_ID: sessionId },
-          extraArgs: [...cfg.extraArgs ?? [], "--resume"]
+          extraArgs: [...cfg.extraArgs ?? [], ...resumeArgs]
         });
       }
     );
@@ -245,6 +276,20 @@ function handleAgentInterrupt(ws, msg, sm) {
   const interrupted = sm.interruptSession(sessionId);
   wsReply(ws, msg, { status: interrupted ? "interrupted" : "no_session" });
 }
+function handleAgentSetModel(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const model = msg.model;
+  if (!model) return replyError(ws, msg, "model is required");
+  const updated = sm.setSessionModel(sessionId, model);
+  wsReply(ws, msg, { status: updated ? "updated" : "no_session", model });
+}
+function handleAgentSetPermissionMode(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const permissionMode = msg.permissionMode;
+  if (!permissionMode) return replyError(ws, msg, "permissionMode is required");
+  const updated = sm.setSessionPermissionMode(sessionId, permissionMode);
+  wsReply(ws, msg, { status: updated ? "updated" : "no_session", permissionMode });
+}
 function handleAgentKill(ws, msg, sm) {
   const sessionId = msg.session ?? "default";
   const killed = sm.killSession(sessionId);
@@ -256,7 +301,9 @@ function handleAgentStatus(ws, msg, sm) {
   wsReply(ws, msg, {
     alive: session?.process?.alive ?? false,
     sessionId: session?.process?.sessionId ?? null,
-    eventCount: session?.eventCounter ?? 0
+    ccSessionId: session?.ccSessionId ?? null,
+    eventCount: session?.eventCounter ?? 0,
+    config: session?.lastStartConfig ?? null
   });
 }
 async function handleAgentRunOnce(ws, msg, sm) {

package/dist/testing/mock-api.d.ts

@@ -0,0 +1,35 @@
+import http from 'http';
+
+/**
+ * Mock Anthropic Messages API server for testing.
+ *
+ * Implements POST /v1/messages with streaming SSE responses.
+ * Set ANTHROPIC_BASE_URL=http://localhost:<port> and
+ * ANTHROPIC_API_KEY=any-string to redirect Claude Code here.
+ *
+ * All requests and responses are logged to stdout (captured by sna tu api:up → .sna/mock-api.log).
+ *
+ * Usage:
+ *   import { startMockAnthropicServer } from "@sna-sdk/core/testing";
+ *   const mock = await startMockAnthropicServer();
+ *   process.env.ANTHROPIC_BASE_URL = `http://localhost:${mock.port}`;
+ *   process.env.ANTHROPIC_API_KEY = "test-key";
+ *   // ... spawn claude code, run tests ...
+ *   mock.close();
+ */
+
+interface MockServer {
+    port: number;
+    server: http.Server;
+    close: () => void;
+    /** Messages received by the mock server */
+    requests: Array<{
+        model: string;
+        messages: any[];
+        stream: boolean;
+        timestamp: string;
+    }>;
+}
+declare function startMockAnthropicServer(): Promise<MockServer>;
+
+export { type MockServer, startMockAnthropicServer };

package/dist/testing/mock-api.js

@@ -0,0 +1,140 @@
+import http from "http";
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+async function startMockAnthropicServer() {
+  const requests = [];
+  const server = http.createServer(async (req, res) => {
+    console.log(`[${ts()}] ${req.method} ${req.url} ${req.headers["content-type"] ?? ""}`);
+    if (req.method === "OPTIONS") {
+      res.writeHead(200, { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "*" });
+      res.end();
+      return;
+    }
+    if (req.method === "POST" && req.url?.startsWith("/v1/messages")) {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const rawBody = Buffer.concat(chunks).toString();
+      let body;
+      try {
+        body = JSON.parse(rawBody);
+      } catch (e) {
+        console.log(`[${ts()}] ERROR: invalid JSON body: ${rawBody.slice(0, 200)}`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "invalid JSON" }));
+        return;
+      }
+      const entry = { model: body.model, messages: body.messages, stream: body.stream, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      requests.push(entry);
+      const lastUser = body.messages?.filter((m) => m.role === "user").pop();
+      let userText = "(no text)";
+      if (typeof lastUser?.content === "string") {
+        userText = lastUser.content;
+      } else if (Array.isArray(lastUser?.content)) {
+        const textBlocks = lastUser.content.filter((b) => b.type === "text").map((b) => b.text);
+        const realText = textBlocks.find((t) => !t.startsWith("<system-reminder>"));
+        userText = realText ?? textBlocks[textBlocks.length - 1] ?? "(no text)";
+      }
+      console.log(`[${ts()}] REQ model=${body.model} stream=${body.stream} messages=${body.messages?.length} user="${userText.slice(0, 120)}"`);
+      for (let mi = 0; mi < body.messages.length; mi++) {
+        const m = body.messages[mi];
+        const role = m.role;
+        let preview = "";
+        if (typeof m.content === "string") {
+          preview = m.content.slice(0, 150);
+        } else if (Array.isArray(m.content)) {
+          preview = m.content.map((b) => {
+            if (b.type === "text") return `text:"${b.text.slice(0, 100)}"`;
+            if (b.type === "image") return `image:${b.source?.media_type}`;
+            return b.type;
+          }).join(" | ");
+        }
+        console.log(`[${ts()}]   [${mi}] ${role}: ${preview}`);
+      }
+      const replyText = [...userText].reverse().join("");
+      const messageId = `msg_mock_${Date.now()}`;
+      if (body.stream) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive"
+        });
+        const send = (event, data) => {
+          res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+        };
+        send("message_start", {
+          type: "message_start",
+          message: {
+            id: messageId,
+            type: "message",
+            role: "assistant",
+            model: body.model,
+            content: [],
+            stop_reason: null,
+            usage: { input_tokens: 100, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }
+          }
+        });
+        send("content_block_start", {
+          type: "content_block_start",
+          index: 0,
+          content_block: { type: "text", text: "" }
+        });
+        const words = replyText.split(" ");
+        for (const word of words) {
+          send("content_block_delta", {
+            type: "content_block_delta",
+            index: 0,
+            delta: { type: "text_delta", text: word + " " }
+          });
+        }
+        send("content_block_stop", { type: "content_block_stop", index: 0 });
+        send("message_delta", {
+          type: "message_delta",
+          delta: { stop_reason: "end_turn", stop_sequence: null },
+          usage: { output_tokens: words.length * 2 }
+        });
+        send("message_stop", { type: "message_stop" });
+        res.end();
+        console.log(`[${ts()}] RES stream complete reply="${replyText.slice(0, 80)}"`);
+      } else {
+        const response = {
+          id: messageId,
+          type: "message",
+          role: "assistant",
+          model: body.model,
+          content: [{ type: "text", text: replyText }],
+          stop_reason: "end_turn",
+          usage: { input_tokens: 100, output_tokens: 20, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(response));
+        console.log(`[${ts()}] RES json reply="${replyText.slice(0, 80)}"`);
+      }
+      return;
+    }
+    console.log(`[${ts()}] 404 ${req.method} ${req.url}`);
+    res.writeHead(404);
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  return new Promise((resolve) => {
+    server.listen(0, () => {
+      const port = server.address().port;
+      console.log(`[${ts()}] Mock Anthropic API server listening on :${port}`);
+      resolve({
+        port,
+        server,
+        close: () => {
+          console.log(`[${ts()}] Mock API server shutting down`);
+          server.close();
+        },
+        requests
+      });
+    });
+  });
+}
+export {
+  startMockAnthropicServer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sna-sdk/core",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Skills-Native Application runtime — server, providers, session management, database, and CLI",
   "type": "module",
   "bin": {
@@ -63,6 +63,11 @@
       "source": "./src/lib/sna-run.ts",
       "types": "./dist/lib/sna-run.d.ts",
       "default": "./dist/lib/sna-run.js"
+    },
+    "./testing": {
+      "source": "./src/testing/mock-api.ts",
+      "types": "./dist/testing/mock-api.d.ts",
+      "default": "./dist/testing/mock-api.js"
     }
   },
   "engines": {