claude-mission-control 1.7.0 → 1.9.0

package/README.md

@@ -113,6 +113,8 @@ The ⚙ gear in the header opens settings — no JSON editing required:
 - **Notifications** on/off (writes `config.json`); per-project mute lives on each project's slide-over
 - **Terminal** for open/new-session buttons: Ghostty, iTerm2, or Terminal.app, auto-detected (`config.json`)
 - **Rename any project** (writes `names.json`) or **hide it** and its whole subtree (writes `ignore.json`), with an unhide list below
+- **Theme**: Departures board (follows system light/dark), Phosphor, Amber CRT, Midnight, or Newsprint (`config.json`)
+- **Updates**: "check for updates" asks GitHub only when you click; when a new release is out, **update now** pulls it in place (git or npm installs) and service installs restart themselves on the new version
 
 Everything saves instantly; the underlying files stay hand-editable. Keyboard: `⌘K` for the palette, `/` for search, `Esc` closes anything.
 
@@ -130,6 +132,8 @@ Edit `names.json` to control how projects are titled:
 
 Unlisted projects fall back to a cleaned-up folder name. Changes are picked up automatically — no restart needed.
 
+Sessions can be renamed too: click the ✎ next to any session title (live board, project cards, pinned strip, or a project's slide-over), type a name, and press Enter. Escape cancels; an empty name goes back to the automatic title. Custom names live in `config.json` under `sessionNames`, keyed by session id, and win over the AI-generated or first-prompt title everywhere.
+
 ## Hiding projects
 
 Edit `ignore.json` — an array of absolute path prefixes. A project is hidden if its path is, or sits under, any listed prefix, so one line hides a whole tree (e.g. all the plugins/themes inside one site). This only hides them from the dashboard, strip, and menu bar; nothing on disk or in `~/.claude` is touched. Picked up automatically.

package/claude-dashboard.service

@@ -4,7 +4,8 @@ After=default.target
 
 [Service]
 ExecStart=__NODE_PATH__ __APP_DIR__/server.js
-Restart=on-failure
+Environment=CLAUDE_DASH_SERVICE=1
+Restart=always
 RestartSec=3
 
 [Install]

package/com.claude-dashboard.plist

@@ -14,5 +14,6 @@
   <key>StandardErrorPath</key><string>__HOME__/Library/Logs/claude-dashboard.log</string>
   <key>EnvironmentVariables</key><dict>
     <key>CLAUDE_DASH_PORT</key><string>4517</string>
+    <key>CLAUDE_DASH_SERVICE</key><string>1</string>
   </dict>
 </dict></plist>

package/lib/collector.js

@@ -165,8 +165,14 @@ class Collector {
     return [...set.values()].filter((p) => !isIgnored(p));
   }
 
+  // sessionTitle with the user's custom names from config.json applied.
+  titleOf(m) {
+    return sessionTitle(m, readConfig().sessionNames);
+  }
+
   assemble() {
     const registry = readRegistry();
+    const sessionNames = readConfig().sessionNames || {}; // read once, not per session
     const liveByProject = new Set(
       this.raw.live.map((s) => worktreeRoot(s.cwd).root.toLowerCase())
     );
@@ -203,7 +209,7 @@ class Collector {
           0
         ),
         sessions: sessionMetas.slice(0, SESSIONS_PER_PROJECT).map((m) => {
-          const { title, source } = sessionTitle(m);
+          const { title, source } = sessionTitle(m, sessionNames);
           return {
             sessionId: m.sessionId,
             estCost: estimateCost(combinedUsage(m)),
@@ -235,7 +241,7 @@ class Collector {
     const subsBySession = new Map();
     for (const g of this.raw.transcriptGroups.values()) {
       for (const m of g.sessions) {
-        titleBySession.set(m.sessionId, sessionTitle(m).title);
+        titleBySession.set(m.sessionId, sessionTitle(m, sessionNames).title);
         if (m.model) modelBySession.set(m.sessionId, m.model);
         const subs = subagentSummary(m);
         if (subs) subsBySession.set(m.sessionId, subs);
@@ -306,7 +312,7 @@ class Collector {
           if (pinnedIds.has(m.sessionId)) {
             pinned.push({
               sessionId: m.sessionId,
-              title: sessionTitle(m).title,
+              title: sessionTitle(m, sessionNames).title,
               projectName: friendlyName(g.path),
               model: m.model || null,
               lastActivityAt: m.lastActivityAt,
@@ -365,7 +371,7 @@ class Collector {
     const g = this.raw.transcriptGroups.get(projectPath.toLowerCase());
     if (!g) return [];
     return g.sessions.map((m) => {
-      const { title, source } = sessionTitle(m);
+      const { title, source } = this.titleOf(m);
       return {
         sessionId: m.sessionId,
         title,
@@ -441,7 +447,7 @@ class Collector {
           timeline.push({
             project: friendlyName(g.path),
             sessionId: m.sessionId,
-            title: sessionTitle(m).title,
+            title: this.titleOf(m).title,
             start: Math.max(m.startedAt || m.lastActivityAt, dayCut),
             end: m.lastActivityAt,
           });
@@ -507,7 +513,7 @@ class Collector {
     for (const g of this.raw.transcriptGroups.values()) {
       for (const m of g.sessions) {
         if (m.sessionId === sessionId) {
-          return { file: m.file, title: sessionTitle(m).title, projectName: friendlyName(g.path) };
+          return { file: m.file, title: this.titleOf(m).title, projectName: friendlyName(g.path) };
         }
       }
     }

package/lib/config.js

@@ -33,7 +33,18 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const NAMES_FILE = path.join(CONFIG_DIR, 'names.json');
 const IGNORE_FILE = path.join(CONFIG_DIR, 'ignore.json');
 
-const DEFAULTS = { terminal: 'ghostty', notifications: true, usageApi: true, mutedProjects: [], weeklyBudget: 0, pinnedSessions: [], theme: 'board' };
+const DEFAULTS = { terminal: 'ghostty', notifications: true, usageApi: true, mutedProjects: [], weeklyBudget: 0, pinnedSessions: [], sessionNames: {}, theme: 'board' };
+
+// The one theme list: updateConfig validates against it and GET /api/config
+// serves it, so the settings dropdown can never offer a value the server
+// would drop. Adding a theme = one entry here + its CSS block in index.html.
+const THEMES = [
+  { id: 'board', label: 'Departures board' },
+  { id: 'phosphor', label: 'Phosphor' },
+  { id: 'amber', label: 'Amber CRT' },
+  { id: 'midnight', label: 'Midnight' },
+  { id: 'newsprint', label: 'Newsprint' },
+];
 
 function readJson(file, fallback) {
   try {
@@ -59,7 +70,7 @@ function updateConfig(patch) {
   if (typeof patch.weeklyBudget === 'number' && patch.weeklyBudget >= 0 && Number.isFinite(patch.weeklyBudget)) {
     next.weeklyBudget = Math.round(patch.weeklyBudget);
   }
-  if (patch.theme === 'board' || patch.theme === 'phosphor') next.theme = patch.theme;
+  if (THEMES.some((t) => t.id === patch.theme)) next.theme = patch.theme;
   writeJson(CONFIG_FILE, next);
   return next;
 }
@@ -85,6 +96,23 @@ function togglePin(sessionId) {
   return !has;
 }
 
+// Pure: returns a new sessionNames map with `name` set for `sessionId`
+// (trimmed, capped at 80 chars); an empty name removes the entry.
+function applySessionName(sessionNames, sessionId, name) {
+  const next = { ...(sessionNames || {}) };
+  const clean = String(name || '').trim().slice(0, 80);
+  if (clean) next[sessionId] = clean;
+  else delete next[sessionId];
+  return next;
+}
+
+function setSessionName(sessionId, name) {
+  const next = { ...readConfig() };
+  next.sessionNames = applySessionName(next.sessionNames, sessionId, name);
+  writeJson(CONFIG_FILE, next);
+  return next.sessionNames[sessionId] || '';
+}
+
 function readNames() {
   return readJson(NAMES_FILE, {});
 }
@@ -188,6 +216,7 @@ function resolvedTerminal() {
 }
 
 module.exports = {
+  THEMES,
   readConfig,
   configDir: () => CONFIG_DIR,
   findOnPath,
@@ -196,6 +225,8 @@ module.exports = {
   updateConfig,
   setProjectMuted,
   togglePin,
+  applySessionName,
+  setSessionName,
   readNames,
   setName,
   readIgnores,

package/lib/transcripts.js

@@ -357,7 +357,11 @@ function dailyCostSeries(daysList, numDays, today = Date.now()) {
 }
 
 // Best display title for a session, with its provenance.
-function sessionTitle(meta) {
+// `custom` is a user-set name from config.json (sessionNames); it wins over
+// anything derived from the transcript.
+function sessionTitle(meta, customNames) {
+  const custom = customNames && customNames[meta.sessionId];
+  if (custom) return { title: custom, source: 'custom' };
   if (meta.aiTitle) return { title: meta.aiTitle, source: 'ai-title' };
   if (meta.firstUserPrompt) return { title: meta.firstUserPrompt, source: 'first-prompt' };
   if (meta.lastPrompt) return { title: meta.lastPrompt, source: 'last-prompt' };

package/lib/update.js

@@ -0,0 +1,110 @@
+'use strict';
+// Self-update: figure out how this copy of the dashboard was installed, and
+// run the matching update command. The server never takes a path or command
+// from the client — everything derives from the app's own location.
+
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { canonicalize } = require('./paths');
+
+const PKG_NAME = require('../package.json').name;
+
+// Pure: appDir + "does .git exist there" -> 'git' | 'npm' | 'npx' | 'brew' | 'unknown'.
+// Location signals (brew Cellar, npx cache, non-npm package managers) win over
+// a .git dir: those are package-manager-owned trees we must never git-pull in.
+// pnpm/yarn/volta/bun globals also live under node_modules, but running
+// `npm install -g` there installs a second copy under npm's own prefix while
+// the running copy stays old — so they get manual instructions instead.
+function detectInstallKind(appDir, hasGitDir) {
+  const p = canonicalize(appDir).toLowerCase();
+  if (p.includes('/cellar/') || p.includes('/homebrew/')) return 'brew';
+  if (p.includes('/_npx/')) return 'npx';
+  if (['/pnpm/', '/yarn/', '/.yarn/', '/volta/', '/.volta/', '/.bun/'].some((sig) => p.includes(sig))) return 'unknown';
+  if (hasGitDir) return 'git';
+  if (p.includes('/node_modules/')) return 'npm';
+  return 'unknown';
+}
+
+// Pure: install kind -> either a fixed command to run, or instructions to
+// show. The command list is closed — nothing here ever comes from a request.
+function updatePlan(kind, pkgName) {
+  if (kind === 'git') return { type: 'run', cmd: 'git', args: ['pull', '--ff-only'] };
+  if (kind === 'npm') return { type: 'run', cmd: 'npm', args: ['install', '-g', `${pkgName}@latest`] };
+  if (kind === 'brew') return { type: 'manual', message: `Run: brew upgrade ${pkgName}` };
+  if (kind === 'npx') return { type: 'manual', message: `Quit the dashboard and re-run npx ${pkgName} — npx fetches the newest release each time.` };
+  return { type: 'manual', message: 'Update with the tool you installed with, or download from https://github.com/JonImmsWordpressDev/claude-dashboard/releases' };
+}
+
+// Pure: where npm's CLI JS lives relative to the node binary's directory —
+// the unix prefix layout and the Windows layout. Running it via our own
+// process.execPath sidesteps both the service manager's minimal PATH
+// (launchd/systemd ship no PATH, so bare 'npm' is ENOENT) and Windows,
+// where 'npm' is npm.cmd and can't be spawned without a shell.
+function npmCliCandidates(nodeDir) {
+  return [
+    path.join(nodeDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ];
+}
+
+// launchd (KeepAlive) and systemd (Restart) relaunch us after an update exit;
+// a terminal-run process must not be killed. Signals, most reliable first:
+// our own service definitions set CLAUDE_DASH_SERVICE=1; systemd sets
+// INVOCATION_ID for every unit, which covers units deployed before that var
+// existed; ppid 1 on macOS covers launchd agents installed before it (kept
+// mac-only so an orphaned `dashboard &` run on Linux isn't misread).
+function serviceManaged() {
+  if (process.env.CLAUDE_DASH_SERVICE === '1') return true;
+  if (process.env.INVOCATION_ID) return true;
+  return process.platform === 'darwin' && process.ppid === 1;
+}
+
+function readPkgVersion(appDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(appDir, 'package.json'), 'utf8')).version || null;
+  } catch {
+    return null;
+  }
+}
+
+function runSelfUpdate(appDir) {
+  const kind = detectInstallKind(appDir, fs.existsSync(path.join(appDir, '.git')));
+  const plan = updatePlan(kind, PKG_NAME);
+  if (plan.type === 'manual') {
+    return Promise.resolve({ ok: false, kind, manual: plan.message });
+  }
+  let cmd = plan.cmd;
+  let args = plan.args;
+  if (kind === 'npm') {
+    const cli = npmCliCandidates(path.dirname(process.execPath)).find((p) => fs.existsSync(p));
+    if (cli) {
+      cmd = process.execPath;
+      args = [cli, ...plan.args];
+    }
+  }
+  const before = readPkgVersion(appDir);
+  return new Promise((resolve) => {
+    execFile(cmd, args, { cwd: appDir, timeout: 120_000 }, (err, stdout, stderr) => {
+      if (err) {
+        resolve({ ok: false, kind, error: String(stderr || err.message).slice(0, 300) });
+        return;
+      }
+      // The command exiting 0 isn't proof anything changed: npm can re-fetch
+      // the same version while a release is still publishing, and git can
+      // pull nothing. Only a version change on disk earns a restart.
+      const after = readPkgVersion(appDir);
+      const changed = Boolean(after && before && after !== before);
+      resolve({
+        ok: true,
+        kind,
+        version: after || undefined,
+        unchanged: !changed,
+        willRestart: changed && serviceManaged(),
+        output: String(stdout).slice(0, 300),
+      });
+    });
+  });
+}
+
+module.exports = { detectInstallKind, updatePlan, npmCliCandidates, runSelfUpdate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mission-control",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Local dashboard for Claude Code: live sessions, transcripts, costs, git status — all your projects in one place.",
   "main": "server.js",
   "bin": {

package/public/index.html

@@ -101,6 +101,79 @@
     --flap-split: rgba(0, 0, 0, 0.5);
     --amber-ink: #050a06;
   }
+  /* Amber CRT: the VT220's other phosphor. Real amber terminals signaled with
+     two intensities, so body text is dim amber, "working" is standard amber,
+     and "needs you" is the white-hot bright intensity. Red still means broken. */
+  :root[data-theme="amber"] {
+    --disp-font: 'JetBrains Mono', ui-monospace, monospace;
+    --bg: #0a0602;
+    --surface: #140d04;
+    --surface2: #1f1508;
+    --ink: #d99a3f;
+    --muted: #a1712a;
+    --faint: #6e4c1a;
+    --line: #241708;
+    --accent: #ffb020;
+    --warn: #ffe6c0;
+    --bad: #ff4b33;
+    --chip-bg: #1f1508;
+    --warn-bg: rgba(255, 230, 192, 0.10);
+    --accent-bg: rgba(255, 176, 32, 0.10);
+    --glow: 0 0 9px;
+    --flap: #140d04;
+    --flap-hi: #1b1206;
+    --flap-split: rgba(0, 0, 0, 0.5);
+    --amber-ink: #0a0602;
+  }
+  /* Midnight: the board on the night shift. Deep blue-black enamel, frost
+     ink, ice-cyan boarding lamp; a warm lantern amber is the one warm thing
+     on screen, so "needs you" pops hardest. */
+  :root[data-theme="midnight"] {
+    --disp-font: 'Oswald', 'Arial Narrow', sans-serif;
+    --bg: #0a1220;
+    --surface: #111a2c;
+    --surface2: #1a2740;
+    --ink: #d6e2f0;
+    --muted: #8299b5;
+    --faint: #4d6076;
+    --line: #1c2a42;
+    --accent: #5bc8d8;
+    --warn: #ffc466;
+    --bad: #ff6b5e;
+    --chip-bg: #1a2740;
+    --warn-bg: rgba(255, 196, 102, 0.12);
+    --accent-bg: rgba(91, 200, 216, 0.10);
+    --glow: 0 0 6px;
+    --flap: #111a2c;
+    --flap-hi: #16223a;
+    --flap-split: rgba(0, 0, 0, 0.45);
+    --amber-ink: #0a1220;
+  }
+  /* Newsprint: always-light broadsheet. Grey newsprint stock, serif section
+     headers, printed-green ink for "boarding", and one red: stop-press red
+     for "needs you". Errors are oxblood — a different red, darker. No glow;
+     paper doesn't. */
+  :root[data-theme="newsprint"] {
+    --disp-font: Georgia, 'Iowan Old Style', 'Times New Roman', serif;
+    --bg: #eeebe1;
+    --surface: #e6e2d6;
+    --surface2: #dbd6c7;
+    --ink: #1c1914;
+    --muted: #5f594c;
+    --faint: #928a79;
+    --line: #c9c3b2;
+    --accent: #23704b;
+    --warn: #c22c1c;
+    --bad: #6b1005;
+    --chip-bg: #dbd6c7;
+    --warn-bg: rgba(194, 44, 28, 0.08);
+    --accent-bg: rgba(35, 112, 75, 0.08);
+    --glow: none;
+    --flap: #e6e2d6;
+    --flap-hi: #ece8dd;
+    --flap-split: rgba(0, 0, 0, 0.08);
+    --amber-ink: #eeebe1;
+  }
   * { box-sizing: border-box; margin: 0; }
   html { -webkit-text-size-adjust: 100%; }
   body {
@@ -329,6 +402,15 @@
   .s-title[data-session], .di-title[data-session] { cursor: pointer; }
   .s-title[data-session]:hover, .di-title[data-session]:hover { color: var(--accent); }
 
+  /* inline session rename (pencil button swaps the title for this input) */
+  .rename-input {
+    font: inherit; font-size: 12.5px; color: var(--ink);
+    background: var(--surface2); border: 1px solid var(--accent);
+    border-radius: 2px; padding: 2px 6px; flex: 1; min-width: 0; width: 100%;
+    box-sizing: border-box;
+  }
+  .rename-input:focus { outline: none; }
+
   /* transcript rendering */
   .t-turn { margin: 10px 0; }
   .t-user {
@@ -861,6 +943,10 @@ function copyBtn(cmd) {
 
 // Live sessions are already open somewhere; only offer open on idle ones.
 let liveIds = new Set();
+function renameBtn(sessionId, title) {
+  return `<button class="copy rename-btn" data-rename-session="${esc(sessionId)}" data-title="${esc(title || '')}" title="Rename this session">✎</button>`;
+}
+
 function openBtn(sessionId) {
   if (liveIds.has(sessionId)) return '';
   return `<button class="copy open-btn" data-open="${esc(sessionId)}" title="Open this session">open ⬈</button>`;
@@ -899,6 +985,7 @@ function liveCard(s) {
       ${modelChip(s.model)}
       <span class="dep-elapsed">${elapsed(s.startedAt)}</span>
       ${statusFlap(s)}
+      ${renameBtn(s.sessionId, s.title)}
       ${copyBtn(s.resumeCommand)}
     </div>
   </div>`;
@@ -912,6 +999,7 @@ function projectCard(p) {
             sess.worktree ? `<span class="wt mono">⎇ ${esc(sess.worktree)}</span>` : ''}${esc(sess.title)}</span>
           ${modelChip(sess.model)}
           <span class="s-when">${relTime(sess.lastActivityAt)}</span>
+          ${renameBtn(sess.sessionId, sess.title)}
           ${openBtn(sess.sessionId)}
           ${copyBtn(sess.resumeCommand)}
         </li>`).join('')}</ul>`
@@ -944,6 +1032,7 @@ function renderPinned(state) {
       ${modelChip(p.model)}
       <span class="s-when">${esc(p.projectName)}</span>
       <span class="s-when">${relTime(p.lastActivityAt)}</span>
+      ${renameBtn(p.sessionId, p.title)}
       <button class="copy" data-pin="${esc(p.sessionId)}" title="Unpin">unpin</button>
     </div>`).join(''));
 }
@@ -1044,7 +1133,11 @@ function renderDigest(state) {
   patch($('#digest-body'), html);
 }
 
+let renderDeferred = false; // an SSE tick arrived while a rename input was open
 function render(state) {
+  // Rebuilding the DOM mid-edit would wipe the rename input; catch up afterwards.
+  if (document.querySelector('.rename-input')) { renderDeferred = true; return; }
+  renderDeferred = false;
   if (state.theme && state.theme !== 'board') document.documentElement.dataset.theme = state.theme;
   else delete document.documentElement.dataset.theme;
   liveIds = new Set((state.liveSessions || []).map((s) => s.sessionId));
@@ -1283,6 +1376,7 @@ function renderDetail(d, name) {
             s.worktree ? `<span class="wt mono">⎇ ${esc(s.worktree)}</span> ` : ''}${esc(s.title)}</span>
           ${fmtCost(s.estCost) ? `<span class="s-when">≈${fmtCost(s.estCost)}</span>` : ''}
           <span class="s-when">${relTime(s.lastActivityAt)}</span>
+          ${renameBtn(s.sessionId, s.title)}
           ${openBtn(s.sessionId)}
           ${copyBtn(s.resumeCommand)}
         </li>`).join('')}</ul>`
@@ -1652,6 +1746,108 @@ async function runSearch(q, deep) {
 }
 
 // ---------- settings ----------
+// One-click self-update. The server decides what to run from its own install
+// location; we just kick it off and wait for the new version to come back up.
+async function applyUpdate(out, currentVersion) {
+  out.textContent = 'updating…';
+  let startPid = null;
+  try {
+    startPid = (await (await fetch('/api/health', { cache: 'no-store' })).json()).pid || null;
+  } catch {}
+  let r;
+  try {
+    r = await (await fetch('/api/update', { method: 'POST' })).json();
+  } catch {
+    out.textContent = "couldn't reach the server";
+    return;
+  }
+  if (r.manual) { out.textContent = r.manual; return; }
+  if (!r.ok) { out.textContent = `update failed: ${r.error || 'unknown error'}`; return; }
+  if (r.unchanged) {
+    out.textContent = r.kind === 'npm'
+      ? 'nothing newer on npm yet — the release may still be publishing, try again in a few minutes'
+      : 'nothing new arrived — try again later';
+    return;
+  }
+  if (!r.willRestart) {
+    out.textContent = `updated to ${r.version || 'the new version'} — restart the dashboard to finish`;
+    return;
+  }
+  out.textContent = 'updated — restarting…';
+  // The old process exits moments after replying; poll health until a
+  // different server answers — new version, new pid, or back up after a
+  // visible down-gap (pid catches a fast relaunch the version can't).
+  const t0 = Date.now();
+  let sawDown = false;
+  (async function poll() {
+    try {
+      const h = await (await fetch('/api/health', { cache: 'no-store' })).json();
+      if (h.version !== currentVersion || (startPid && h.pid && h.pid !== startPid) || sawDown) {
+        location.reload();
+        return;
+      }
+    } catch {
+      sawDown = true;
+    }
+    if (Date.now() - t0 < 60000) setTimeout(poll, 1500);
+    else out.textContent = "server didn't come back — check the logs";
+  })();
+}
+
+// Swap a session title for a text input. Enter/blur saves, Escape cancels,
+// an empty name goes back to the automatic title.
+function startRename(btn) {
+  const id = btn.dataset.renameSession;
+  const row = btn.closest('li, .pin-row, .dep-row');
+  const titleEl = row && row.querySelector(`[data-session="${CSS.escape(id)}"]`);
+  if (!titleEl || row.querySelector('.rename-input')) return;
+  const before = btn.dataset.title || '';
+  const input = document.createElement('input');
+  input.className = 'rename-input';
+  input.type = 'text';
+  input.maxLength = 80;
+  input.value = before;
+  input.placeholder = 'Session name — leave empty to reset';
+  titleEl.hidden = true;
+  titleEl.after(input);
+  input.focus();
+  input.select();
+  let done = false;
+  const finish = async (save) => {
+    if (done) return;
+    done = true;
+    const val = input.value.trim();
+    input.remove();
+    titleEl.hidden = false;
+    if (save && val !== before) {
+      try {
+        const r = await fetch('/api/config', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ renameSession: id, name: val }),
+        });
+        const out = await r.json();
+        if (out.ok) {
+          // Drawers aren't re-rendered by SSE, so patch the title in place.
+          const text = [...titleEl.childNodes].find((n) => n.nodeType === 3);
+          if (text) text.textContent = out.title; else titleEl.append(out.title);
+          btn.dataset.title = out.title;
+          toast(val ? `Renamed to "${val}"` : 'Name reset to the automatic title');
+        } else toast(`Couldn't rename: ${out.error}`);
+      } catch {
+        toast("Couldn't reach the server");
+      }
+    }
+    if (renderDeferred && lastState) render(lastState);
+  };
+  input.addEventListener('keydown', (e) => {
+    e.stopPropagation(); // keep the page's shortcuts (Esc, /, etc.) out of the edit
+    if (e.key === 'Enter') finish(true);
+    else if (e.key === 'Escape') finish(false);
+  });
+  input.addEventListener('blur', () => finish(true));
+}
+
 async function saveSetting(endpoint, payload, note) {
   try {
     const r = await fetch(endpoint, {
@@ -1680,6 +1876,7 @@ async function openSettings() {
       }
       return '';
     };
+    const themeId = (c.themes || []).some((t) => t.id === c.theme) ? c.theme : 'board';
     const general = `
       <div class="set-row">
         <span class="set-label">Notifications<span class="set-sub">waiting-for-input and stuck-session alerts</span></span>
@@ -1702,10 +1899,9 @@ async function openSettings() {
         <input type="checkbox" id="set-usage" ${c.usageApi !== false ? 'checked' : ''}>
       </div>
       <div class="set-row">
-        <span class="set-label">Theme<span class="set-sub">Departures board follows light/dark; Phosphor is always-dark green terminal</span></span>
+        <span class="set-label">Theme<span class="set-sub">Departures board follows light/dark; Newsprint is always-light; the rest are always-dark</span></span>
         <select id="set-theme">
-          <option value="board" ${c.theme !== 'phosphor' ? 'selected' : ''}>Departures board</option>
-          <option value="phosphor" ${c.theme === 'phosphor' ? 'selected' : ''}>Phosphor</option>
+          ${(c.themes || []).map((t) => `<option value="${t.id}" ${t.id === themeId ? 'selected' : ''}>${esc(t.label)}</option>`).join('')}
         </select>
       </div>
       <div class="set-row">
@@ -1752,7 +1948,13 @@ async function openSettings() {
         const r = await (await fetch('/api/update-check')).json();
         if (r.error) out.textContent = `couldn't check: ${r.error}`;
         else if (r.upToDate) out.textContent = `up to date (${r.current})`;
-        else out.innerHTML = `${esc(r.latest)} available — <a href="${esc(r.url)}" target="_blank" rel="noopener" style="color:var(--accent)">release notes</a>, then git pull`;
+        else {
+          out.innerHTML = `${esc(r.latest)} available — <a href="${esc(r.url)}" target="_blank" rel="noopener" style="color:var(--accent)">release notes</a> · <a href="#" id="set-update-now" style="color:var(--warn)">update now</a>`;
+          $('#set-update-now').addEventListener('click', (ev) => {
+            ev.preventDefault();
+            applyUpdate(out, r.current);
+          });
+        }
       } catch {
         out.textContent = "couldn't reach GitHub";
       }
@@ -1846,6 +2048,8 @@ document.addEventListener('click', async (e) => {
     }
     return;
   }
+  const rb = e.target.closest('[data-rename-session]');
+  if (rb) { startRename(rb); return; }
   const t = e.target.closest('[data-session]');
   if (t) { openTranscript(t.dataset.session, t.dataset.hl); return; }
   const nb = e.target.closest('[data-new]');

package/server.js

@@ -17,6 +17,7 @@ const cfg = require('./lib/config');
 const { isProjectMuted } = require('./lib/notify');
 const { recentCommits, linkCommitsToSessions } = require('./lib/gitlog');
 const { demoState, demoStats, demoSession } = require('./lib/demo');
+const { runSelfUpdate } = require('./lib/update');
 const DEMO = process.env.CLAUDE_DASH_DEMO === '1';
 
 const PORT = Number(process.env.CLAUDE_DASH_PORT) || 4517;
@@ -114,7 +115,7 @@ const server = http.createServer((req, res) => {
       });
     }
     if (url === '/api/config' && req.method === 'GET') {
-      return json(res, 200, { demo: true, notifications: true, usageApi: false, weeklyBudget: 200, terminals: [], resolvedTerminal: { id: 'terminal', label: 'Terminal' }, claudeApp: false, names: {}, ignores: [], version: VERSION, errors: [] });
+      return json(res, 200, { demo: true, notifications: true, usageApi: false, weeklyBudget: 200, terminals: [], resolvedTerminal: { id: 'terminal', label: 'Terminal' }, claudeApp: false, names: {}, ignores: [], themes: cfg.THEMES, version: VERSION, errors: [] });
     }
     if (url === '/api/events') {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
@@ -179,6 +180,27 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  // Manual only, no client input: updates this install in place (git pull or
+  // npm -g reinstall, decided server-side from our own location). When the
+  // process is service-managed, it exits after replying and launchd/systemd
+  // relaunch it on the new code.
+  if (url === '/api/update' && req.method === 'POST') {
+    if (!sameOrigin(req)) return json(res, 403, { ok: false, error: 'forbidden' });
+    runSelfUpdate(__dirname).then((result) => {
+      json(res, result.ok || result.manual ? 200 : 500, result);
+      if (result.ok && result.willRestart) {
+        setTimeout(() => {
+          console.log(`self-update to ${result.version} applied — exiting so the service manager relaunches`);
+          // launchd's KeepAlive=true relaunches on any exit, so macOS exits
+          // clean. Linux exits 1 because units deployed before this feature
+          // have Restart=on-failure and never get the updated unit file.
+          process.exit(process.platform === 'darwin' ? 0 : 1);
+        }, 500);
+      }
+    });
+    return;
+  }
+
   if (url === '/api/events') {
     res.writeHead(200, {
       'Content-Type': 'text/event-stream',
@@ -230,6 +252,7 @@ const server = http.createServer((req, res) => {
   if (url === '/api/config' && req.method === 'GET') {
     json(res, 200, {
       ...cfg.readConfig(),
+      themes: cfg.THEMES,
       version: VERSION,
       errors: collector.state.errors || [],
       terminals: cfg.detectTerminals(),
@@ -256,6 +279,13 @@ const server = http.createServer((req, res) => {
             collector.assemble();
             return json(res, 200, { ok: true, pinned });
           }
+          if (payload.renameSession !== undefined) {
+            const id = String(payload.renameSession || '');
+            if (!collector.findSessionFile(id)) return json(res, 404, { ok: false, error: 'unknown session' });
+            const name = cfg.setSessionName(id, String(payload.name || ''));
+            collector.assemble();
+            return json(res, 200, { ok: true, name, title: collector.findSessionFile(id).title });
+          }
           if (payload.mutePath !== undefined) {
             const known = collector
               .projectPaths()