@kosinal/claude-code-dashboard 0.0.0 → 0.0.2

package/dist/bin.js

@@ -5,77 +5,572 @@ import { exec, spawn } from "child_process";
 import * as http2 from "http";
 import * as net from "net";
 
-// src/state.ts
-var EVENT_TO_STATUS = {
-  SessionStart: "waiting",
-  UserPromptSubmit: "running",
-  Stop: "waiting"
-};
-function createStore() {
-  const sessions = /* @__PURE__ */ new Map();
-  return {
-    handleEvent(payload) {
-      const { session_id, hook_event_name, cwd } = payload;
-      if (hook_event_name === "SessionEnd") {
-        sessions.delete(session_id);
-        return null;
+// src/hooks.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var MARKER_QUICK = "__claude_code_dashboard_quick__";
+var MARKER_INSTALL = "__claude_code_dashboard_install__";
+var MARKER_LEGACY = "__claude_code_dashboard__";
+var HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"];
+function getConfigDir(configDir) {
+  return configDir ?? path.join(os.homedir(), ".claude");
+}
+function getSettingsPath(configDir) {
+  return path.join(getConfigDir(configDir), "settings.json");
+}
+function readSettings(configDir) {
+  const settingsPath = getSettingsPath(configDir);
+  try {
+    const content = fs.readFileSync(settingsPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed;
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return {};
+    }
+    try {
+      fs.copyFileSync(settingsPath, `${settingsPath}.bak`);
+      console.warn(`Warning: Invalid settings.json backed up to ${settingsPath}.bak`);
+    } catch {
+    }
+    return {};
+  }
+}
+function writeSettings(settings, configDir) {
+  const settingsPath = getSettingsPath(configDir);
+  const dir = path.dirname(settingsPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+}
+function backupSettings(configDir) {
+  const settingsPath = getSettingsPath(configDir);
+  const backupPath = settingsPath.replace(/\.json$/, ".pre-dashboard.json");
+  try {
+    fs.copyFileSync(settingsPath, backupPath);
+  } catch {
+  }
+}
+function removeHooksByMarkers(settings, markers) {
+  if (!settings.hooks) return;
+  for (const event of HOOK_EVENTS) {
+    const groups = settings.hooks[event];
+    if (!groups) continue;
+    const filtered = [];
+    for (const group of groups) {
+      const kept = group.hooks.filter(
+        (h) => !h.statusMessage || !markers.includes(h.statusMessage)
+      );
+      if (kept.length > 0) {
+        filtered.push({ ...group, hooks: kept });
       }
-      const status = EVENT_TO_STATUS[hook_event_name];
-      if (!status) {
-        const existing2 = sessions.get(session_id);
-        if (existing2) return existing2;
-        const session2 = {
-          sessionId: session_id,
-          status: "waiting",
-          cwd: cwd ?? "",
-          lastEvent: hook_event_name,
-          updatedAt: Date.now(),
-          startedAt: Date.now()
-        };
-        sessions.set(session_id, session2);
-        return session2;
+    }
+    if (filtered.length > 0) {
+      settings.hooks[event] = filtered;
+    } else {
+      delete settings.hooks[event];
+    }
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+}
+function installHooks(port, configDir) {
+  const settings = readSettings(configDir);
+  backupSettings(configDir);
+  removeHooksByMarkers(settings, [MARKER_QUICK, MARKER_LEGACY]);
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  for (const event of HOOK_EVENTS) {
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+    const command = process.platform === "win32" ? `powershell -NoProfile -Command "$input | Invoke-WebRequest -Uri http://localhost:${port}/api/hook -Method POST -ContentType 'application/json' -ErrorAction SilentlyContinue | Out-Null"` : `curl -s -X POST -H "Content-Type: application/json" -d @- http://localhost:${port}/api/hook > /dev/null 2>&1`;
+    settings.hooks[event].push({
+      hooks: [
+        {
+          type: "command",
+          command,
+          async: true,
+          statusMessage: MARKER_QUICK
+        }
+      ]
+    });
+  }
+  writeSettings(settings, configDir);
+}
+function installHooksWithCommand(command, configDir) {
+  const settings = readSettings(configDir);
+  backupSettings(configDir);
+  removeHooksByMarkers(settings, [MARKER_INSTALL, MARKER_LEGACY]);
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  for (const event of HOOK_EVENTS) {
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+    settings.hooks[event].push({
+      hooks: [
+        {
+          type: "command",
+          command,
+          async: true,
+          statusMessage: MARKER_INSTALL
+        }
+      ]
+    });
+  }
+  writeSettings(settings, configDir);
+}
+function removeHooks(configDir, mode) {
+  const settingsPath = getSettingsPath(configDir);
+  try {
+    fs.accessSync(settingsPath);
+  } catch {
+    return;
+  }
+  const settings = readSettings(configDir);
+  let markers;
+  if (mode === "quick") {
+    markers = [MARKER_QUICK, MARKER_LEGACY];
+  } else if (mode === "install") {
+    markers = [MARKER_INSTALL, MARKER_LEGACY];
+  } else {
+    markers = [MARKER_QUICK, MARKER_INSTALL, MARKER_LEGACY];
+  }
+  removeHooksByMarkers(settings, markers);
+  writeSettings(settings, configDir);
+}
+
+// src/installer.ts
+import { execSync } from "child_process";
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+var DASHBOARD_DIR = path2.join(os2.homedir(), ".claude", "dashboard");
+var BIN_DIR = path2.join(os2.homedir(), ".claude", "bin");
+var CONFIG_PATH = path2.join(DASHBOARD_DIR, "config.json");
+var SERVER_DIR = path2.join(DASHBOARD_DIR, "server");
+var HOOK_SCRIPT_PATH = path2.join(BIN_DIR, "claude-dashboard-hook.mjs");
+var LOCK_PATH = path2.join(DASHBOARD_DIR, "dashboard.lock");
+var PROTOCOL_SCHEME = "claude-dashboard";
+function getThisBundle() {
+  return process.argv[1] ?? __filename;
+}
+function writeHookScript(_port, _serverEntry) {
+  const script = `#!/usr/bin/env node
+// Auto-generated by claude-code-dashboard install
+import { readFileSync, existsSync, unlinkSync } from 'node:fs';
+import { spawn, exec } from 'node:child_process';
+import { request } from 'node:http';
+import { openSync } from 'node:fs';
+
+const CONFIG_PATH = ${JSON.stringify(CONFIG_PATH)};
+const LOCK_PATH = ${JSON.stringify(LOCK_PATH)};
+
+let config;
+try {
+  config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+} catch {
+  process.exit(0); // Config missing \u2014 probably uninstalled
+}
+
+const { port, serverEntry } = config;
+const stdin = readFileSync(0, 'utf-8');
+
+function postHook(data) {
+  return new Promise((resolve, reject) => {
+    const req = request({
+      hostname: '127.0.0.1',
+      port,
+      path: '/api/hook',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      timeout: 5000,
+    }, (res) => {
+      res.resume();
+      resolve(res.statusCode);
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.write(data);
+    req.end();
+  });
+}
+
+function httpPing() {
+  return new Promise((resolve, reject) => {
+    const req = request({
+      hostname: '127.0.0.1',
+      port,
+      path: '/api/sessions',
+      method: 'GET',
+      timeout: 2000,
+    }, (res) => {
+      res.resume();
+      resolve(res.statusCode);
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    req.end();
+  });
+}
+
+async function isServerRunning() {
+  try {
+    if (!existsSync(LOCK_PATH)) return false;
+    const pid = parseInt(readFileSync(LOCK_PATH, 'utf-8').trim().split(':')[0], 10);
+    if (isNaN(pid)) return false;
+    try {
+      process.kill(pid, 0); // Check if process exists
+    } catch (e) {
+      // On Windows, EPERM can be thrown for processes we can't signal but that exist.
+      // Only treat ESRCH (no such process) as definitely dead.
+      if (e && e.code === 'ESRCH') {
+        try { unlinkSync(LOCK_PATH); } catch { /* ignore */ }
+        return false;
       }
-      const now = Date.now();
-      const existing = sessions.get(session_id);
-      if (existing) {
-        existing.status = status;
-        existing.lastEvent = hook_event_name;
-        existing.updatedAt = now;
-        if (cwd) existing.cwd = cwd;
-        return existing;
+      // EPERM \u2014 process might exist, fall through to HTTP check
+    }
+    // PID check passed or was ambiguous \u2014 verify with HTTP ping
+    try {
+      await httpPing();
+      return true;
+    } catch {
+      // HTTP ping failed \u2014 server is not actually running, clean stale lock
+      try { unlinkSync(LOCK_PATH); } catch { /* ignore */ }
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === 'win32'
+    ? \`start "" "\${url}"\`
+    : platform === 'darwin'
+      ? \`open "\${url}"\`
+      : \`xdg-open "\${url}"\`;
+  exec(cmd, () => {});
+}
+
+function startServer() {
+  const logPath = ${JSON.stringify(path2.join(DASHBOARD_DIR, "server.log"))};
+  const logFd = openSync(logPath, 'a');
+  const child = spawn(process.execPath, [serverEntry, '--no-hooks', '--no-open', '--port', String(port)], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env },
+  });
+  child.unref();
+}
+
+async function waitForServer(maxWaitMs = 10000) {
+  const start = Date.now();
+  let delay = 100;
+  while (Date.now() - start < maxWaitMs) {
+    try {
+      await postHook('{"session_id":"ping","hook_event_name":"Ping"}');
+      return true;
+    } catch {
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, 1000);
+    }
+  }
+  return false;
+}
+
+async function main() {
+  try {
+    await postHook(stdin);
+  } catch {
+    // Server not running \u2014 try to start it
+    const running = await isServerRunning();
+    if (!running) {
+      startServer();
+    }
+    const ready = await waitForServer();
+    if (ready) {
+      if (!running) {
+        // We just auto-started the server \u2014 open the browser
+        openBrowser(\`http://localhost:\${port}\`);
       }
-      const session = {
-        sessionId: session_id,
-        status,
-        cwd: cwd ?? "",
-        lastEvent: hook_event_name,
-        updatedAt: now,
-        startedAt: now
-      };
-      sessions.set(session_id, session);
-      return session;
-    },
-    getAllSessions() {
-      return Array.from(sessions.values());
-    },
-    getSession(sessionId) {
-      return sessions.get(sessionId);
-    },
-    removeSession(sessionId) {
-      return sessions.delete(sessionId);
-    },
-    cleanIdleSessions(maxIdleMs) {
-      const now = Date.now();
-      const removed = [];
-      for (const [id, session] of sessions) {
-        if (now - session.updatedAt > maxIdleMs) {
-          sessions.delete(id);
-          removed.push(id);
+      try { await postHook(stdin); } catch { /* give up */ }
+    }
+  }
+}
+
+main().catch(() => {});
+`;
+  fs2.mkdirSync(path2.dirname(HOOK_SCRIPT_PATH), { recursive: true });
+  fs2.writeFileSync(HOOK_SCRIPT_PATH, script);
+}
+function getShortcutPath() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    const appData = process.env.APPDATA;
+    if (!appData) return null;
+    return path2.join(
+      appData,
+      "Microsoft",
+      "Windows",
+      "Start Menu",
+      "Programs",
+      "Claude Dashboard.url"
+    );
+  }
+  if (platform === "darwin") {
+    return path2.join(os2.homedir(), "Applications", "Claude Dashboard.webloc");
+  }
+  return path2.join(os2.homedir(), ".local", "share", "applications", "claude-dashboard.desktop");
+}
+function createShortcuts(port) {
+  const shortcutPath = getShortcutPath();
+  if (!shortcutPath) return;
+  fs2.mkdirSync(path2.dirname(shortcutPath), { recursive: true });
+  const platform = process.platform;
+  const url = `http://localhost:${port}`;
+  if (platform === "win32") {
+    const content = `[InternetShortcut]
+URL=${url}
+IconIndex=0
+`;
+    fs2.writeFileSync(shortcutPath, content);
+  } else if (platform === "darwin") {
+    const content = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+      '<plist version="1.0">',
+      "<dict>",
+      "	<key>URL</key>",
+      `	<string>${url}</string>`,
+      "</dict>",
+      "</plist>",
+      ""
+    ].join("\n");
+    fs2.writeFileSync(shortcutPath, content);
+  } else {
+    const content = [
+      "[Desktop Entry]",
+      "Version=1.1",
+      "Type=Link",
+      "Name=Claude Dashboard",
+      `URL=${url}`,
+      "Icon=text-html",
+      ""
+    ].join("\n");
+    fs2.writeFileSync(shortcutPath, content);
+  }
+  console.log(`  Shortcut:      ${shortcutPath}`);
+}
+function removeShortcuts() {
+  const shortcutPath = getShortcutPath();
+  if (!shortcutPath) return;
+  try {
+    fs2.unlinkSync(shortcutPath);
+  } catch {
+  }
+}
+function getProtocolDesktopPath() {
+  return path2.join(
+    os2.homedir(),
+    ".local",
+    "share",
+    "applications",
+    "claude-dashboard-handler.desktop"
+  );
+}
+function registerProtocol(port) {
+  const platform = process.platform;
+  const url = `http://localhost:${port}`;
+  try {
+    if (platform === "win32") {
+      const regBase = `HKCU\\Software\\Classes\\${PROTOCOL_SCHEME}`;
+      execSync(`reg add "${regBase}" /ve /d "URL:Claude Dashboard" /f`, { stdio: "ignore" });
+      execSync(`reg add "${regBase}" /v "URL Protocol" /d "" /f`, { stdio: "ignore" });
+      execSync(`reg add "${regBase}\\shell\\open\\command" /ve /d "cmd /c start ${url}" /f`, {
+        stdio: "ignore"
+      });
+    } else if (platform === "darwin") {
+      const appDir = path2.join(
+        os2.homedir(),
+        "Applications",
+        "Claude Dashboard Protocol.app",
+        "Contents"
+      );
+      const macOSDir = path2.join(appDir, "MacOS");
+      fs2.mkdirSync(macOSDir, { recursive: true });
+      const infoPlist = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        "<dict>",
+        "	<key>CFBundleIdentifier</key>",
+        "	<string>com.claude-dashboard.protocol</string>",
+        "	<key>CFBundleName</key>",
+        "	<string>Claude Dashboard Protocol</string>",
+        "	<key>CFBundleExecutable</key>",
+        "	<string>open-dashboard</string>",
+        "	<key>CFBundleURLTypes</key>",
+        "	<array>",
+        "		<dict>",
+        "			<key>CFBundleURLName</key>",
+        "			<string>Claude Dashboard</string>",
+        "			<key>CFBundleURLSchemes</key>",
+        "			<array>",
+        `				<string>${PROTOCOL_SCHEME}</string>`,
+        "			</array>",
+        "		</dict>",
+        "	</array>",
+        "</dict>",
+        "</plist>",
+        ""
+      ].join("\n");
+      fs2.writeFileSync(path2.join(appDir, "Info.plist"), infoPlist);
+      const launchScript = `#!/bin/sh
+open "${url}"
+`;
+      const scriptPath = path2.join(macOSDir, "open-dashboard");
+      fs2.writeFileSync(scriptPath, launchScript, { mode: 493 });
+      try {
+        execSync(
+          `/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -R "${path2.dirname(appDir)}"`,
+          { stdio: "ignore" }
+        );
+      } catch {
+      }
+    } else {
+      const desktopPath = getProtocolDesktopPath();
+      fs2.mkdirSync(path2.dirname(desktopPath), { recursive: true });
+      const content = [
+        "[Desktop Entry]",
+        "Version=1.1",
+        "Type=Application",
+        "Name=Claude Dashboard Protocol Handler",
+        `Exec=xdg-open ${url}`,
+        `MimeType=x-scheme-handler/${PROTOCOL_SCHEME};`,
+        "NoDisplay=true",
+        ""
+      ].join("\n");
+      fs2.writeFileSync(desktopPath, content);
+      try {
+        execSync(
+          `xdg-mime default claude-dashboard-handler.desktop x-scheme-handler/${PROTOCOL_SCHEME}`,
+          { stdio: "ignore" }
+        );
+      } catch {
+      }
+    }
+  } catch {
+  }
+  console.log(`  Protocol:      ${PROTOCOL_SCHEME}:// registered`);
+}
+function unregisterProtocol() {
+  const platform = process.platform;
+  try {
+    if (platform === "win32") {
+      execSync(`reg delete "HKCU\\Software\\Classes\\${PROTOCOL_SCHEME}" /f`, { stdio: "ignore" });
+    } else if (platform === "darwin") {
+      const appDir = path2.join(os2.homedir(), "Applications", "Claude Dashboard Protocol.app");
+      fs2.rmSync(appDir, { recursive: true, force: true });
+    } else {
+      const desktopPath = getProtocolDesktopPath();
+      try {
+        fs2.unlinkSync(desktopPath);
+      } catch {
+      }
+      try {
+        execSync("update-desktop-database ~/.local/share/applications/", {
+          stdio: "ignore"
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function install(port) {
+  fs2.mkdirSync(SERVER_DIR, { recursive: true });
+  fs2.mkdirSync(BIN_DIR, { recursive: true });
+  const bundleSrc = getThisBundle();
+  const bundleDest = path2.join(SERVER_DIR, "bin.js");
+  fs2.copyFileSync(bundleSrc, bundleDest);
+  fs2.writeFileSync(CONFIG_PATH, `${JSON.stringify({ port, serverEntry: bundleDest }, null, 2)}
+`);
+  writeHookScript(port, bundleDest);
+  const command = `node ${JSON.stringify(HOOK_SCRIPT_PATH)}`;
+  installHooksWithCommand(command);
+  console.log("Dashboard installed successfully!");
+  console.log(`  Server bundle: ${bundleDest}`);
+  console.log(`  Hook script:   ${HOOK_SCRIPT_PATH}`);
+  console.log(`  Config:        ${CONFIG_PATH}`);
+  console.log(`  Port:          ${port}`);
+  createShortcuts(port);
+  registerProtocol(port);
+  console.log("");
+  console.log("The dashboard will auto-launch when a Claude Code session starts.");
+  console.log(
+    `You can also open it via the shortcut or by typing "${PROTOCOL_SCHEME}://" in your browser.`
+  );
+  console.log("To uninstall: npx @kosinal/claude-code-dashboard uninstall");
+}
+function uninstall() {
+  removeHooks();
+  removeShortcuts();
+  unregisterProtocol();
+  try {
+    fs2.rmSync(DASHBOARD_DIR, { recursive: true, force: true });
+  } catch {
+  }
+  try {
+    fs2.unlinkSync(HOOK_SCRIPT_PATH);
+  } catch {
+  }
+  console.log("Dashboard uninstalled successfully.");
+  console.log("  Shortcut removed, protocol handler unregistered.");
+}
+function writeLockFile(port) {
+  fs2.mkdirSync(DASHBOARD_DIR, { recursive: true });
+  fs2.writeFileSync(LOCK_PATH, `${process.pid}:${port}`);
+}
+function readLockFile() {
+  try {
+    const content = fs2.readFileSync(LOCK_PATH, "utf-8").trim();
+    const parts = content.split(":");
+    const pid = parseInt(parts[0], 10);
+    const port = parts.length > 1 ? parseInt(parts[1], 10) : NaN;
+    if (Number.isNaN(pid) || Number.isNaN(port)) return null;
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ESRCH") {
+        try {
+          fs2.unlinkSync(LOCK_PATH);
+        } catch {
         }
+        return null;
       }
-      return removed;
     }
-  };
+    return { pid, port };
+  } catch {
+    try {
+      fs2.unlinkSync(LOCK_PATH);
+    } catch {
+    }
+    return null;
+  }
+}
+function removeLockFile() {
+  try {
+    fs2.unlinkSync(LOCK_PATH);
+  } catch {
+  }
 }
 
 // src/server.ts
@@ -462,686 +957,451 @@ function getDashboardHtml() {
   </div>
 </header>
 <div id="overlayContainer"></div>
-<main id="app">
-  <div class="empty-state">
-    <h2>No sessions yet</h2>
-    <p>Start a Claude Code session and it will appear here.<br>
-    Sessions already running when the dashboard started won't be tracked.</p>
-  </div>
-</main>
-<footer>
-  <button id="btnRestart" disabled>Restart</button>
-  <button id="btnStop" class="btn-danger" disabled>Stop</button>
-</footer>
-<script>
-(function() {
-  var app = document.getElementById('app');
-  var connDot = document.getElementById('connDot');
-  var connLabel = document.getElementById('connLabel');
-  var overlayContainer = document.getElementById('overlayContainer');
-  var btnStop = document.getElementById('btnStop');
-  var btnRestart = document.getElementById('btnRestart');
-  var notifToggle = document.getElementById('notifToggle');
-  var notificationsEnabled = localStorage.getItem('notificationsEnabled') !== 'false';
-  var sessions = [];
-  var previousStatuses = {};
-  var initialized = false;
-  var es = null;
-
-  notifToggle.checked = notificationsEnabled;
-  notifToggle.addEventListener('change', function() {
-    notificationsEnabled = notifToggle.checked;
-    localStorage.setItem('notificationsEnabled', notificationsEnabled ? 'true' : 'false');
-    if (notificationsEnabled && 'Notification' in window && Notification.permission === 'default') {
-      Notification.requestPermission();
-    }
-  });
-
-  if (notificationsEnabled && 'Notification' in window && Notification.permission === 'default') {
-    Notification.requestPermission();
-  }
-
-  var STATUS_LABELS = { running: 'Running', waiting: 'Waiting for input', done: 'Done' };
-  var STATUS_ORDER = { running: 0, waiting: 1, done: 2 };
-
-  function timeAgo(ts) {
-    var diff = Math.floor((Date.now() - ts) / 1000);
-    if (diff < 5) return 'just now';
-    if (diff < 60) return diff + 's ago';
-    if (diff < 3600) return Math.floor(diff / 60) + 'm ago';
-    if (diff < 86400) return Math.floor(diff / 3600) + 'h ago';
-    return Math.floor(diff / 86400) + 'd ago';
-  }
-
-  function folderName(cwd) {
-    if (!cwd) return 'Unknown';
-    var parts = cwd.replace(/\\\\/g, '/').split('/');
-    return parts[parts.length - 1] || parts[parts.length - 2] || cwd;
-  }
-
-  function shortId(id) {
-    if (!id) return '';
-    return id.length > 12 ? id.slice(0, 8) + '...' : id;
-  }
-
-  function render() {
-    if (sessions.length === 0) {
-      app.innerHTML = '<div class="empty-state"><h2>No sessions yet</h2>' +
-        '<p>Start a Claude Code session and it will appear here.<br>' +
-        'Sessions already running when the dashboard started won\\'t be tracked.</p></div>';
-      return;
-    }
-
-    var sorted = sessions.slice().sort(function(a, b) {
-      var od = STATUS_ORDER[a.status] - STATUS_ORDER[b.status];
-      if (od !== 0) return od;
-      return b.updatedAt - a.updatedAt;
-    });
-
-    app.innerHTML = '<div class="sessions-grid">' + sorted.map(function(s) {
-      return '<div class="session-card status-' + s.status + '">' +
-        '<div class="card-header">' +
-          '<span class="project-name" title="' + esc(s.cwd) + '">' + esc(folderName(s.cwd)) + '</span>' +
-          '<span class="status-badge"><span class="status-dot"></span>' + STATUS_LABELS[s.status] + '</span>' +
-        '</div>' +
-        '<div class="card-details">' +
-          '<div class="detail-row"><span class="detail-label">Session</span>' +
-            '<span class="detail-value session-id-short" title="' + esc(s.sessionId) + '">' + esc(shortId(s.sessionId)) + '</span></div>' +
-          '<div class="detail-row"><span class="detail-label">Path</span>' +
-            '<span class="detail-value" title="' + esc(s.cwd) + '">' + esc(s.cwd) + '</span></div>' +
-          '<div class="detail-row"><span class="detail-label">Event</span>' +
-            '<span class="detail-value">' + esc(s.lastEvent) + ' &middot; ' + timeAgo(s.updatedAt) + '</span></div>' +
-        '</div>' +
-      '</div>';
-    }).join('') + '</div>';
-  }
-
-  function esc(str) {
-    if (!str) return '';
-    return str.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
-  }
-
-  function checkAndNotify(newSessions) {
-    if (!initialized) {
-      initialized = true;
-      newSessions.forEach(function(s) { previousStatuses[s.sessionId] = s.status; });
-      return;
-    }
-    if (notificationsEnabled && 'Notification' in window && Notification.permission === 'granted') {
-      newSessions.forEach(function(s) {
-        if (s.status === 'waiting' && previousStatuses[s.sessionId] !== 'waiting') {
-          new Notification('Claude Code - Waiting for input', {
-            body: folderName(s.cwd),
-            tag: 'claude-waiting-' + s.sessionId
-          });
-        }
-      });
-    }
-    previousStatuses = {};
-    newSessions.forEach(function(s) { previousStatuses[s.sessionId] = s.status; });
-  }
-
-  function setButtonsEnabled(enabled) {
-    btnStop.disabled = !enabled;
-    btnRestart.disabled = !enabled;
-  }
-
-  function clearOverlay() {
-    overlayContainer.innerHTML = '';
-  }
-
-  function showOverlay(title, message) {
-    overlayContainer.innerHTML =
-      '<div class="overlay"><div class="overlay-card">' +
-        '<h2>' + esc(title) + '</h2>' +
-        '<p>' + esc(message) + '</p>' +
-      '</div></div>';
-  }
-
-  function showConfirm(title, message, label, isDanger, onConfirm) {
-    var btnClass = isDanger ? 'btn-confirm-danger' : 'btn-confirm';
-    overlayContainer.innerHTML =
-      '<div class="overlay"><div class="overlay-card">' +
-        '<h2>' + esc(title) + '</h2>' +
-        '<p>' + esc(message) + '</p>' +
-        '<div class="overlay-actions">' +
-          '<button class="btn-cancel" id="overlayCancel">Cancel</button>' +
-          '<button class="' + btnClass + '" id="overlayConfirm">' + esc(label) + '</button>' +
-        '</div>' +
-      '</div></div>';
-    document.getElementById('overlayCancel').onclick = clearOverlay;
-    document.getElementById('overlayConfirm').onclick = function() {
-      onConfirm();
-    };
-  }
-
-  function attemptReconnect() {
-    var attempts = 0;
-    var maxAttempts = 30;
-    var timer = setInterval(function() {
-      attempts++;
-      if (attempts > maxAttempts) {
-        clearInterval(timer);
-        showOverlay('Connection Lost', 'Could not reconnect to the dashboard server.');
-        return;
-      }
-      var req = new XMLHttpRequest();
-      req.open('GET', '/api/sessions', true);
-      req.timeout = 2000;
-      req.onload = function() {
-        if (req.status === 200) {
-          clearInterval(timer);
-          clearOverlay();
-          connect();
-        }
-      };
-      req.onerror = function() {};
-      req.ontimeout = function() {};
-      req.send();
-    }, 1000);
-  }
-
-  btnStop.onclick = function() {
-    showConfirm('Stop Dashboard', 'Are you sure you want to stop the dashboard server?', 'Stop', true, function() {
-      showOverlay('Stopping...', 'Shutting down the dashboard server.');
-      setButtonsEnabled(false);
-      var req = new XMLHttpRequest();
-      req.open('POST', '/api/shutdown', true);
-      req.onload = function() {
-        showOverlay('Server Stopped', 'The dashboard server has been shut down.');
-      };
-      req.onerror = function() {
-        showOverlay('Server Stopped', 'The dashboard server has been shut down.');
-      };
-      req.send();
-    });
-  };
-
-  btnRestart.onclick = function() {
-    showConfirm('Restart Dashboard', 'Are you sure you want to restart the dashboard server?', 'Restart', false, function() {
-      showOverlay('Restarting...', 'The dashboard server is restarting. Reconnecting automatically...');
-      setButtonsEnabled(false);
-      var req = new XMLHttpRequest();
-      req.open('POST', '/api/restart', true);
-      req.onload = function() {};
-      req.onerror = function() {};
-      req.send();
-    });
-  };
-
-  function connect() {
-    if (es) {
-      es.close();
-      es = null;
-    }
-
-    es = new EventSource('/api/events');
-
-    es.addEventListener('init', function(e) {
-      sessions = JSON.parse(e.data);
-      checkAndNotify(sessions);
-      render();
-    });
-
-    es.addEventListener('update', function(e) {
-      sessions = JSON.parse(e.data);
-      checkAndNotify(sessions);
-      render();
-    });
-
-    es.addEventListener('shutdown', function() {
-      if (es) { es.close(); es = null; }
-      setButtonsEnabled(false);
-      showOverlay('Server Stopped', 'The dashboard server has been shut down.');
-    });
-
-    es.addEventListener('restart', function() {
-      if (es) { es.close(); es = null; }
-      setButtonsEnabled(false);
-      showOverlay('Restarting...', 'The dashboard server is restarting. Reconnecting automatically...');
-      attemptReconnect();
-    });
+<main id="app">
+  <div class="empty-state">
+    <h2>No sessions yet</h2>
+    <p>Start a Claude Code session and it will appear here.<br>
+    Sessions already running when the dashboard started won't be tracked.</p>
+  </div>
+</main>
+<footer>
+  <button id="btnRestart" disabled>Restart</button>
+  <button id="btnStop" class="btn-danger" disabled>Stop</button>
+</footer>
+<script>
+(function() {
+  var app = document.getElementById('app');
+  var connDot = document.getElementById('connDot');
+  var connLabel = document.getElementById('connLabel');
+  var overlayContainer = document.getElementById('overlayContainer');
+  var btnStop = document.getElementById('btnStop');
+  var btnRestart = document.getElementById('btnRestart');
+  var notifToggle = document.getElementById('notifToggle');
+  var notificationsEnabled = localStorage.getItem('notificationsEnabled') !== 'false';
+  var sessions = [];
+  var previousStatuses = {};
+  var initialized = false;
+  var es = null;
 
-    es.onopen = function() {
-      connDot.classList.add('connected');
-      connLabel.textContent = 'Connected';
-      setButtonsEnabled(true);
-    };
+  notifToggle.checked = notificationsEnabled;
+  notifToggle.addEventListener('change', function() {
+    notificationsEnabled = notifToggle.checked;
+    localStorage.setItem('notificationsEnabled', notificationsEnabled ? 'true' : 'false');
+    if (notificationsEnabled && 'Notification' in window && Notification.permission === 'default') {
+      Notification.requestPermission();
+    }
+  });
 
-    es.onerror = function() {
-      connDot.classList.remove('connected');
-      connLabel.textContent = 'Disconnected';
-      setButtonsEnabled(false);
-    };
+  if (notificationsEnabled && 'Notification' in window && Notification.permission === 'default') {
+    Notification.requestPermission();
   }
 
-  // Update time-ago values every 10 seconds
-  setInterval(render, 10000);
-
-  connect();
-})();
-</script>
-</body>
-</html>`;
-}
+  var STATUS_LABELS = { running: 'Running', waiting: 'Waiting for input', done: 'Done' };
+  var STATUS_ORDER = { running: 0, waiting: 1, done: 2 };
 
-// src/server.ts
-function createServer2(options) {
-  const { store, onShutdown, onRestart } = options;
-  const idleTimeoutMs = options.idleTimeoutMs ?? 5 * 60 * 1e3;
-  const cleanupIntervalMs = options.cleanupIntervalMs ?? 6e4;
-  const sseClients = /* @__PURE__ */ new Set();
-  function broadcastEvent(event, data) {
-    for (const res of sseClients) {
-      res.write(`event: ${event}
-data: ${data}
+  function timeAgo(ts) {
+    var diff = Math.floor((Date.now() - ts) / 1000);
+    if (diff < 5) return 'just now';
+    if (diff < 60) return diff + 's ago';
+    if (diff < 3600) return Math.floor(diff / 60) + 'm ago';
+    if (diff < 86400) return Math.floor(diff / 3600) + 'h ago';
+    return Math.floor(diff / 86400) + 'd ago';
+  }
 
-`);
-    }
+  function folderName(cwd) {
+    if (!cwd) return 'Unknown';
+    var parts = cwd.replace(/\\\\/g, '/').split('/');
+    return parts[parts.length - 1] || parts[parts.length - 2] || cwd;
   }
-  function broadcast() {
-    broadcastEvent("update", JSON.stringify(store.getAllSessions()));
+
+  function shortId(id) {
+    if (!id) return '';
+    return id.length > 12 ? id.slice(0, 8) + '...' : id;
   }
-  const server = http.createServer((req, res) => {
-    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-    const pathname = url.pathname;
-    if (req.method === "GET" && pathname === "/") {
-      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      res.end(getDashboardHtml());
-      return;
-    }
-    if (req.method === "POST" && pathname === "/api/hook") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk.toString();
-      });
-      req.on("end", () => {
-        try {
-          const payload = JSON.parse(body);
-          if (!payload.session_id || !payload.hook_event_name) {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Missing session_id or hook_event_name" }));
-            return;
-          }
-          store.handleEvent(payload);
-          broadcast();
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true }));
-        } catch {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Invalid JSON" }));
-        }
-      });
-      return;
-    }
-    if (req.method === "GET" && pathname === "/api/events") {
-      res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      });
-      const initData = JSON.stringify(store.getAllSessions());
-      res.write(`event: init
-data: ${initData}
 
-`);
-      sseClients.add(res);
-      req.on("close", () => {
-        sseClients.delete(res);
-      });
-      return;
-    }
-    if (req.method === "GET" && pathname === "/api/sessions") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(store.getAllSessions()));
-      return;
-    }
-    if (req.method === "POST" && pathname === "/api/shutdown") {
-      broadcastEvent("shutdown", JSON.stringify({ ok: true }));
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true }));
-      if (onShutdown) setImmediate(() => onShutdown());
-      return;
-    }
-    if (req.method === "POST" && pathname === "/api/restart") {
-      broadcastEvent("restart", JSON.stringify({ ok: true }));
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true }));
-      if (onRestart) setImmediate(() => onRestart());
+  function render() {
+    if (sessions.length === 0) {
+      app.innerHTML = '<div class="empty-state"><h2>No sessions yet</h2>' +
+        '<p>Start a Claude Code session and it will appear here.<br>' +
+        'Sessions already running when the dashboard started won\\'t be tracked.</p></div>';
       return;
     }
-    res.writeHead(404, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: "Not found" }));
-  });
-  const cleanupTimer = setInterval(() => {
-    const removed = store.cleanIdleSessions(idleTimeoutMs);
-    if (removed.length > 0) broadcast();
-  }, cleanupIntervalMs);
-  cleanupTimer.unref();
-  return {
-    server,
-    listen(port, callback) {
-      server.listen(port, "127.0.0.1", callback);
-    },
-    close() {
-      clearInterval(cleanupTimer);
-      for (const res of sseClients) {
-        res.end();
-      }
-      sseClients.clear();
-      return new Promise((resolve, reject) => {
-        server.close((err) => err ? reject(err) : resolve());
-      });
-    }
-  };
-}
 
-// src/hooks.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-var MARKER = "__claude_code_dashboard__";
-var HOOK_EVENTS = [
-  "SessionStart",
-  "UserPromptSubmit",
-  "Stop",
-  "SessionEnd"
-];
-function getConfigDir(configDir) {
-  return configDir ?? path.join(os.homedir(), ".claude");
-}
-function getSettingsPath(configDir) {
-  return path.join(getConfigDir(configDir), "settings.json");
-}
-function readSettings(configDir) {
-  const settingsPath = getSettingsPath(configDir);
-  try {
-    const content = fs.readFileSync(settingsPath, "utf-8");
-    const parsed = JSON.parse(content);
-    return parsed;
-  } catch (err) {
-    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      return {};
-    }
-    try {
-      fs.copyFileSync(settingsPath, settingsPath + ".bak");
-      console.warn(
-        `Warning: Invalid settings.json backed up to ${settingsPath}.bak`
-      );
-    } catch {
-    }
-    return {};
-  }
-}
-function writeSettings(settings, configDir) {
-  const settingsPath = getSettingsPath(configDir);
-  const dir = path.dirname(settingsPath);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-}
-function backupSettings(configDir) {
-  const settingsPath = getSettingsPath(configDir);
-  const backupPath = settingsPath.replace(/\.json$/, ".pre-dashboard.json");
-  try {
-    fs.copyFileSync(settingsPath, backupPath);
-  } catch {
-  }
-}
-function installHooks(port, configDir) {
-  const settings = readSettings(configDir);
-  backupSettings(configDir);
-  removeHooksFromSettings(settings);
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  for (const event of HOOK_EVENTS) {
-    if (!settings.hooks[event]) {
-      settings.hooks[event] = [];
-    }
-    const command = process.platform === "win32" ? `powershell -NoProfile -Command "$input | Invoke-WebRequest -Uri http://localhost:${port}/api/hook -Method POST -ContentType 'application/json' -ErrorAction SilentlyContinue | Out-Null"` : `curl -s -X POST -H "Content-Type: application/json" -d @- http://localhost:${port}/api/hook > /dev/null 2>&1`;
-    settings.hooks[event].push({
-      hooks: [{
-        type: "command",
-        command,
-        async: true,
-        statusMessage: MARKER
-      }]
+    var sorted = sessions.slice().sort(function(a, b) {
+      var od = STATUS_ORDER[a.status] - STATUS_ORDER[b.status];
+      if (od !== 0) return od;
+      return b.updatedAt - a.updatedAt;
     });
+
+    app.innerHTML = '<div class="sessions-grid">' + sorted.map(function(s) {
+      return '<div class="session-card status-' + s.status + '">' +
+        '<div class="card-header">' +
+          '<span class="project-name" title="' + esc(s.cwd) + '">' + esc(folderName(s.cwd)) + '</span>' +
+          '<span class="status-badge"><span class="status-dot"></span>' + STATUS_LABELS[s.status] + '</span>' +
+        '</div>' +
+        '<div class="card-details">' +
+          '<div class="detail-row"><span class="detail-label">Session</span>' +
+            '<span class="detail-value session-id-short" title="' + esc(s.sessionId) + '">' + esc(shortId(s.sessionId)) + '</span></div>' +
+          '<div class="detail-row"><span class="detail-label">Path</span>' +
+            '<span class="detail-value" title="' + esc(s.cwd) + '">' + esc(s.cwd) + '</span></div>' +
+          '<div class="detail-row"><span class="detail-label">Event</span>' +
+            '<span class="detail-value">' + esc(s.lastEvent) + ' &middot; ' + timeAgo(s.updatedAt) + '</span></div>' +
+        '</div>' +
+      '</div>';
+    }).join('') + '</div>';
   }
-  writeSettings(settings, configDir);
-}
-function installHooksWithCommand(command, configDir) {
-  const settings = readSettings(configDir);
-  backupSettings(configDir);
-  removeHooksFromSettings(settings);
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  for (const event of HOOK_EVENTS) {
-    if (!settings.hooks[event]) {
-      settings.hooks[event] = [];
-    }
-    settings.hooks[event].push({
-      hooks: [{
-        type: "command",
-        command,
-        async: true,
-        statusMessage: MARKER
-      }]
-    });
+
+  function esc(str) {
+    if (!str) return '';
+    return str.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
   }
-  writeSettings(settings, configDir);
-}
-function removeHooksFromSettings(settings) {
-  if (!settings.hooks) return;
-  for (const event of HOOK_EVENTS) {
-    const groups = settings.hooks[event];
-    if (!groups) continue;
-    const filtered = [];
-    for (const group of groups) {
-      const kept = group.hooks.filter((h) => h.statusMessage !== MARKER);
-      if (kept.length > 0) {
-        filtered.push({ ...group, hooks: kept });
-      }
+
+  function checkAndNotify(newSessions) {
+    if (!initialized) {
+      initialized = true;
+      newSessions.forEach(function(s) { previousStatuses[s.sessionId] = s.status; });
+      return;
     }
-    if (filtered.length > 0) {
-      settings.hooks[event] = filtered;
-    } else {
-      delete settings.hooks[event];
+    if (notificationsEnabled && 'Notification' in window && Notification.permission === 'granted') {
+      newSessions.forEach(function(s) {
+        if (s.status === 'waiting' && previousStatuses[s.sessionId] !== 'waiting') {
+          new Notification('Claude Code - Waiting for input', {
+            body: folderName(s.cwd),
+            tag: 'claude-waiting-' + s.sessionId
+          });
+        }
+      });
     }
+    previousStatuses = {};
+    newSessions.forEach(function(s) { previousStatuses[s.sessionId] = s.status; });
   }
-  if (Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
+
+  function setButtonsEnabled(enabled) {
+    btnStop.disabled = !enabled;
+    btnRestart.disabled = !enabled;
   }
-}
-function removeHooks(configDir) {
-  const settingsPath = getSettingsPath(configDir);
-  try {
-    fs.accessSync(settingsPath);
-  } catch {
-    return;
+
+  function clearOverlay() {
+    overlayContainer.innerHTML = '';
   }
-  const settings = readSettings(configDir);
-  removeHooksFromSettings(settings);
-  writeSettings(settings, configDir);
-}
 
-// src/installer.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-var DASHBOARD_DIR = path2.join(os2.homedir(), ".claude", "dashboard");
-var BIN_DIR = path2.join(os2.homedir(), ".claude", "bin");
-var CONFIG_PATH = path2.join(DASHBOARD_DIR, "config.json");
-var SERVER_DIR = path2.join(DASHBOARD_DIR, "server");
-var HOOK_SCRIPT_PATH = path2.join(BIN_DIR, "claude-dashboard-hook.mjs");
-var LOCK_PATH = path2.join(DASHBOARD_DIR, "dashboard.lock");
-function getThisBundle() {
-  return process.argv[1] ?? __filename;
-}
-function writeHookScript(port, serverEntry) {
-  const script = `#!/usr/bin/env node
-// Auto-generated by claude-code-dashboard install
-import { readFileSync, existsSync, writeFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { request } from 'node:http';
-import { openSync } from 'node:fs';
+  function showOverlay(title, message) {
+    overlayContainer.innerHTML =
+      '<div class="overlay"><div class="overlay-card">' +
+        '<h2>' + esc(title) + '</h2>' +
+        '<p>' + esc(message) + '</p>' +
+      '</div></div>';
+  }
 
-const CONFIG_PATH = ${JSON.stringify(CONFIG_PATH)};
-const LOCK_PATH = ${JSON.stringify(LOCK_PATH)};
+  function showConfirm(title, message, label, isDanger, onConfirm) {
+    var btnClass = isDanger ? 'btn-confirm-danger' : 'btn-confirm';
+    overlayContainer.innerHTML =
+      '<div class="overlay"><div class="overlay-card">' +
+        '<h2>' + esc(title) + '</h2>' +
+        '<p>' + esc(message) + '</p>' +
+        '<div class="overlay-actions">' +
+          '<button class="btn-cancel" id="overlayCancel">Cancel</button>' +
+          '<button class="' + btnClass + '" id="overlayConfirm">' + esc(label) + '</button>' +
+        '</div>' +
+      '</div></div>';
+    document.getElementById('overlayCancel').onclick = clearOverlay;
+    document.getElementById('overlayConfirm').onclick = function() {
+      onConfirm();
+    };
+  }
 
-let config;
-try {
-  config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
-} catch {
-  process.exit(0); // Config missing \u2014 probably uninstalled
-}
+  function attemptReconnect() {
+    var attempts = 0;
+    var maxAttempts = 30;
+    var timer = setInterval(function() {
+      attempts++;
+      if (attempts > maxAttempts) {
+        clearInterval(timer);
+        showOverlay('Connection Lost', 'Could not reconnect to the dashboard server.');
+        return;
+      }
+      var req = new XMLHttpRequest();
+      req.open('GET', '/api/sessions', true);
+      req.timeout = 2000;
+      req.onload = function() {
+        if (req.status === 200) {
+          clearInterval(timer);
+          clearOverlay();
+          connect();
+        }
+      };
+      req.onerror = function() {};
+      req.ontimeout = function() {};
+      req.send();
+    }, 1000);
+  }
 
-const { port, serverEntry } = config;
-const stdin = readFileSync(0, 'utf-8');
+  btnStop.onclick = function() {
+    showConfirm('Stop Dashboard', 'Are you sure you want to stop the dashboard server?', 'Stop', true, function() {
+      showOverlay('Stopping...', 'Shutting down the dashboard server.');
+      setButtonsEnabled(false);
+      var req = new XMLHttpRequest();
+      req.open('POST', '/api/shutdown', true);
+      req.onload = function() {
+        showOverlay('Server Stopped', 'The dashboard server has been shut down.');
+      };
+      req.onerror = function() {
+        showOverlay('Server Stopped', 'The dashboard server has been shut down.');
+      };
+      req.send();
+    });
+  };
 
-function postHook(data) {
-  return new Promise((resolve, reject) => {
-    const req = request({
-      hostname: '127.0.0.1',
-      port,
-      path: '/api/hook',
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      timeout: 5000,
-    }, (res) => {
-      res.resume();
-      resolve(res.statusCode);
+  btnRestart.onclick = function() {
+    showConfirm('Restart Dashboard', 'Are you sure you want to restart the dashboard server?', 'Restart', false, function() {
+      showOverlay('Restarting...', 'The dashboard server is restarting. Reconnecting automatically...');
+      setButtonsEnabled(false);
+      var req = new XMLHttpRequest();
+      req.open('POST', '/api/restart', true);
+      req.onload = function() {};
+      req.onerror = function() {};
+      req.send();
     });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
-    req.write(data);
-    req.end();
-  });
-}
+  };
 
-function isServerRunning() {
-  try {
-    if (!existsSync(LOCK_PATH)) return false;
-    const pid = parseInt(readFileSync(LOCK_PATH, 'utf-8').trim().split(':')[0], 10);
-    if (isNaN(pid)) return false;
-    process.kill(pid, 0); // Check if process exists
-    return true;
-  } catch {
-    return false;
+  function connect() {
+    if (es) {
+      es.close();
+      es = null;
+    }
+
+    es = new EventSource('/api/events');
+
+    es.addEventListener('init', function(e) {
+      sessions = JSON.parse(e.data);
+      checkAndNotify(sessions);
+      render();
+    });
+
+    es.addEventListener('update', function(e) {
+      sessions = JSON.parse(e.data);
+      checkAndNotify(sessions);
+      render();
+    });
+
+    es.addEventListener('shutdown', function() {
+      if (es) { es.close(); es = null; }
+      setButtonsEnabled(false);
+      showOverlay('Server Stopped', 'The dashboard server has been shut down.');
+    });
+
+    es.addEventListener('restart', function() {
+      if (es) { es.close(); es = null; }
+      setButtonsEnabled(false);
+      showOverlay('Restarting...', 'The dashboard server is restarting. Reconnecting automatically...');
+      attemptReconnect();
+    });
+
+    es.onopen = function() {
+      connDot.classList.add('connected');
+      connLabel.textContent = 'Connected';
+      setButtonsEnabled(true);
+    };
+
+    es.onerror = function() {
+      connDot.classList.remove('connected');
+      connLabel.textContent = 'Disconnected';
+      setButtonsEnabled(false);
+    };
   }
-}
 
-function startServer() {
-  const logPath = ${JSON.stringify(path2.join(DASHBOARD_DIR, "server.log"))};
-  const logFd = openSync(logPath, 'a');
-  const child = spawn(process.execPath, [serverEntry, '--no-hooks', '--no-open', '--port', String(port)], {
-    detached: true,
-    stdio: ['ignore', logFd, logFd],
-    env: { ...process.env },
-  });
-  child.unref();
+  // Update time-ago values every 10 seconds
+  setInterval(render, 10000);
+
+  connect();
+})();
+</script>
+</body>
+</html>`;
 }
 
-async function waitForServer(maxWaitMs = 10000) {
-  const start = Date.now();
-  let delay = 100;
-  while (Date.now() - start < maxWaitMs) {
-    try {
-      await postHook('{"session_id":"ping","hook_event_name":"Ping"}');
-      return true;
-    } catch {
-      await new Promise(r => setTimeout(r, delay));
-      delay = Math.min(delay * 1.5, 1000);
+// src/server.ts
+function createServer2(options) {
+  const { store, onShutdown, onRestart } = options;
+  const idleTimeoutMs = options.idleTimeoutMs ?? 5 * 60 * 1e3;
+  const cleanupIntervalMs = options.cleanupIntervalMs ?? 6e4;
+  const sseClients = /* @__PURE__ */ new Set();
+  function broadcastEvent(event, data) {
+    for (const res of sseClients) {
+      res.write(`event: ${event}
+data: ${data}
+
+`);
     }
   }
-  return false;
-}
+  function broadcast() {
+    broadcastEvent("update", JSON.stringify(store.getAllSessions()));
+  }
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    if (req.method === "GET" && pathname === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(getDashboardHtml());
+      return;
+    }
+    if (req.method === "POST" && pathname === "/api/hook") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", () => {
+        try {
+          const payload = JSON.parse(body);
+          if (!payload.session_id || !payload.hook_event_name) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Missing session_id or hook_event_name" }));
+            return;
+          }
+          store.handleEvent(payload);
+          broadcast();
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+        }
+      });
+      return;
+    }
+    if (req.method === "GET" && pathname === "/api/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      const initData = JSON.stringify(store.getAllSessions());
+      res.write(`event: init
+data: ${initData}
 
-async function main() {
-  try {
-    await postHook(stdin);
-  } catch {
-    // Server not running \u2014 try to start it
-    if (!isServerRunning()) {
-      startServer();
+`);
+      sseClients.add(res);
+      req.on("close", () => {
+        sseClients.delete(res);
+      });
+      return;
     }
-    const ready = await waitForServer();
-    if (ready) {
-      try { await postHook(stdin); } catch { /* give up */ }
+    if (req.method === "GET" && pathname === "/api/sessions") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(store.getAllSessions()));
+      return;
     }
-  }
+    if (req.method === "POST" && pathname === "/api/shutdown") {
+      broadcastEvent("shutdown", JSON.stringify({ ok: true }));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+      if (onShutdown) setImmediate(() => onShutdown());
+      return;
+    }
+    if (req.method === "POST" && pathname === "/api/restart") {
+      broadcastEvent("restart", JSON.stringify({ ok: true }));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+      if (onRestart) setImmediate(() => onRestart());
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  const cleanupTimer = setInterval(() => {
+    const removed = store.cleanIdleSessions(idleTimeoutMs);
+    if (removed.length > 0) broadcast();
+  }, cleanupIntervalMs);
+  cleanupTimer.unref();
+  return {
+    server,
+    listen(port, callback) {
+      server.listen(port, "127.0.0.1", callback);
+    },
+    close() {
+      clearInterval(cleanupTimer);
+      for (const res of sseClients) {
+        res.end();
+      }
+      sseClients.clear();
+      return new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+      });
+    }
+  };
 }
 
-main().catch(() => {});
-`;
-  fs2.mkdirSync(path2.dirname(HOOK_SCRIPT_PATH), { recursive: true });
-  fs2.writeFileSync(HOOK_SCRIPT_PATH, script);
-}
-function install(port) {
-  fs2.mkdirSync(SERVER_DIR, { recursive: true });
-  fs2.mkdirSync(BIN_DIR, { recursive: true });
-  const bundleSrc = getThisBundle();
-  const bundleDest = path2.join(SERVER_DIR, "bin.js");
-  fs2.copyFileSync(bundleSrc, bundleDest);
-  fs2.writeFileSync(
-    CONFIG_PATH,
-    JSON.stringify({ port, serverEntry: bundleDest }, null, 2) + "\n"
-  );
-  writeHookScript(port, bundleDest);
-  const command = `node ${JSON.stringify(HOOK_SCRIPT_PATH)}`;
-  installHooksWithCommand(command);
-  console.log("Dashboard installed successfully!");
-  console.log(`  Server bundle: ${bundleDest}`);
-  console.log(`  Hook script:   ${HOOK_SCRIPT_PATH}`);
-  console.log(`  Config:        ${CONFIG_PATH}`);
-  console.log(`  Port:          ${port}`);
-  console.log("");
-  console.log(
-    "The dashboard will auto-launch when a Claude Code session starts."
-  );
-  console.log(
-    "To uninstall: npx @kosinal/claude-code-dashboard uninstall"
-  );
-}
-function uninstall() {
-  removeHooks();
-  try {
-    fs2.rmSync(DASHBOARD_DIR, { recursive: true, force: true });
-  } catch {
-  }
-  try {
-    fs2.unlinkSync(HOOK_SCRIPT_PATH);
-  } catch {
-  }
-  console.log("Dashboard uninstalled successfully.");
-}
-function writeLockFile(port) {
-  fs2.mkdirSync(DASHBOARD_DIR, { recursive: true });
-  fs2.writeFileSync(LOCK_PATH, `${process.pid}:${port}`);
-}
-function readLockFile() {
-  try {
-    const content = fs2.readFileSync(LOCK_PATH, "utf-8").trim();
-    const parts = content.split(":");
-    const pid = parseInt(parts[0], 10);
-    const port = parts.length > 1 ? parseInt(parts[1], 10) : NaN;
-    if (isNaN(pid) || isNaN(port)) return null;
-    process.kill(pid, 0);
-    return { pid, port };
-  } catch {
-    try {
-      fs2.unlinkSync(LOCK_PATH);
-    } catch {
+// src/state.ts
+var EVENT_TO_STATUS = {
+  SessionStart: "waiting",
+  UserPromptSubmit: "running",
+  Stop: "waiting"
+};
+function createStore() {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    handleEvent(payload) {
+      const { session_id, hook_event_name, cwd } = payload;
+      if (hook_event_name === "SessionEnd") {
+        sessions.delete(session_id);
+        return null;
+      }
+      const status = EVENT_TO_STATUS[hook_event_name];
+      if (!status) {
+        const existing2 = sessions.get(session_id);
+        if (existing2) return existing2;
+        const session2 = {
+          sessionId: session_id,
+          status: "waiting",
+          cwd: cwd ?? "",
+          lastEvent: hook_event_name,
+          updatedAt: Date.now(),
+          startedAt: Date.now()
+        };
+        sessions.set(session_id, session2);
+        return session2;
+      }
+      const now = Date.now();
+      const existing = sessions.get(session_id);
+      if (existing) {
+        existing.status = status;
+        existing.lastEvent = hook_event_name;
+        existing.updatedAt = now;
+        if (cwd) existing.cwd = cwd;
+        return existing;
+      }
+      const session = {
+        sessionId: session_id,
+        status,
+        cwd: cwd ?? "",
+        lastEvent: hook_event_name,
+        updatedAt: now,
+        startedAt: now
+      };
+      sessions.set(session_id, session);
+      return session;
+    },
+    getAllSessions() {
+      return Array.from(sessions.values());
+    },
+    getSession(sessionId) {
+      return sessions.get(sessionId);
+    },
+    removeSession(sessionId) {
+      return sessions.delete(sessionId);
+    },
+    cleanIdleSessions(maxIdleMs) {
+      const now = Date.now();
+      const removed = [];
+      for (const [id, session] of sessions) {
+        if (now - session.updatedAt > maxIdleMs) {
+          sessions.delete(id);
+          removed.push(id);
+        }
+      }
+      return removed;
     }
-    return null;
-  }
-}
-function removeLockFile() {
-  try {
-    fs2.unlinkSync(LOCK_PATH);
-  } catch {
-  }
+  };
 }
 
 // src/bin.ts
@@ -1155,7 +1415,7 @@ function parseArgs(argv) {
     const arg = argv[i];
     if (arg === "--port" && i + 1 < argv.length) {
       port = parseInt(argv[++i], 10);
-      if (isNaN(port) || port < 1 || port > 65535) {
+      if (Number.isNaN(port) || port < 1 || port > 65535) {
         console.error("Error: Invalid port number");
         process.exit(1);
       }
@@ -1177,7 +1437,8 @@ function parseArgs(argv) {
   return { port, command, noHooks, noOpen };
 }
 function printHelp() {
-  console.log(`
+  console.log(
+    `
 claude-code-dashboard - Real-time browser dashboard for Claude Code sessions
 
 Usage:
@@ -1200,7 +1461,8 @@ Quick mode (default):
 Install mode:
   Copies the server to ~/.claude/dashboard/ and installs persistent hooks.
   The dashboard auto-launches when a Claude Code session starts.
-`.trim());
+`.trim()
+  );
 }
 function openBrowser(url) {
   const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
@@ -1353,7 +1615,7 @@ function startDashboard(port, noHooks, noOpen) {
     cleanedUp = true;
     if (!noHooks) {
       try {
-        removeHooks();
+        removeHooks(void 0, "quick");
         console.log("\nHooks removed from settings.json");
       } catch (err) {
         console.error("Warning: Failed to remove hooks:", err);
@@ -1395,9 +1657,7 @@ function startDashboard(port, noHooks, noOpen) {
   });
   dashboard.server.on("error", (err) => {
     if (err.code === "EADDRINUSE") {
-      console.error(
-        `Error: Port ${port} is already in use. Try --port <number>`
-      );
+      console.error(`Error: Port ${port} is already in use. Try --port <number>`);
       process.exit(1);
     }
     throw err;