@staff0rd/assist 0.191.3 → 0.193.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.191.3",
+  version: "0.193.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -49,10 +49,12 @@ var package_default = {
     "is-wsl": "^3.1.0",
     minimatch: "^10.1.1",
     "node-notifier": "^10.0.1",
+    "node-pty": "^1.1.0",
     semver: "^7.7.3",
     "shell-quote": "^1.8.3",
     "ts-morph": "^27.0.2",
     typescript: "^5.9.3",
+    ws: "^8.20.0",
     yaml: "^2.8.2",
     zod: "^4.3.6"
   },
@@ -70,7 +72,10 @@ var package_default = {
     "@types/react-dom": "^19.2.3",
     "@types/semver": "^7.7.1",
     "@types/shell-quote": "^1.7.5",
+    "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^4.1.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
     esbuild: "^0.27.3",
     jotai: "^2.18.0",
     jscpd: "^4.0.5",
@@ -920,10 +925,10 @@ function writeSignal(event, data) {
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path50 = getSignalPath();
-  if (!existsSync5(path50)) return void 0;
+  const path52 = getSignalPath();
+  if (!existsSync5(path52)) return void 0;
   try {
-    return JSON.parse(readFileSync5(path50, "utf-8"));
+    return JSON.parse(readFileSync5(path52, "utf-8"));
   } catch {
     return void 0;
   }
@@ -976,10 +981,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml2 } from "yaml";
-function loadRawYaml(path50) {
-  if (!existsSync7(path50)) return {};
+function loadRawYaml(path52) {
+  if (!existsSync7(path52)) return {};
   try {
-    const content = readFileSync6(path50, "utf-8");
+    const content = readFileSync6(path52, "utf-8");
     return parseYaml2(content) || {};
   } catch {
     return {};
@@ -1573,20 +1578,20 @@ function createBundleHandler(importMetaUrl, bundlePath) {
     res.end(cache);
   };
 }
-function createHtmlHandler(getHtml3) {
+function createHtmlHandler(getHtml4) {
   return (_req, res) => {
     res.writeHead(200, { "Content-Type": "text/html" });
-    res.end(getHtml3());
+    res.end(getHtml4());
   };
 }
 function parseRoute(req, port) {
   const url = new URL(req.url ?? "/", `http://localhost:${port}`);
   return { method: req.method ?? "GET", pathname: url.pathname };
 }
-function createRouteHandler(routes3) {
+function createRouteHandler(routes4) {
   return async (req, res, port) => {
     const { method, pathname } = parseRoute(req, port);
-    const handler = routes3[`${method} ${pathname}`];
+    const handler = routes4[`${method} ${pathname}`];
     if (handler) {
       await handler(req, res);
       return;
@@ -1605,6 +1610,25 @@ function startWebServer(label2, port, handler) {
     console.log(chalk16.dim("Press Ctrl+C to stop"));
     exec(`open ${url}`);
   });
+  return server;
+}
+
+// src/shared/createFallbackHandler.ts
+function createFallbackHandler(routes4, htmlHandler3, extra) {
+  const baseHandler = createRouteHandler(routes4);
+  return async (req, res, port) => {
+    const { method, pathname } = parseRoute(req, port);
+    if (extra && await extra(req, res, pathname)) return;
+    if (routes4[`${method} ${pathname}`]) {
+      await baseHandler(req, res, port);
+      return;
+    }
+    if (method === "GET" && !pathname.startsWith("/api/")) {
+      await htmlHandler3(req, res);
+      return;
+    }
+    await baseHandler(req, res, port);
+  };
 }
 
 // src/commands/backlog/web/getHtml.ts
@@ -1711,8 +1735,9 @@ async function patchItemStatus(req, res, id) {
 }
 
 // src/commands/backlog/web/handleRequest.ts
+var htmlHandler = createHtmlHandler(getHtml);
 var routes = {
-  "GET /": createHtmlHandler(getHtml),
+  "GET /": htmlHandler,
   "GET /bundle.js": createBundleHandler(
     import.meta.url,
     "commands/backlog/web/bundle.js"
@@ -1726,8 +1751,6 @@ var itemRoutes = {
   PATCH: (req, res, id) => patchItemStatus(req, res, id),
   DELETE: (_req, res, id) => deleteItem2(res, id)
 };
-var serveHtml = createHtmlHandler(getHtml);
-var baseHandler = createRouteHandler(routes);
 async function handleItemRoute(req, res, pathname) {
   const match = pathname.match(/^\/api\/items\/(\d+)$/);
   if (!match) return false;
@@ -1736,21 +1759,11 @@ async function handleItemRoute(req, res, pathname) {
   await handler(req, res, Number.parseInt(match[1], 10));
   return true;
 }
-async function handleRequest(req, res, port) {
-  const url = new URL(req.url ?? "/", `http://localhost:${port}`);
-  const method = req.method ?? "GET";
-  const pathname = url.pathname;
-  if (await handleItemRoute(req, res, pathname)) return;
-  if (routes[`${method} ${pathname}`]) {
-    await baseHandler(req, res, port);
-    return;
-  }
-  if (method === "GET" && !pathname.startsWith("/api/")) {
-    await serveHtml(req, res);
-    return;
-  }
-  await baseHandler(req, res, port);
-}
+var handleRequest = createFallbackHandler(
+  routes,
+  htmlHandler,
+  handleItemRoute
+);
 
 // src/commands/backlog/web/index.ts
 async function web(options2) {
@@ -4942,9 +4955,9 @@ var __dirname4 = dirname15(__filename2);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path50) {
-  if (!existsSync20(path50)) return [];
-  return readFileSync16(path50, "utf-8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path52) {
+  if (!existsSync20(path52)) return [];
+  return readFileSync16(path52, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -5377,14 +5390,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path50, description, depth, p) {
-  showProgress(p, path50.join(" "));
-  const subHelp = await runHelp([cli, ...path50]);
+async function resolveCommand(cli, path52, description, depth, p) {
+  showProgress(p, path52.join(" "));
+  const subHelp = await runHelp([cli, ...path52]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path50, description }];
+    return [{ path: path52, description }];
   }
-  const children = await discoverAt(cli, path50, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path50, description }];
+  const children = await discoverAt(cli, path52, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path52, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -5532,9 +5545,9 @@ function logPath(cli) {
   return join19(homedir4(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path50 = logPath(cli);
-  if (!existsSync22(path50)) return void 0;
-  return readFileSync18(path50, "utf-8");
+  const path52 = logPath(cli);
+  if (!existsSync22(path52)) return void 0;
+  return readFileSync18(path52, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join19(homedir4(), ".assist");
@@ -6176,8 +6189,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path50, value) {
-  const keys = path50.split(".");
+function setNestedValue(obj, path52, value) {
+  const keys = path52.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -6257,9 +6270,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path50) {
+function getNestedValue(obj, path52) {
   let current = obj;
-  for (const key of path50.split(".")) current = stepInto(current, key);
+  for (const key of path52.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -7600,10 +7613,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path50 = getStorePath(filename);
-  if (existsSync29(path50)) {
+  const path52 = getStorePath(filename);
+  if (existsSync29(path52)) {
     try {
-      return JSON.parse(readFileSync25(path50, "utf-8"));
+      return JSON.parse(readFileSync25(path52, "utf-8"));
     } catch {
       return {};
     }
@@ -7996,7 +8009,7 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-function comment2(path50, line, body) {
+function comment2(path52, line, body) {
   validateBody(body);
   validateLine(line);
   try {
@@ -8016,7 +8029,7 @@ function comment2(path50, line, body) {
           "-f",
           `body=${body}`,
           "-f",
-          `path=${path50}`,
+          `path=${path52}`,
           "-F",
           `line=${line}`
         ],
@@ -8025,7 +8038,7 @@ function comment2(path50, line, body) {
       if (result.status !== 0) {
         throw new Error(result.stderr || result.stdout);
       }
-      console.log(`Added review comment on ${path50}:${line}`);
+      console.log(`Added review comment on ${path52}:${line}`);
     } finally {
       unlinkSync6(queryFile);
     }
@@ -8524,8 +8537,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path50, line, body) => {
-    comment2(path50, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path52, line, body) => {
+    comment2(path52, Number.parseInt(line, 10), body);
   });
 }
 
@@ -8777,10 +8790,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path50) {
+async function ravenFetch(connection, path52) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path50}`;
+  const url = `${connection.url}${path52}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -8870,16 +8883,16 @@ import chalk111 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path50;
+  let path52;
   if (opts.collection) {
-    path50 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path52 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path50 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path52 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path50 += `&query=${encodeURIComponent(opts.query)}`;
+    path52 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path50;
+  return path52;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -8888,7 +8901,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path50 = buildQueryPath({
+    const path52 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -8896,7 +8909,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path50);
+    const data = await ravenFetch(connection, path52);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -10067,8 +10080,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename7 = path39.basename(file, path39.extname(file));
-    if (basename7 === "index") continue;
+    const basename8 = path39.basename(file, path39.extname(file));
+    if (basename8 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -10518,8 +10531,8 @@ import chalk128 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk125 from "chalk";
-async function fetchSeq(conn, path50, params) {
-  const url = `${conn.url}${path50}?${params}`;
+async function fetchSeq(conn, path52, params) {
+  const url = `${conn.url}${path52}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -12123,11 +12136,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path50 = process.argv[idx + 1];
+  const path52 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path50, prefix: prefix2 };
+  return { path: path52, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -12373,6 +12386,422 @@ function screenshot(processName) {
   }
 }
 
+// src/commands/sessions/web/index.ts
+import { WebSocketServer } from "ws";
+
+// src/commands/sessions/web/handleRequest.ts
+import { readFileSync as readFileSync34 } from "fs";
+import { createRequire as createRequire2 } from "module";
+
+// src/commands/sessions/web/getHtml.ts
+function getHtml3() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Sessions</title>
+<link rel="stylesheet" href="/xterm.css">
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  html, body, #app { width: 100%; height: 100%; overflow: hidden; background: #1e1e1e; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+  ::-webkit-scrollbar { width: 6px; }
+  ::-webkit-scrollbar-track { background: transparent; }
+  ::-webkit-scrollbar-thumb { background: #555; border-radius: 3px; }
+  ::-webkit-scrollbar-thumb:hover { background: #777; }
+</style>
+</head>
+<body>
+<div id="app"></div>
+<script src="/bundle.js"></script>
+</body>
+</html>`;
+}
+
+// src/commands/sessions/web/handleRequest.ts
+var require3 = createRequire2(import.meta.url);
+function createCssHandler(packageEntry) {
+  let cache;
+  return (_req, res) => {
+    if (!cache) {
+      const resolved = require3.resolve(packageEntry);
+      cache = readFileSync34(resolved, "utf-8");
+    }
+    res.writeHead(200, { "Content-Type": "text/css" });
+    res.end(cache);
+  };
+}
+var htmlHandler2 = createHtmlHandler(getHtml3);
+var routes3 = {
+  "GET /": htmlHandler2,
+  "GET /bundle.js": createBundleHandler(
+    import.meta.url,
+    "commands/sessions/web/bundle.js"
+  ),
+  "GET /xterm.css": createCssHandler("@xterm/xterm/css/xterm.css")
+};
+var handleRequest3 = createFallbackHandler(routes3, htmlHandler2);
+
+// src/commands/sessions/web/handleSocket.ts
+function handleSocket(ws, manager) {
+  manager.addClient(ws);
+  ws.on("message", (msg) => {
+    let data;
+    try {
+      data = JSON.parse(msg.toString());
+    } catch {
+      return;
+    }
+    switch (data.type) {
+      case "create": {
+        const id = manager.spawn(data.prompt);
+        ws.send(JSON.stringify({ type: "created", sessionId: id }));
+        break;
+      }
+      case "input":
+        manager.writeToSession(data.sessionId, data.data);
+        break;
+      case "resize":
+        manager.resizeSession(
+          data.sessionId,
+          data.cols,
+          data.rows
+        );
+        break;
+      case "resume": {
+        const id = manager.resume(
+          data.sessionId,
+          data.cwd,
+          data.name
+        );
+        ws.send(JSON.stringify({ type: "created", sessionId: id }));
+        break;
+      }
+      case "dismiss":
+        manager.dismissSession(data.sessionId);
+        break;
+      case "history":
+        manager.getHistory().then((history) => {
+          ws.send(JSON.stringify({ type: "history", sessions: history }));
+        });
+        break;
+    }
+  });
+  ws.on("close", () => {
+    manager.removeClient(ws);
+  });
+}
+
+// src/commands/sessions/web/spawnClaude.ts
+import * as pty from "node-pty";
+function spawnClaude2(opts = {}) {
+  const shell = process.platform === "win32" ? "cmd.exe" : process.env.SHELL ?? "bash";
+  const args = buildArgs(opts);
+  return pty.spawn(shell, args, {
+    name: "xterm-256color",
+    cols: 120,
+    rows: 30,
+    cwd: opts.cwd ?? process.cwd(),
+    env: { ...process.env }
+  });
+}
+function buildArgs(opts) {
+  const claudeArgs = opts.resumeSessionId ? ["claude", "--resume", opts.resumeSessionId] : opts.prompt ? ["claude", opts.prompt] : ["claude"];
+  if (process.platform === "win32") {
+    return ["/c", ...claudeArgs];
+  }
+  return ["-c", `exec ${claudeArgs.map(shellEscape).join(" ")}`];
+}
+function shellEscape(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// src/commands/sessions/web/createSession.ts
+function createSession(id, prompt) {
+  return {
+    id,
+    name: prompt?.slice(0, 40) || `Session ${id}`,
+    status: "running",
+    startedAt: Date.now(),
+    pty: spawnClaude2({ prompt }),
+    scrollback: "",
+    idleTimer: null,
+    lastResizeAt: 0
+  };
+}
+function resumeSession(id, sessionId, cwd, name) {
+  return {
+    id,
+    name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
+    status: "running",
+    startedAt: Date.now(),
+    pty: spawnClaude2({ resumeSessionId: sessionId, cwd }),
+    scrollback: "",
+    idleTimer: null,
+    lastResizeAt: 0
+  };
+}
+
+// src/commands/sessions/web/discoverSessions.ts
+import * as fs24 from "fs";
+import * as os from "os";
+import * as path47 from "path";
+
+// src/commands/sessions/web/parseSessionFile.ts
+import * as fs23 from "fs";
+import * as path46 from "path";
+
+// src/commands/sessions/web/extractSessionMeta.ts
+function extractSessionMeta(lines) {
+  let sessionId = "";
+  let cwd = "";
+  let timestamp = "";
+  let name = "";
+  for (const line of lines) {
+    const entry = safeParse(line);
+    if (!entry) continue;
+    sessionId ||= typeof entry.sessionId === "string" ? entry.sessionId : "";
+    timestamp ||= typeof entry.timestamp === "string" ? entry.timestamp : "";
+    cwd ||= typeof entry.cwd === "string" ? entry.cwd : "";
+    if (entry.type === "user" && !entry.isMeta) {
+      name = extractName(entry);
+      break;
+    }
+  }
+  return { sessionId, cwd, timestamp, name };
+}
+function safeParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function extractName(entry) {
+  const msg = entry.message;
+  const content = msg?.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
+  return text.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+}
+
+// src/commands/sessions/web/parseSessionFile.ts
+async function parseSessionFile(filePath) {
+  let handle;
+  try {
+    handle = await fs23.promises.open(filePath, "r");
+    const buf = Buffer.alloc(16384);
+    const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+    const lines = buf.toString("utf8", 0, bytesRead).split("\n").filter(Boolean);
+    const meta = extractSessionMeta(lines);
+    if (!meta.sessionId) return null;
+    const timestamp = meta.timestamp || (await fs23.promises.stat(filePath)).mtime.toISOString();
+    const project = meta.cwd ? path46.basename(meta.cwd) : dirNameToProject(filePath);
+    return {
+      sessionId: meta.sessionId,
+      name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
+      project,
+      cwd: meta.cwd,
+      timestamp
+    };
+  } catch {
+    return null;
+  } finally {
+    await handle?.close();
+  }
+}
+function dirNameToProject(filePath) {
+  const dirName = path46.basename(path46.dirname(filePath));
+  const parts = dirName.split("--");
+  return parts[parts.length - 1].replace(/-/g, "/");
+}
+
+// src/commands/sessions/web/discoverSessions.ts
+async function discoverSessions() {
+  const projectsDir = path47.join(os.homedir(), ".claude", "projects");
+  let projectDirs;
+  try {
+    projectDirs = await fs24.promises.readdir(projectsDir);
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  await Promise.all(
+    projectDirs.map(async (dirName) => {
+      const dirPath = path47.join(projectsDir, dirName);
+      let entries;
+      try {
+        entries = await fs24.promises.readdir(dirPath);
+      } catch {
+        return;
+      }
+      const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
+      await Promise.all(
+        jsonlFiles.map(async (file) => {
+          const filePath = path47.join(dirPath, file);
+          const session = await parseSessionFile(filePath);
+          if (session) sessions.push(session);
+        })
+      );
+    })
+  );
+  sessions.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  );
+  return sessions;
+}
+
+// src/commands/sessions/web/scheduleIdle.ts
+var IDLE_MS = 3e3;
+function scheduleIdle(session, onIdle) {
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  if (session.status === "done") return;
+  session.idleTimer = setTimeout(() => {
+    if (session.status === "running") onIdle();
+  }, IDLE_MS);
+}
+function clearIdle(session) {
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+}
+
+// src/commands/sessions/web/wsBroadcast.ts
+function wsSend(ws, msg) {
+  if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
+}
+function wsBroadcast(clients, msg) {
+  const json = JSON.stringify(msg);
+  for (const ws of clients) {
+    if (ws.readyState === ws.OPEN) ws.send(json);
+  }
+}
+
+// src/commands/sessions/web/wirePtyEvents.ts
+var MAX_SCROLLBACK = 256 * 1024;
+var RESIZE_GRACE_MS = 500;
+function appendScrollback(session, data) {
+  session.scrollback += data;
+  if (session.scrollback.length > MAX_SCROLLBACK) {
+    session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
+  }
+}
+function wirePtyEvents(session, clients, onStatusChange) {
+  session.pty.onData((data) => {
+    appendScrollback(session, data);
+    const isRedraw = Date.now() - session.lastResizeAt < RESIZE_GRACE_MS;
+    if (!isRedraw && session.status !== "running")
+      onStatusChange(session, "running");
+    if (!isRedraw)
+      scheduleIdle(session, () => onStatusChange(session, "waiting"));
+    wsBroadcast(clients, { type: "output", sessionId: session.id, data });
+  });
+  session.pty.onExit(() => {
+    clearIdle(session);
+    onStatusChange(session, "done");
+  });
+}
+
+// src/commands/sessions/web/SessionManager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Set();
+  nextId = 1;
+  addClient(ws) {
+    this.clients.add(ws);
+    wsSend(ws, { type: "sessions", sessions: this.listSessions() });
+    for (const s of this.sessions.values()) {
+      if (s.scrollback)
+        wsSend(ws, { type: "output", sessionId: s.id, data: s.scrollback });
+    }
+  }
+  removeClient(ws) {
+    this.clients.delete(ws);
+  }
+  spawn(prompt) {
+    const id = String(this.nextId++);
+    const session = createSession(id, prompt);
+    this.wire(session);
+    return id;
+  }
+  resume(sessionId, cwd, name) {
+    const id = String(this.nextId++);
+    const session = resumeSession(id, sessionId, cwd, name);
+    this.wire(session);
+    return id;
+  }
+  wire(session) {
+    this.sessions.set(session.id, session);
+    wirePtyEvents(session, this.clients, (s, status2) => {
+      s.status = status2;
+      this.notify();
+    });
+    scheduleIdle(session, () => {
+      session.status = "waiting";
+      this.notify();
+    });
+    this.notify();
+  }
+  writeToSession(id, data) {
+    const s = this.sessions.get(id);
+    if (s && s.status !== "done") s.pty.write(data);
+  }
+  resizeSession(id, cols, rows) {
+    const s = this.sessions.get(id);
+    if (s && s.status !== "done") {
+      s.lastResizeAt = Date.now();
+      s.pty.resize(cols, rows);
+    }
+  }
+  dismissSession(id) {
+    const s = this.sessions.get(id);
+    if (!s) return;
+    if (s.status !== "done") s.pty.kill();
+    clearIdle(s);
+    this.sessions.delete(id);
+    this.notify();
+  }
+  listSessions() {
+    return [...this.sessions.values()].map(
+      ({ id, name, status: status2, startedAt }) => ({
+        id,
+        name,
+        status: status2,
+        startedAt
+      })
+    );
+  }
+  async getHistory() {
+    return discoverSessions();
+  }
+  notify() {
+    wsBroadcast(this.clients, {
+      type: "sessions",
+      sessions: this.listSessions()
+    });
+  }
+};
+
+// src/commands/sessions/web/index.ts
+async function web3(options2) {
+  const port = Number.parseInt(options2.port, 10);
+  const server = startWebServer("Sessions", port, handleRequest3);
+  const manager = new SessionManager();
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (req, socket, head) => {
+    if (req.url === "/ws") {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        handleSocket(ws, manager);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+}
+
+// src/commands/sessions/registerSessions.ts
+function registerSessions(program2) {
+  const cmd = program2.command("sessions").description("Web dashboard for Claude Code sessions").action(() => web3({ port: "3100" }));
+  cmd.command("web").description("Start the sessions web dashboard").option("-p, --port <number>", "Port to listen on", "3100").action(web3);
+}
+
 // src/commands/statusLine.ts
 import chalk134 from "chalk";
 
@@ -12451,21 +12880,21 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs25 from "fs";
-import * as os from "os";
-import * as path48 from "path";
+import * as fs27 from "fs";
+import * as os2 from "os";
+import * as path50 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs23 from "fs";
-import * as path46 from "path";
+import * as fs25 from "fs";
+import * as path48 from "path";
 import chalk135 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path46.join(claudeDir, "CLAUDE.md");
-  const target = path46.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs23.readFileSync(source, "utf-8");
-  if (fs23.existsSync(target)) {
-    const targetContent = fs23.readFileSync(target, "utf-8");
+  const source = path48.join(claudeDir, "CLAUDE.md");
+  const target = path48.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs25.readFileSync(source, "utf-8");
+  if (fs25.existsSync(target)) {
+    const targetContent = fs25.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk135.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -12482,21 +12911,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs23.copyFileSync(source, target);
+  fs25.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs24 from "fs";
-import * as path47 from "path";
+import * as fs26 from "fs";
+import * as path49 from "path";
 import chalk136 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path47.join(claudeDir, "settings.json");
-  const target = path47.join(targetBase, "settings.json");
-  const sourceContent = fs24.readFileSync(source, "utf-8");
+  const source = path49.join(claudeDir, "settings.json");
+  const target = path49.join(targetBase, "settings.json");
+  const sourceContent = fs26.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs24.existsSync(target)) {
-    const targetContent = fs24.readFileSync(target, "utf-8");
+  if (fs26.existsSync(target)) {
+    const targetContent = fs26.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -12522,29 +12951,29 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs24.writeFileSync(target, mergedContent);
+  fs26.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path48.dirname(__filename4);
+var __dirname7 = path50.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path48.join(__dirname7, "..", "claude");
-  const targetBase = path48.join(os.homedir(), ".claude");
+  const claudeDir = path50.join(__dirname7, "..", "claude");
+  const targetBase = path50.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path48.join(claudeDir, "commands");
-  const targetDir = path48.join(targetBase, "commands");
-  fs25.mkdirSync(targetDir, { recursive: true });
-  const files = fs25.readdirSync(sourceDir);
+  const sourceDir = path50.join(claudeDir, "commands");
+  const targetDir = path50.join(targetBase, "commands");
+  fs27.mkdirSync(targetDir, { recursive: true });
+  const files = fs27.readdirSync(sourceDir);
   for (const file of files) {
-    fs25.copyFileSync(path48.join(sourceDir, file), path48.join(targetDir, file));
+    fs27.copyFileSync(path50.join(sourceDir, file), path50.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -12552,15 +12981,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync42 } from "child_process";
-import * as path49 from "path";
+import * as path51 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path49.resolve(dir);
-    if (resolved.split(path49.sep).includes("node_modules")) {
+    const resolved = path51.resolve(dir);
+    if (resolved.split(path51.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync42("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path49.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path51.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -12627,6 +13056,7 @@ registerRavendb(program);
 registerSeq(program);
 registerTranscript(program);
 registerVoice(program);
+registerSessions(program);
 registerDeny(program);
 program.command("next").description("Alias for backlog next -w").action(() => next({ allowEdits: true }));
 program.command("draft").alias("feat").description("Launch Claude in /draft mode, chain into next on /next signal").action(() => launchMode("draft"));