@sna-sdk/core 0.2.3 → 0.3.0

package/dist/server/standalone.js

@@ -304,6 +304,7 @@ var logger = { log, err };
 // src/core/providers/claude-code.ts
 var SHELL = process.env.SHELL || "/bin/zsh";
 function resolveClaudePath(cwd) {
+  if (process.env.SNA_CLAUDE_COMMAND) return process.env.SNA_CLAUDE_COMMAND;
   const cached = path3.join(cwd, ".sna/claude-path");
   if (fs3.existsSync(cached)) {
     const p = fs3.readFileSync(cached, "utf8").trim();
@@ -337,6 +338,7 @@ var ClaudeCodeProcess = class {
     this.emitter = new EventEmitter();
     this._alive = true;
     this._sessionId = null;
+    this._initEmitted = false;
     this.buffer = "";
     this.proc = proc;
     proc.stdout.on("data", (chunk) => {
@@ -376,6 +378,29 @@ var ClaudeCodeProcess = class {
       this._alive = false;
       this.emitter.emit("error", err2);
     });
+    if (options.history?.length) {
+      if (!options.prompt) {
+        throw new Error("history requires a prompt \u2014 the last stdin message must be a user message");
+      }
+      for (const msg of options.history) {
+        if (msg.role === "user") {
+          const line = JSON.stringify({
+            type: "user",
+            message: { role: "user", content: msg.content }
+          });
+          this.proc.stdin.write(line + "\n");
+        } else if (msg.role === "assistant") {
+          const line = JSON.stringify({
+            type: "assistant",
+            message: {
+              role: "assistant",
+              content: [{ type: "text", text: msg.content }]
+            }
+          });
+          this.proc.stdin.write(line + "\n");
+        }
+      }
+    }
     if (options.prompt) {
       this.send(options.prompt);
     }
@@ -388,20 +413,41 @@ var ClaudeCodeProcess = class {
   }
   /**
    * Send a user message to the persistent Claude process via stdin.
+   * Accepts plain string or content block array (text + images).
    */
   send(input) {
     if (!this._alive || !this.proc.stdin.writable) return;
+    const content = typeof input === "string" ? input : input;
     const msg = JSON.stringify({
       type: "user",
-      message: { role: "user", content: input }
+      message: { role: "user", content }
     });
     logger.log("stdin", msg.slice(0, 200));
     this.proc.stdin.write(msg + "\n");
   }
   interrupt() {
-    if (this._alive) {
-      this.proc.kill("SIGINT");
-    }
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "interrupt" }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setModel(model) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_model", model }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setPermissionMode(mode) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_permission_mode", permission_mode: mode }
+    });
+    this.proc.stdin.write(msg + "\n");
   }
   kill() {
     if (this._alive) {
@@ -419,6 +465,8 @@ var ClaudeCodeProcess = class {
     switch (msg.type) {
       case "system": {
         if (msg.subtype === "init") {
+          if (this._initEmitted) return null;
+          this._initEmitted = true;
           return {
             type: "init",
             message: `Agent ready (${msg.model ?? "unknown"})`,
@@ -500,6 +548,14 @@ var ClaudeCodeProcess = class {
             timestamp: Date.now()
           };
         }
+        if (msg.subtype === "error_during_execution" && msg.is_error === false) {
+          return {
+            type: "interrupted",
+            message: "Turn interrupted by user",
+            data: { durationMs: msg.duration_ms, costUsd: msg.total_cost_usd },
+            timestamp: Date.now()
+          };
+        }
         if (msg.subtype?.startsWith("error") || msg.is_error) {
           return {
             type: "error",
@@ -531,7 +587,10 @@ var ClaudeCodeProvider = class {
     }
   }
   spawn(options) {
-    const claudePath = resolveClaudePath(options.cwd);
+    const claudeCommand = resolveClaudePath(options.cwd);
+    const claudeParts = claudeCommand.split(/\s+/);
+    const claudePath = claudeParts[0];
+    const claudePrefix = claudeParts.slice(1);
     const hookScript = new URL("../../scripts/hook.js", import.meta.url).pathname;
     const sessionId = options.env?.SNA_SESSION_ID ?? "default";
     const sdkSettings = {};
@@ -588,12 +647,13 @@ var ClaudeCodeProvider = class {
     delete cleanEnv.CLAUDECODE;
     delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
     delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
-    const proc = spawn2(claudePath, args, {
+    delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const proc = spawn2(claudePath, [...claudePrefix, ...args], {
       cwd: options.cwd,
       env: cleanEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    logger.log("agent", `spawned claude-code (pid=${proc.pid}) \u2192 ${claudePath} ${args.join(" ")}`);
+    logger.log("agent", `spawned claude-code (pid=${proc.pid}) \u2192 ${claudeCommand} ${args.join(" ")}`);
     return new ClaudeCodeProcess(proc, options);
   }
 };
@@ -622,6 +682,38 @@ function getProvider(name = "claude-code") {
   return provider2;
 }
 
+// src/server/image-store.ts
+import fs4 from "fs";
+import path4 from "path";
+import { createHash } from "crypto";
+var IMAGE_DIR = path4.join(process.cwd(), "data/images");
+var MIME_TO_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/svg+xml": "svg"
+};
+function saveImages(sessionId, images) {
+  const dir = path4.join(IMAGE_DIR, sessionId);
+  fs4.mkdirSync(dir, { recursive: true });
+  return images.map((img) => {
+    const ext = MIME_TO_EXT[img.mimeType] ?? "bin";
+    const hash = createHash("sha256").update(img.base64).digest("hex").slice(0, 12);
+    const filename = `${hash}.${ext}`;
+    const filePath = path4.join(dir, filename);
+    if (!fs4.existsSync(filePath)) {
+      fs4.writeFileSync(filePath, Buffer.from(img.base64, "base64"));
+    }
+    return filename;
+  });
+}
+function resolveImagePath(sessionId, filename) {
+  if (filename.includes("..") || filename.includes("/")) return null;
+  const filePath = path4.join(IMAGE_DIR, sessionId, filename);
+  return fs4.existsSync(filePath) ? filePath : null;
+}
+
 // src/server/routes/agent.ts
 function getSessionId(c) {
   return c.req.query("session") ?? "default";
@@ -645,7 +737,7 @@ async function runOnce(sessionManager2, opts) {
     model: opts.model ?? "claude-sonnet-4-6",
     permissionMode: opts.permissionMode ?? "bypassPermissions",
     env: { SNA_SESSION_ID: sessionId },
-    extraArgs: extraArgs.length > 0 ? extraArgs : void 0
+    extraArgs
   });
   sessionManager2.setProcess(sessionId, proc);
   try {
@@ -767,6 +859,7 @@ function createAgentRoutes(sessionManager2) {
         model,
         permissionMode: permissionMode2,
         env: { SNA_SESSION_ID: sessionId },
+        history: body.history,
         extraArgs
       });
       sessionManager2.setProcess(sessionId, proc);
@@ -793,20 +886,38 @@ function createAgentRoutes(sessionManager2) {
       );
     }
     const body = await c.req.json().catch(() => ({}));
-    if (!body.message) {
+    if (!body.message && !body.images?.length) {
       logger.err("err", `POST /send?session=${sessionId} \u2192 empty message`);
-      return c.json({ status: "error", message: "message is required" }, 400);
+      return c.json({ status: "error", message: "message or images required" }, 400);
+    }
+    const textContent = body.message ?? "(image)";
+    let meta = body.meta ? { ...body.meta } : {};
+    if (body.images?.length) {
+      const filenames = saveImages(sessionId, body.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, body.message, body.meta ? JSON.stringify(body.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";
     sessionManager2.touch(sessionId);
-    logger.log("route", `POST /send?session=${sessionId} \u2192 "${body.message.slice(0, 80)}"`);
-    session.process.send(body.message);
+    if (body.images?.length) {
+      const content = [
+        ...body.images.map((img) => ({
+          type: "image",
+          source: { type: "base64", media_type: img.mimeType, data: img.base64 }
+        })),
+        ...body.message ? [{ type: "text", text: body.message }] : []
+      ];
+      logger.log("route", `POST /send?session=${sessionId} \u2192 ${body.images.length} image(s) + "${(body.message ?? "").slice(0, 40)}"`);
+      session.process.send(content);
+    } else {
+      logger.log("route", `POST /send?session=${sessionId} \u2192 "${body.message.slice(0, 80)}"`);
+      session.process.send(body.message);
+    }
     return httpJson(c, "agent.send", { status: "sent" });
   });
   app.get("/events", (c) => {
@@ -846,14 +957,16 @@ function createAgentRoutes(sessionManager2) {
     const sessionId = getSessionId(c);
     const body = await c.req.json().catch(() => ({}));
     try {
+      const ccSessionId = sessionManager2.getSession(sessionId)?.ccSessionId;
       const { config } = sessionManager2.restartSession(sessionId, body, (cfg) => {
         const prov = getProvider(cfg.provider);
+        const resumeArgs = ccSessionId ? ["--resume", ccSessionId] : ["--resume"];
         return prov.spawn({
           cwd: sessionManager2.getSession(sessionId).cwd,
           model: cfg.model,
           permissionMode: cfg.permissionMode,
           env: { SNA_SESSION_ID: sessionId },
-          extraArgs: [...cfg.extraArgs ?? [], "--resume"]
+          extraArgs: [...cfg.extraArgs ?? [], ...resumeArgs]
         });
       });
       logger.log("route", `POST /restart?session=${sessionId} \u2192 restarted`);
@@ -872,6 +985,20 @@ function createAgentRoutes(sessionManager2) {
     const interrupted = sessionManager2.interruptSession(sessionId);
     return httpJson(c, "agent.interrupt", { status: interrupted ? "interrupted" : "no_session" });
   });
+  app.post("/set-model", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.model) return c.json({ status: "error", message: "model is required" }, 400);
+    const updated = sessionManager2.setSessionModel(sessionId, body.model);
+    return httpJson(c, "agent.set-model", { status: updated ? "updated" : "no_session", model: body.model });
+  });
+  app.post("/set-permission-mode", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.permissionMode) return c.json({ status: "error", message: "permissionMode is required" }, 400);
+    const updated = sessionManager2.setSessionPermissionMode(sessionId, body.permissionMode);
+    return httpJson(c, "agent.set-permission-mode", { status: updated ? "updated" : "no_session", permissionMode: body.permissionMode });
+  });
   app.post("/kill", async (c) => {
     const sessionId = getSessionId(c);
     const killed = sessionManager2.killSession(sessionId);
@@ -883,7 +1010,9 @@ function createAgentRoutes(sessionManager2) {
     return httpJson(c, "agent.status", {
       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
     });
   });
   app.post("/permission-request", async (c) => {
@@ -917,6 +1046,7 @@ function createAgentRoutes(sessionManager2) {
 
 // src/server/routes/chat.ts
 import { Hono as Hono2 } from "hono";
+import fs5 from "fs";
 function createChatRoutes() {
   const app = new Hono2();
   app.get("/sessions", (c) => {
@@ -1005,6 +1135,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 = fs5.readFileSync(filePath);
+    return new Response(data, { headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" } });
+  });
   return app;
 }
 
@@ -1020,6 +1170,7 @@ var SessionManager = class {
     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();
   }
@@ -1042,6 +1193,7 @@ var SessionManager = class {
           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()
         });
@@ -1054,7 +1206,13 @@ var SessionManager = class {
     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,
@@ -1100,6 +1258,7 @@ var SessionManager = class {
       meta: opts.meta ?? null,
       state: "idle",
       lastStartConfig: null,
+      ccSessionId: null,
       createdAt: Date.now(),
       lastActivityAt: Date.now()
     };
@@ -1131,12 +1290,16 @@ var SessionManager = class {
     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);
@@ -1194,6 +1357,15 @@ var SessionManager = class {
   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) {
@@ -1262,9 +1434,10 @@ var SessionManager = class {
     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;
@@ -1272,6 +1445,34 @@ var SessionManager = class {
     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);
@@ -1300,6 +1501,8 @@ var SessionManager = class {
       state: s.state,
       cwd: s.cwd,
       meta: s.meta,
+      config: s.lastStartConfig,
+      ccSessionId: s.ccSessionId,
       eventCount: s.eventCounter,
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt
@@ -1383,10 +1586,13 @@ function attachWebSocket(server2, sessionManager2) {
   });
   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 = sessionManager2.onSessionLifecycle((event) => {
       send(ws, { type: "session.lifecycle", ...event });
     });
+    state.configChangedUnsub = sessionManager2.onConfigChanged((event) => {
+      send(ws, { type: "session.config-changed", ...event });
+    });
     ws.on("message", (raw) => {
       let msg;
       try {
@@ -1415,6 +1621,8 @@ function attachWebSocket(server2, sessionManager2) {
       state.permissionUnsub = null;
       state.lifecycleUnsub?.();
       state.lifecycleUnsub = null;
+      state.configChangedUnsub?.();
+      state.configChangedUnsub = null;
     });
   });
   return wss;
@@ -1437,6 +1645,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":
@@ -1538,6 +1750,7 @@ function handleAgentStart(ws, msg, sm) {
       model,
       permissionMode: permissionMode2,
       env: { SNA_SESSION_ID: sessionId },
+      history: msg.history,
       extraArgs
     });
     sm.setProcess(sessionId, proc);
@@ -1553,23 +1766,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,
       {
@@ -1580,12 +1812,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]
         });
       }
     );
@@ -1599,6 +1832,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 permissionMode2 = msg.permissionMode;
+  if (!permissionMode2) return replyError(ws, msg, "permissionMode is required");
+  const updated = sm.setSessionPermissionMode(sessionId, permissionMode2);
+  wsReply(ws, msg, { status: updated ? "updated" : "no_session", permissionMode: permissionMode2 });
+}
 function handleAgentKill(ws, msg, sm) {
   const sessionId = msg.session ?? "default";
   const killed = sm.killSession(sessionId);
@@ -1610,7 +1857,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) {
@@ -1886,8 +2135,8 @@ var methodColor = {
 root.use("*", async (c, next) => {
   const m = c.req.method;
   const colorFn = methodColor[m] ?? chalk2.white;
-  const path4 = new URL(c.req.url).pathname;
-  logger.log("req", `${colorFn(m.padEnd(6))} ${path4}`);
+  const path5 = new URL(c.req.url).pathname;
+  logger.log("req", `${colorFn(m.padEnd(6))} ${path5}`);
   await next();
 });
 var sessionManager = new SessionManager({ maxSessions });