@joeyshi12/casper 0.8.6 → 0.8.8

package/dist/server.js

@@ -319,12 +319,10 @@ var init_config = __esm({
        */
       defaultAgent: setting("DEFAULT_AGENT", "defaultAgent", "casper"),
       /**
-       * Filesystem root that file-serving endpoints (/api/fs/dirs, /api/fs/image)
-       * are confined to. Requests resolving outside this root are rejected.
-       * Defaults to the filesystem root (/), so file browsing spans everything the
-       * server process can read. Set CASPER_FILE_ROOT to a narrower path (e.g. the
-       * user's home directory) to stop authenticated users from reading system
-       * files such as /etc or SSH keys.
+       * Filesystem root the file endpoints (/api/fs/dirs, /api/fs/image) are confined to; anything
+       * resolving outside it is rejected. Defaults to /, so browsing spans everything the process
+       * can read - set a narrower path to keep authenticated users out of system files such as /etc
+       * or SSH keys.
        */
       fileRoot: path5.resolve(setting("CASPER_FILE_ROOT", "fileRoot", "/")),
       /** Directory where kiro-cli persists its own session files. */
@@ -723,24 +721,66 @@ var init_dist = __esm({
   }
 });
 
-// server/src/util/paths.ts
+// server/src/session/workspaces.ts
+import crypto3 from "node:crypto";
 import fs7 from "node:fs";
-import fsp from "node:fs/promises";
 import path8 from "node:path";
+function workspacesRoot() {
+  return path8.join(config.casperDataDir, "workspaces");
+}
+function workspaceDir(workspaceId) {
+  return path8.join(workspacesRoot(), workspaceId);
+}
+function createWorkspace() {
+  const id = crypto3.randomUUID();
+  const dir = workspaceDir(id);
+  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  return { id, dir };
+}
+var init_workspaces = __esm({
+  "server/src/session/workspaces.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// server/src/session/titles.ts
+function titleFromPrompt(content) {
+  const text2 = content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+  const words = stripAttachmentsLine(text2).replace(/```[\s\S]*?```/g, " ").replace(/\s+/g, " ").trim();
+  if (!words) return "";
+  if (words.length <= MAX_TITLE) return words.replace(/[.,;:!?]+$/, "");
+  const cut = words.slice(0, MAX_TITLE);
+  const lastSpace = cut.lastIndexOf(" ");
+  return `${(lastSpace > MAX_TITLE / 2 ? cut.slice(0, lastSpace) : cut).replace(/[.,;:!?]+$/, "")}\u2026`;
+}
+var MAX_TITLE;
+var init_titles = __esm({
+  "server/src/session/titles.ts"() {
+    "use strict";
+    init_dist();
+    MAX_TITLE = 60;
+  }
+});
+
+// server/src/util/paths.ts
+import fs8 from "node:fs";
+import fsp from "node:fs/promises";
+import path9 from "node:path";
 function isWithinRoot(root, target) {
-  const resolved = path8.resolve(target);
-  if (root === path8.sep) return true;
-  return resolved === root || resolved.startsWith(root + path8.sep);
+  const resolved = path9.resolve(target);
+  if (root === path9.sep) return true;
+  return resolved === root || resolved.startsWith(root + path9.sep);
 }
 function confineToRoot(root, input) {
-  const resolved = path8.resolve(root, input);
+  const resolved = path9.resolve(root, input);
   return isWithinRoot(root, resolved) ? resolved : null;
 }
 function resolveRealRoot(root) {
   if (realRootCache && realRootCache.root === root) return realRootCache.real;
   let real;
   try {
-    real = fs7.realpathSync(root);
+    real = fs8.realpathSync(root);
   } catch {
     real = root;
   }
@@ -1221,8 +1261,8 @@ var init_TurnState = __esm({
 });
 
 // server/src/session/kiroFiles.ts
-import fs8 from "node:fs/promises";
-import path9 from "node:path";
+import fs9 from "node:fs/promises";
+import path10 from "node:path";
 function isContentBlock(v) {
   return isRecord(v) && typeof v.kind === "string";
 }
@@ -1274,7 +1314,7 @@ function summarize(j) {
 async function listPersistedSessions(log) {
   let files;
   try {
-    files = await fs8.readdir(config.kiroSessionsDir);
+    files = await fs9.readdir(config.kiroSessionsDir);
   } catch {
     return [];
   }
@@ -1283,7 +1323,7 @@ async function listPersistedSessions(log) {
   await Promise.all(
     jsonFiles.map(async (f) => {
       try {
-        const raw = await fs8.readFile(path9.join(config.kiroSessionsDir, f), "utf8");
+        const raw = await fs9.readFile(path10.join(config.kiroSessionsDir, f), "utf8");
         summaries.push(summarize(JSON.parse(raw)));
       } catch (err) {
         log.debug({ err, f }, "kiroFiles: skipping unreadable session file");
@@ -1296,18 +1336,18 @@ async function listPersistedSessions(log) {
 async function deletePersistedSession(sessionId) {
   if (!isValidSessionId(sessionId)) return;
   const targets = [
-    path9.join(config.kiroSessionsDir, `${sessionId}.json`),
-    path9.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
-    path9.join(config.kiroSessionsDir, `${sessionId}.history`),
-    path9.join(config.kiroSessionsDir, sessionId)
+    path10.join(config.kiroSessionsDir, `${sessionId}.json`),
+    path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
+    path10.join(config.kiroSessionsDir, `${sessionId}.history`),
+    path10.join(config.kiroSessionsDir, sessionId)
   ];
-  await Promise.all(targets.map((f) => fs8.rm(f, { recursive: true, force: true })));
+  await Promise.all(targets.map((f) => fs9.rm(f, { recursive: true, force: true })));
 }
 async function readPersistedSession(sessionId) {
   if (!isValidSessionId(sessionId)) return null;
   try {
-    const raw = await fs8.readFile(
-      path9.join(config.kiroSessionsDir, `${sessionId}.json`),
+    const raw = await fs9.readFile(
+      path10.join(config.kiroSessionsDir, `${sessionId}.json`),
       "utf8"
     );
     return summarize(JSON.parse(raw));
@@ -1319,8 +1359,8 @@ async function hydrateTranscript(sessionId) {
   if (!isValidSessionId(sessionId)) return [];
   let raw;
   try {
-    raw = await fs8.readFile(
-      path9.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
+    raw = await fs9.readFile(
+      path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
       "utf8"
     );
   } catch {
@@ -1435,17 +1475,17 @@ var init_sessionStore = __esm({
 });
 
 // server/src/session/SessionManager.ts
-import fs9 from "node:fs";
-import path10 from "node:path";
+import fs10 from "node:fs";
+import path11 from "node:path";
 function resolveCwd(input) {
   const raw = input?.trim();
-  const abs = raw ? path10.resolve(config.defaultCwd, raw) : config.defaultCwd;
+  const abs = raw ? path11.resolve(config.defaultCwd, raw) : config.defaultCwd;
   if (!isWithinRoot(config.fileRoot, abs)) {
     throw new Error(`Working directory is outside the allowed root: ${abs}`);
   }
   let stat;
   try {
-    stat = fs9.statSync(abs);
+    stat = fs10.statSync(abs);
   } catch {
     stat = void 0;
   }
@@ -1453,7 +1493,7 @@ function resolveCwd(input) {
     throw new Error(`Working directory path is a file, not a directory: ${abs}`);
   }
   if (!stat) {
-    fs9.mkdirSync(abs, { recursive: true });
+    fs10.mkdirSync(abs, { recursive: true });
   }
   return abs;
 }
@@ -1485,6 +1525,8 @@ var init_SessionManager = __esm({
     "use strict";
     init_dist();
     init_config();
+    init_workspaces();
+    init_titles();
     init_paths2();
     init_KiroProcess();
     init_EventStore();
@@ -1551,17 +1593,10 @@ var init_SessionManager = __esm({
         if (s) s.title = title.trim() || s.title;
       }
       /**
-       * Re-point a session at a different working directory. A session's cwd is
-       * fixed at creation, so this is needed when the original folder was moved or
-       * deleted (the workspace endpoints and the kiro process are scoped to it).
-       *
-       * The target is validated and created exactly like a new session's cwd, so a
-       * folder is only created on this explicit action - never silently on resume.
-       * Any live kiro process was spawned with the old cwd, so it's disposed here;
-       * the next turn respawns in the new directory with the transcript intact
-       * (kiro reloads the session from its own file).
-       *
-       * Returns the resolved absolute path.
+       * Re-point a session at a different working directory, for when the original was moved
+       * or deleted. Validates and creates the target exactly like a new session's cwd, so a
+       * folder is only created on this explicit action. Any live process was spawned with the
+       * old cwd, so it is disposed and the next turn respawns in the new one, transcript intact.
        */
       async setSessionCwd(sessionId, input) {
         const resolved = resolveCwd(input);
@@ -1709,7 +1744,7 @@ var init_SessionManager = __esm({
       // -------------------------------------------------------------------------
       /** Create a new session. Spawns immediately so we get a real kiro sessionId. */
       async createSession(opts) {
-        const cwd = resolveCwd(opts.cwd);
+        const cwd = opts.freshWorkspace ? createWorkspace().dir : resolveCwd(opts.cwd);
         const tempId = `pending-${Date.now()}-${Math.floor(this.sessions.size)}`;
         const store = new EventStore(tempId);
         const s = new Session(tempId, store, cwd);
@@ -1723,7 +1758,7 @@ var init_SessionManager = __esm({
           this.evict(s.sessionId);
           throw err;
         }
-        const folder = path10.basename(s.cwd);
+        const folder = opts.freshWorkspace ? "" : path11.basename(s.cwd);
         if (folder) {
           this.store.setTitle(s.sessionId, folder);
           s.title = folder;
@@ -1740,6 +1775,13 @@ var init_SessionManager = __esm({
         s.running = true;
         s.lastActivity = Date.now();
         s.record({ kind: "turn_started", prompt: content });
+        if (!this.store.getTitle(s.sessionId)) {
+          const title = titleFromPrompt(content);
+          if (title) {
+            this.store.setTitle(s.sessionId, title);
+            s.title = title;
+          }
+        }
         proc.prompt({ sessionId: s.sessionId, prompt: content }).then((res) => s.record({ kind: "turn_ended", stopReason: res.stopReason })).catch((err) => {
           this.log.error({ err, sessionId: s.sessionId }, "prompt turn failed");
           const tail = proc.stderrTail();
@@ -1873,12 +1915,10 @@ ${tail}` : err.message;
         };
       }
       /**
-       * The cursor a reconnecting client should start from. Normally the store
-       * head, but while a turn is in flight the prompt/response are not yet in
-       * kiro's persisted jsonl (kiro writes a turn only when it completes), so the
-       * hydrated transcript is missing them. Rewind to just before the in-flight
-       * turn_started so the WS replays the whole in-flight turn. Guarded against
-       * duplication in case kiro ever persists the prompt at turn start.
+       * The cursor a reconnecting client should start from. Normally the store head, but kiro writes
+       * a turn to its jsonl only once the turn completes, so a hydrated transcript is missing one in
+       * flight. Rewind to just before its turn_started and let the WS replay the whole turn. Guarded
+       * against duplication in case kiro ever persists the prompt at turn start.
        */
       replayHead(s, transcript) {
         const head = s.store.head();
@@ -1983,13 +2023,13 @@ var init_rateLimit = __esm({
 });
 
 // server/src/routes/auth.ts
-import crypto3 from "node:crypto";
+import crypto4 from "node:crypto";
 import fastifyCookie from "@fastify/cookie";
 function secretMatches(supplied, expected) {
   if (typeof supplied !== "string") return false;
-  const a = crypto3.createHash("sha256").update(supplied).digest();
-  const b = crypto3.createHash("sha256").update(expected).digest();
-  return crypto3.timingSafeEqual(a, b);
+  const a = crypto4.createHash("sha256").update(supplied).digest();
+  const b = crypto4.createHash("sha256").update(expected).digest();
+  return crypto4.timingSafeEqual(a, b);
 }
 function extractToken(req) {
   const auth = req.headers["authorization"];
@@ -2193,9 +2233,9 @@ var init_agents2 = __esm({
 });
 
 // server/src/routes/fs.ts
-import fs10 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 import { createReadStream } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 function confinedPath(input) {
   return confineToRoot(config.fileRoot, input) ?? confineToRoot(config.casperDataDir, input);
 }
@@ -2206,10 +2246,10 @@ function registerFsRoutes(app) {
       const input = (req.query.path ?? "").trim();
       const base = config.defaultCwd;
       const endsWithSep = input.endsWith("/");
-      const resolved = input ? path11.resolve(base, input) : base;
-      const dir = endsWithSep || !input ? resolved : path11.dirname(resolved);
-      const prefix = endsWithSep || !input ? "" : path11.basename(resolved);
-      const targetKind = await fs10.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
+      const resolved = input ? path12.resolve(base, input) : base;
+      const dir = endsWithSep || !input ? resolved : path12.dirname(resolved);
+      const prefix = endsWithSep || !input ? "" : path12.basename(resolved);
+      const targetKind = await fs11.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
       if (confinedPath(dir) === null) {
         reply.code(403);
         return { error: "Path outside allowed root" };
@@ -2220,23 +2260,23 @@ function registerFsRoutes(app) {
       }
       let entries = [];
       try {
-        const dirents = await fs10.readdir(realDir, { withFileTypes: true });
+        const dirents = await fs11.readdir(realDir, { withFileTypes: true });
         const candidates = dirents.filter((d) => !d.name.startsWith("."));
         const checks2 = await Promise.all(
           candidates.map(async (d) => {
             if (d.isDirectory()) return d.name;
             if (!d.isSymbolicLink()) return null;
-            const full = path11.join(realDir, d.name);
+            const full = path12.join(realDir, d.name);
             const real = await realConfineToRoot(config.fileRoot, full);
             if (!real) return null;
             try {
-              return (await fs10.stat(real)).isDirectory() ? d.name : null;
+              return (await fs11.stat(real)).isDirectory() ? d.name : null;
             } catch {
               return null;
             }
           })
         );
-        entries = checks2.filter((name) => name !== null).filter((name) => name.toLowerCase().startsWith(prefix.toLowerCase())).sort((a, b) => a.localeCompare(b)).slice(0, 20).map((name) => path11.join(dir, name));
+        entries = checks2.filter((name) => name !== null).filter((name) => name.toLowerCase().startsWith(prefix.toLowerCase())).sort((a, b) => a.localeCompare(b)).slice(0, 20).map((name) => path12.join(dir, name));
       } catch {
         entries = [];
       }
@@ -2251,7 +2291,7 @@ function registerFsRoutes(app) {
         reply.code(400);
         return { error: "path parameter is required" };
       }
-      if (!path11.isAbsolute(filePath)) {
+      if (!path12.isAbsolute(filePath)) {
         reply.code(400);
         return { error: "path must be absolute" };
       }
@@ -2260,7 +2300,7 @@ function registerFsRoutes(app) {
         reply.code(403);
         return { error: "Path outside allowed root" };
       }
-      const ext = path11.extname(resolved).toLowerCase();
+      const ext = path12.extname(resolved).toLowerCase();
       const mime = IMAGE_MIMES[ext];
       if (!mime) {
         reply.code(400);
@@ -2273,7 +2313,7 @@ function registerFsRoutes(app) {
       }
       let stat;
       try {
-        stat = await fs10.stat(real);
+        stat = await fs11.stat(real);
       } catch {
         reply.code(404);
         return { error: "File not found" };
@@ -2332,7 +2372,8 @@ function registerSessionRoutes(app, manager) {
       return await manager.createSession({
         cwd: body.cwd,
         agentId: body.agentId,
-        modelId: body.modelId
+        modelId: body.modelId,
+        freshWorkspace: body.freshWorkspace
       });
     } catch (err) {
       reply.code(400);
@@ -2429,7 +2470,7 @@ var init_sessions = __esm({
 });
 
 // server/src/util/filekind.ts
-import path12 from "node:path";
+import path13 from "node:path";
 function mimeForExt(ext) {
   return MIME_MAP[ext.toLowerCase()] ?? "application/octet-stream";
 }
@@ -2449,7 +2490,7 @@ function looksBinary(buf) {
   return control / buf.length > 0.3;
 }
 function classifyKind(name) {
-  const ext = path12.extname(name).toLowerCase();
+  const ext = path13.extname(name).toLowerCase();
   if (ext in IMAGE_EXTS2) return "image";
   if (TEXT_EXTS.has(ext)) return "text";
   return "binary";
@@ -2559,9 +2600,9 @@ var init_filekind = __esm({
 });
 
 // server/src/routes/workspace.ts
-import fs11 from "node:fs/promises";
+import fs12 from "node:fs/promises";
 import { createReadStream as createReadStream2 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 function tooLargeForPreview(size, maxBytes) {
   return {
     error: `File too large for preview (${(size / 1024 / 1024).toFixed(1)} MB, max ${maxBytes / 1024 / 1024} MB)`
@@ -2606,7 +2647,7 @@ function registerWorkspaceRoutes(app, manager) {
       }
       const workspaceMissing = async () => {
         try {
-          return !(await fs11.stat(cwd)).isDirectory();
+          return !(await fs12.stat(cwd)).isDirectory();
         } catch {
           return true;
         }
@@ -2621,7 +2662,7 @@ function registerWorkspaceRoutes(app, manager) {
       }
       let dirents;
       try {
-        dirents = await fs11.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
+        dirents = await fs12.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
       } catch {
         return notFound();
       }
@@ -2629,14 +2670,14 @@ function registerWorkspaceRoutes(app, manager) {
       for (const d of dirents) {
         const name = d.name;
         const entryRelative = relative ? `${relative}/${name}` : name;
-        const entryAbsolute = path13.join(realTarget, name);
+        const entryAbsolute = path14.join(realTarget, name);
         let kind = d.isDirectory() ? "directory" : d.isFile() ? "file" : null;
         let statTarget = entryAbsolute;
         if (kind === null && d.isSymbolicLink()) {
           const real = await realConfineToRoot(config.fileRoot, entryAbsolute);
           if (!real) continue;
           try {
-            const st = await fs11.stat(real);
+            const st = await fs12.stat(real);
             kind = st.isDirectory() ? "directory" : st.isFile() ? "file" : null;
             statTarget = real;
           } catch {
@@ -2648,7 +2689,7 @@ function registerWorkspaceRoutes(app, manager) {
           entries.push({ name, path: entryRelative, type: "directory" });
         } else {
           try {
-            const stat = await fs11.stat(statTarget);
+            const stat = await fs12.stat(statTarget);
             entries.push({
               name,
               path: entryRelative,
@@ -2695,7 +2736,7 @@ function registerWorkspaceRoutes(app, manager) {
       }
       let stat;
       try {
-        stat = await fs11.stat(realTarget);
+        stat = await fs12.stat(realTarget);
       } catch {
         reply.code(404);
         return { error: "File not found" };
@@ -2708,8 +2749,8 @@ function registerWorkspaceRoutes(app, manager) {
         reply.code(413);
         return { error: `File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB, max 100 MB)` };
       }
-      const ext = path13.extname(realTarget);
-      const filename = path13.basename(realTarget);
+      const ext = path14.extname(realTarget);
+      const filename = path14.basename(realTarget);
       const asciiName = filename.replace(/[^\w.\-]/g, "_");
       reply.header("Content-Type", mimeForExt(ext));
       reply.header(
@@ -2747,7 +2788,7 @@ function registerWorkspaceRoutes(app, manager) {
       }
       let stat;
       try {
-        stat = await fs11.stat(realTarget);
+        stat = await fs12.stat(realTarget);
       } catch {
         reply.code(404);
         return { error: "File not found" };
@@ -2756,7 +2797,7 @@ function registerWorkspaceRoutes(app, manager) {
         reply.code(400);
         return { error: "Path is not a file" };
       }
-      const ext = path13.extname(realTarget).toLowerCase();
+      const ext = path14.extname(realTarget).toLowerCase();
       const mime = mimeForExt(ext);
       const isImage = mime.startsWith("image/");
       const isPdf = mime === "application/pdf";
@@ -2801,7 +2842,7 @@ function registerWorkspaceRoutes(app, manager) {
       if (kind === "binary") {
         let fh;
         try {
-          fh = await fs11.open(realTarget, "r");
+          fh = await fs12.open(realTarget, "r");
           const buf = Buffer.alloc(Math.min(HEXDUMP_BYTES, stat.size));
           const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
           const head = buf.subarray(0, bytesRead);
@@ -2851,36 +2892,36 @@ var init_workspace = __esm({
 
 // server/src/routes/uploads.ts
 import { createReadStream as createReadStream3, createWriteStream } from "node:fs";
-import fs12 from "node:fs/promises";
-import path14 from "node:path";
-import crypto4 from "node:crypto";
+import fs13 from "node:fs/promises";
+import path15 from "node:path";
+import crypto5 from "node:crypto";
 import { execFile as execFile3 } from "node:child_process";
 import { pipeline } from "node:stream/promises";
 function uploadDirFor(sessionId) {
-  return path14.join(config.casperDataDir, "sessions", sessionId, "uploads");
+  return path15.join(config.casperDataDir, "sessions", sessionId, "uploads");
 }
 function sanitizeName(raw) {
-  const base = path14.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
+  const base = path15.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
   if (!base || base === "." || base === "..") return `upload-${Date.now()}`;
   return base.replace(/^\.+/, "") || `upload-${Date.now()}`;
 }
 async function uniquePath(dir, name) {
-  const ext = path14.extname(name);
+  const ext = path15.extname(name);
   const stem = name.slice(0, name.length - ext.length);
   let candidate = name;
   let n = 1;
   while (true) {
     try {
-      await fs12.access(path14.join(dir, candidate));
+      await fs13.access(path15.join(dir, candidate));
       candidate = `${stem} (${n++})${ext}`;
     } catch {
-      return path14.join(dir, candidate);
+      return path15.join(dir, candidate);
     }
   }
 }
 function sha256File(absPath) {
   return new Promise((resolve, reject) => {
-    const hash = crypto4.createHash("sha256");
+    const hash = crypto5.createHash("sha256");
     createReadStream3(absPath).on("data", (d) => hash.update(d)).on("end", () => resolve(hash.digest("hex"))).on("error", reject);
   });
 }
@@ -2894,7 +2935,7 @@ function fileType(absPath) {
 async function sampleStrings(absPath, limit = 40) {
   let fh;
   try {
-    fh = await fs12.open(absPath, "r");
+    fh = await fs13.open(absPath, "r");
     const buf = Buffer.alloc(STRINGS_SCAN_BYTES);
     const { bytesRead } = await fh.read(buf, 0, STRINGS_SCAN_BYTES, 0);
     const out = [];
@@ -2932,7 +2973,7 @@ function registerUploadRoutes(app, manager) {
         return { error: "Invalid session id" };
       }
       const uploadDir = uploadDirFor(req.params.id);
-      await fs12.mkdir(uploadDir, { recursive: true, mode: 448 });
+      await fs13.mkdir(uploadDir, { recursive: true, mode: 448 });
       const results = [];
       const parts = req.files();
       for await (const part of parts) {
@@ -2946,17 +2987,17 @@ function registerUploadRoutes(app, manager) {
           return { error: `Failed to store ${name}` };
         }
         if (part.file.truncated) {
-          await fs12.rm(dest, { force: true });
+          await fs13.rm(dest, { force: true });
           reply.code(413);
           return {
             error: `${name} exceeds the max upload size (${Math.round(config.maxUploadBytes / 1024 / 1024)} MB)`
           };
         }
-        const stat = await fs12.stat(dest);
-        const ext = path14.extname(dest);
+        const stat = await fs13.stat(dest);
+        const ext = path15.extname(dest);
         const kind = classifyKind(dest);
         const uploaded = {
-          name: path14.basename(dest),
+          name: path15.basename(dest),
           // Absolute, because the file sits outside the session's workspace: a
           // relative path would resolve against the wrong root for both the agent
           // and the image endpoint.
@@ -3103,7 +3144,7 @@ var init_dispatch = __esm({
 });
 
 // server/src/ws/dirWatchers.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 function diffWatchSet(current, next) {
   const have = new Set(current);
   const want = new Set(next.slice(0, MAX_WATCHES));
@@ -3127,7 +3168,7 @@ function createDirWatchers(opts) {
     const target = await opts.resolve(relative);
     if (!target || closed) return;
     try {
-      const watcher = fs13.watch(target, { persistent: false }, () => {
+      const watcher = fs14.watch(target, { persistent: false }, () => {
         const existing = timers.get(relative);
         if (existing) clearTimeout(existing);
         timers.set(
@@ -3193,7 +3234,7 @@ function registerWsGateway(app, manager) {
           return null;
         }
       },
-      onChange: (path17) => send(socket, { type: "fs_changed", path: path17 })
+      onChange: (path18) => send(socket, { type: "fs_changed", path: path18 })
     });
     let alive = true;
     let ready = false;
@@ -3278,7 +3319,7 @@ var init_gateway = __esm({
 });
 
 // server/src/app.ts
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import websocket from "@fastify/websocket";
@@ -3316,14 +3357,14 @@ async function buildApp() {
   registerWorkspaceRoutes(app, manager);
   registerUploadRoutes(app, manager);
   registerWsGateway(app, manager);
-  if (fs14.existsSync(config.webDist)) {
+  if (fs15.existsSync(config.webDist)) {
     await app.register(fastifyStatic, {
       root: config.webDist
     });
     app.setNotFoundHandler((req, reply) => {
-      const path17 = req.url.split("?")[0] ?? "";
-      const looksLikeAsset = path17.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path17);
-      if (path17.startsWith("/api/") || path17.startsWith("/ws") || looksLikeAsset) {
+      const path18 = req.url.split("?")[0] ?? "";
+      const looksLikeAsset = path18.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path18);
+      if (path18.startsWith("/api/") || path18.startsWith("/ws") || looksLikeAsset) {
         reply.code(404).send({ error: "Not found" });
         return;
       }
@@ -3397,15 +3438,15 @@ __export(doctor_exports, {
   mcpWiring: () => mcpWiring
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs15 from "node:fs";
-import path15 from "node:path";
+import fs16 from "node:fs";
+import path16 from "node:path";
 function which(bin) {
-  if (bin.includes("/")) return fs15.existsSync(bin) ? bin : void 0;
-  for (const dir of (process.env.PATH ?? "").split(path15.delimiter)) {
+  if (bin.includes("/")) return fs16.existsSync(bin) ? bin : void 0;
+  for (const dir of (process.env.PATH ?? "").split(path16.delimiter)) {
     if (dir === "") continue;
-    const candidate = path15.join(dir, bin);
+    const candidate = path16.join(dir, bin);
     try {
-      fs15.accessSync(candidate, fs15.constants.X_OK);
+      fs16.accessSync(candidate, fs16.constants.X_OK);
       return candidate;
     } catch {
     }
@@ -3429,7 +3470,7 @@ function mcpWiring(agentJson, resolve) {
     return { ok: false, detail: `${command || "(no command)"} not found - widgets are unavailable` };
   }
   const script = args.find((a) => a.endsWith(".js"));
-  if (script && !fs15.existsSync(script)) {
+  if (script && !fs16.existsSync(script)) {
     return { ok: false, detail: `${script} is gone - delete the agent file and restart to rewrite it` };
   }
   return { ok: true, detail: script ?? `${command} ${args.join(" ")}` };
@@ -3461,7 +3502,7 @@ function checks() {
   const settings = readSettings(config.configFile);
   const hasToken = typeof settings.token === "string" && settings.token !== "";
   out.push(
-    fs15.existsSync(config.configFile) ? {
+    fs16.existsSync(config.configFile) ? {
       ok: hasToken,
       name: "settings",
       detail: hasToken ? `${config.configFile} (token set)` : `${config.configFile} exists but has no token - auth is DISABLED`
@@ -3471,8 +3512,8 @@ function checks() {
       detail: `${config.configFile} not found; a token is generated on first run`
     }
   );
-  if (fs15.existsSync(config.configFile)) {
-    const mode = fs15.statSync(config.configFile).mode & 511;
+  if (fs16.existsSync(config.configFile)) {
+    const mode = fs16.statSync(config.configFile).mode & 511;
     out.push({
       ok: mode === 384,
       name: "settings mode",
@@ -3480,10 +3521,10 @@ function checks() {
     });
   }
   try {
-    fs15.mkdirSync(config.casperDataDir, { recursive: true });
-    fs15.accessSync(config.casperDataDir, fs15.constants.W_OK);
-    const db2 = path15.join(config.casperDataDir, "casper.db");
-    const size = fs15.existsSync(db2) ? `, casper.db ${(fs15.statSync(db2).size / 1024).toFixed(0)} KB` : "";
+    fs16.mkdirSync(config.casperDataDir, { recursive: true });
+    fs16.accessSync(config.casperDataDir, fs16.constants.W_OK);
+    const db2 = path16.join(config.casperDataDir, "casper.db");
+    const size = fs16.existsSync(db2) ? `, casper.db ${(fs16.statSync(db2).size / 1024).toFixed(0)} KB` : "";
     out.push({ ok: true, name: "data dir", detail: `${config.casperDataDir} writable${size}` });
   } catch (err) {
     out.push({
@@ -3494,22 +3535,22 @@ function checks() {
     });
   }
   out.push(
-    fs15.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
+    fs16.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
       ok: false,
       fatal: true,
       name: "web app",
       detail: `${config.webDist} not found - the package is incomplete or CASPER_WEB_DIST is wrong`
     }
   );
-  const agent = path15.join(config.kiroSessionsDir, "..", "..", "agents", "casper.json");
-  const hasAgent = fs15.existsSync(agent);
+  const agent = path16.join(config.kiroSessionsDir, "..", "..", "agents", "casper.json");
+  const hasAgent = fs16.existsSync(agent);
   out.push({
     ok: hasAgent,
     name: "casper agent",
     detail: hasAgent ? agent : `${agent} missing - it is installed on first run`
   });
   if (hasAgent) {
-    const wiring = mcpWiring(fs15.readFileSync(agent, "utf8"), which);
+    const wiring = mcpWiring(fs16.readFileSync(agent, "utf8"), which);
     out.push({ ok: wiring.ok, name: "casper mcp", detail: wiring.detail });
   }
   return out;
@@ -3973,14 +4014,14 @@ var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.8.6" : "dev";
+    VERSION = true ? "0.8.8" : "dev";
   }
 });
 
 // server/src/cli/program.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import os4 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // server/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -7093,9 +7134,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path17) {
-    if (path17 === void 0) return this._executableDir;
-    this._executableDir = path17;
+  executableDir(path18) {
+    if (path18 === void 0) return this._executableDir;
+    this._executableDir = path18;
     return this;
   }
   /**
@@ -7353,7 +7394,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.8.6" : "dev";
+var VERSION2 = true ? "0.8.8" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);
@@ -7399,8 +7440,8 @@ async function resetToken(value) {
   updateSettings(file, { token });
   process.stdout.write(`wrote a new token to ${file}
 `);
-  const dbFile = path16.join(dataDirPath(), "casper.db");
-  if (fs16.existsSync(dbFile)) {
+  const dbFile = path17.join(dataDirPath(), "casper.db");
+  if (fs17.existsSync(dbFile)) {
     const { LoginStore: LoginStore2 } = await Promise.resolve().then(() => (init_logins(), logins_exports));
     new LoginStore2().revokeAll();
     process.stdout.write("revoked all device sessions\n");