clementine-agent 1.18.145 → 1.18.147

package/dist/cli/dashboard.js

@@ -1754,6 +1754,28 @@ export async function cmdDashboard(opts) {
             }
             catch { /* ignore */ }
         };
+        // 1.18.147 — Auto-open the dashboard URL in the user's default
+        // browser once the child has had a chance to bind + write the
+        // token file. Direct `clementine dashboard` invocations now match
+        // the restart/update flow so the user never has to copy-paste a
+        // token by hand. Honors NO_BROWSER=1 for headless / CI runs.
+        if (process.env.NO_BROWSER !== '1') {
+            setTimeout(() => {
+                try {
+                    const tokenPath = path.join(BASE_DIR, '.dashboard-token');
+                    const token = existsSync(tokenPath) ? readFileSync(tokenPath, 'utf-8').trim() : '';
+                    if (!token)
+                        return;
+                    const url = `http://localhost:${childPort}/?token=${token}`;
+                    const platform = process.platform;
+                    const cmd = platform === 'darwin' ? 'open'
+                        : platform === 'win32' ? 'start'
+                            : 'xdg-open';
+                    spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
+                }
+                catch { /* best effort */ }
+            }, 1500);
+        }
         // Forward signals to child
         process.on('SIGINT', () => { child.kill('SIGINT'); cleanup(); process.exit(0); });
         process.on('SIGTERM', () => { child.kill('SIGTERM'); cleanup(); process.exit(0); });

package/dist/cli/index.js

@@ -463,31 +463,90 @@ function cmdStop() {
         catch { /* ignore */ }
     }
 }
+/**
+ * 1.18.146 — Spawn the dashboard child detached + briefly verify it's
+ * listening on :3030. Used by both `restart` and `update` so the
+ * dashboard reliably comes back after a daemon refresh.
+ *
+ * The dashboard token rotates on each spawn — print the fresh URL so
+ * the user's old browser tab (which would silently 401 on the stale
+ * token) doesn't waste their time.
+ */
+/**
+ * 1.18.147 — Open the dashboard URL in the user's default browser.
+ *
+ * Invoked after the dashboard child binds. Best-effort cross-platform:
+ * macOS uses `open`, Windows uses `start`, Linux falls back to
+ * `xdg-open`. Failures are swallowed (no native browser, headless
+ * SSH session, etc.) — the printed URL is still the source of truth
+ * the user can copy by hand.
+ *
+ * Honors NO_BROWSER=1 env var so CI / scripted runs don't get a
+ * spurious browser tab.
+ */
+function openInBrowser(url) {
+    if (process.env.NO_BROWSER === '1')
+        return;
+    const platform = process.platform;
+    const cmd = platform === 'darwin' ? 'open'
+        : platform === 'win32' ? 'start'
+            : 'xdg-open';
+    try {
+        const { spawn: spawnProc } = require('node:child_process');
+        spawnProc(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
+    }
+    catch { /* no browser available; URL was already printed */ }
+}
+async function relaunchDashboardDetached(opts = {}) {
+    try {
+        const { spawn: spawnProc } = await import('node:child_process');
+        const child = spawnProc('node', [path.join(PACKAGE_ROOT, 'dist/cli/index.js'), 'dashboard'], { detached: true, stdio: 'ignore' });
+        child.unref();
+        // Brief liveness wait — give the child ~3s to bind before we
+        // print the URL. If it never binds, the URL still prints (user
+        // can retry) but we surface the failure in logs.
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        let token = '';
+        try {
+            const tokenPath = path.join(BASE_DIR, '.dashboard-token');
+            if (existsSync(tokenPath))
+                token = readFileSync(tokenPath, 'utf-8').trim();
+        }
+        catch { /* token may not be ready yet */ }
+        if (token) {
+            const url = `http://localhost:3030/?token=${token}`;
+            console.log(`  Dashboard relaunched: ${url}`);
+            // 1.18.147 — auto-open the browser by default. Restart/update
+            // already imply user wants the dashboard back; making them copy a
+            // URL was a UX papercut.
+            if (opts.open !== false)
+                openInBrowser(url);
+        }
+        else {
+            console.log('  Dashboard relaunched (token not ready — check `clementine status`).');
+        }
+    }
+    catch {
+        console.log('  Could not relaunch dashboard — run: clementine dashboard');
+    }
+}
 async function cmdRestart(options) {
     cmdStop();
-    // Kill ALL dashboard processes (not just PID file — catches orphans)
-    let dashboardWasRunning = false;
+    // Kill ALL dashboard processes (not just PID file — catches orphans).
+    // Restart implies "I want a fresh dashboard too" — always respawn,
+    // not just when the kill check found one. Closes the race where the
+    // dashboard had crashed (or been killed by an earlier `clementine
+    // update`) before restart ran, leaving the user with no dashboard.
     try {
         const { killExistingDashboards } = await import('./dashboard.js');
         const killed = killExistingDashboards();
         if (killed > 0) {
-            dashboardWasRunning = true;
             console.log(`  Stopped ${killed} dashboard process(es).`);
         }
     }
     catch { /* dashboard module may not be available */ }
     await cmdLaunch({ foreground: options.foreground });
-    if (dashboardWasRunning) {
-        try {
-            const { spawn: spawnProc } = await import('node:child_process');
-            const child = spawnProc('node', [path.join(PACKAGE_ROOT, 'dist/cli/index.js'), 'dashboard'], { detached: true, stdio: 'ignore' });
-            child.unref();
-            console.log('  Dashboard relaunched.');
-        }
-        catch {
-            console.log('  Could not relaunch dashboard — run: clementine dashboard');
-        }
-    }
+    await relaunchDashboardDetached();
 }
 function cmdStatus() {
     const DIM = '\x1b[0;90m';
@@ -4262,10 +4321,13 @@ async function cmdUpdate(options) {
         }
     }
     catch { /* no dashboard running */ }
-    // Don't auto-relaunch dashboard during update — it causes duplicate process issues.
-    // The daemon restart below will handle it, or user can run: clementine dashboard
+    // 1.18.146 — `dashboardWasRunning` was previously dropped on the
+    // floor here (the comment said "the daemon restart below will handle
+    // it" — but cmdRestart's own dashboard detection runs after this kill
+    // so it sees zero and never respawns). Now we explicitly remember to
+    // respawn at the end of update if the user had a dashboard up before.
     if (dashboardWasRunning) {
-        console.log(`  Dashboard stopped. Relaunch with: ${DIM}clementine dashboard${RESET}`);
+        console.log(`  ${GREEN}OK${RESET}  Dashboard will relaunch after daemon restart.`);
     }
     // 12. Write update sentinel so the daemon can report what happened
     let commitHash = '';
@@ -4399,6 +4461,14 @@ async function cmdUpdate(options) {
         }
         catch { /* .env read failed */ }
     }
+    // 13.5. Respawn dashboard if it was running before the update.
+    // 1.18.146 — closes the bug where `clementine update restart` left
+    // users with no dashboard because the kill at step 11 above robbed
+    // cmdRestart of its respawn signal. Now we own the respawn here
+    // when we own the kill.
+    if (dashboardWasRunning) {
+        await relaunchDashboardDetached();
+    }
     // 14. Show current version
     console.log();
     if (previousVersion !== 'unknown' && newVersion !== 'unknown' && previousVersion !== newVersion) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.145",
+  "version": "1.18.147",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",