claude-mission-control 1.7.0 → 1.8.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.
 

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/config.js

@@ -35,6 +35,17 @@ const IGNORE_FILE = path.join(CONFIG_DIR, 'ignore.json');
 
 const DEFAULTS = { terminal: 'ghostty', notifications: true, usageApi: true, mutedProjects: [], weeklyBudget: 0, pinnedSessions: [], 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 {
     return JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -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;
 }
@@ -188,6 +199,7 @@ function resolvedTerminal() {
 }
 
 module.exports = {
+  THEMES,
   readConfig,
   configDir: () => CONFIG_DIR,
   findOnPath,

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.8.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 {
@@ -1652,6 +1725,54 @@ 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";
+  })();
+}
+
 async function saveSetting(endpoint, payload, note) {
   try {
     const r = await fetch(endpoint, {
@@ -1680,6 +1801,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 +1824,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 +1873,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";
       }

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(),