persnally 2.5.2 → 2.5.3

package/build/src/cli.js

@@ -19,7 +19,7 @@ import { extractClaudeEvents, parseClaudeExport } from "./importers/claude.js";
 import { DEFAULT_TRANSCRIPTS_DIR, extractClaudeCodeEvents, parseClaudeCodeTranscripts, } from "./importers/claude-code.js";
 import { gitEvents, scanRepos } from "./importers/git.js";
 import { freshConversations } from "./importers/extract.js";
-import { autostartInstalled, installAutostart, LOG_FILE, removeAutostart, removePidFile, runningPid, startDetached, stopDaemon, writePidFile, } from "./lifecycle.js";
+import { autostartInstalled, installAutostart, LOG_FILE, reloadAutostart, removeAutostart, removePidFile, runningPid, startDetached, stopDaemon, writePidFile, } from "./lifecycle.js";
 import { newEvent } from "./events.js";
 import { proseLines } from "./prose.js";
 import { analyzeVoice } from "./stylometry.js";
@@ -50,6 +50,7 @@ Usage:
   persnallyd activity               Context-read engagement over time (retention pulse)
   persnallyd start [--port N]       Start the daemon in the background
   persnallyd stop                   Stop the background daemon
+  persnallyd restart                Restart the daemon (correctly handles autostart/launchd)
   persnallyd serve [--port N]       Run the daemon in the foreground (127.0.0.1:${DEFAULT_PORT})
   persnallyd autostart [--remove]   Start the daemon at login and keep it alive (macOS)
   persnallyd config set-key <key>   Store the Anthropic API key (owner-only file) for the daemon
@@ -171,13 +172,8 @@ async function main() {
                     console.error(`· Context hook skipped: ${e instanceof Error ? e.message : e}`);
                 }
             }
-            console.log(`\nDone${imported ? ` — ${imported} events imported` : ""}. Dashboard: http://127.0.0.1:${port}`);
-            if (process.platform === "darwin" && process.stdout.isTTY) {
-                try {
-                    execFileSync("open", [`http://127.0.0.1:${port}`]);
-                }
-                catch { /* non-fatal */ }
-            }
+            console.log(`\nDone${imported ? ` — ${imported} events imported` : ""}.`);
+            announceDashboard(port);
             return;
         }
         case "scope": {
@@ -483,19 +479,43 @@ async function main() {
             const existing = runningPid();
             if (existing)
                 return die(`daemon already running (pid ${existing})`);
-            const pid = await startDetached(process.argv[1], parsePort(args));
-            console.log(`persnallyd started (pid ${pid}). Dashboard: http://127.0.0.1:${parsePort(args)}`);
+            const port = parsePort(args);
+            const pid = await startDetached(process.argv[1], port);
+            console.log(`persnallyd started (pid ${pid}).`);
+            announceDashboard(port);
             console.log(`Logs: ${LOG_FILE}`);
             return;
         }
         case "stop": {
             if (autostartInstalled()) {
-                console.error("Note: autostart is installed — launchd will restart the daemon. Use `persnallyd autostart --remove` to stop it permanently.");
+                console.error("Note: autostart is installed — launchd will respawn the daemon. To restart cleanly use `persnallyd restart`; to stop it for good use `persnallyd autostart --remove`.");
             }
             const pid = await stopDaemon();
             console.log(pid ? `Stopped daemon (pid ${pid}).` : "Daemon was not running.");
             return;
         }
+        case "restart": {
+            const port = parsePort(args);
+            if (autostartInstalled()) {
+                // launchd owns the lifecycle — a plain stop just gets respawned. Reload the
+                // job so it comes back on the current install (also heals a drifted plist path).
+                const health = await reloadAutostart(process.argv[1], port);
+                if (health) {
+                    console.log(`Restarted via launchd — daemon up on v${health.version}.`);
+                    announceDashboard(port);
+                }
+                else {
+                    console.log("Reloaded autostart; daemon is still coming up — check: persnallyd status");
+                }
+            }
+            else {
+                await stopDaemon();
+                const pid = await startDetached(process.argv[1], port);
+                console.log(`persnallyd restarted (pid ${pid}).`);
+                announceDashboard(port);
+            }
+            return;
+        }
         case "autostart": {
             if (args[0] === "--remove") {
                 console.log(removeAutostart() ? "Autostart removed; daemon stopped." : "Autostart was not installed.");
@@ -507,6 +527,7 @@ async function main() {
                 console.log(`Stopped existing daemon (pid ${stopped}) — launchd takes over.`);
             const plist = installAutostart(process.argv[1], parsePort(args));
             console.log(`Autostart installed (${plist}). The daemon now runs at login and restarts if it exits.`);
+            announceDashboard(parsePort(args), false); // launchd brings it up async — show the link, don't open a not-yet-ready page
             return;
         }
         case "serve": {
@@ -553,6 +574,17 @@ function summarize(payload) {
     const s = JSON.stringify(payload);
     return s.length > 80 ? s.slice(0, 77) + "..." : s;
 }
+/** Print the dashboard URL and, when run interactively on macOS, open it. */
+function announceDashboard(port, open = true) {
+    const url = `http://127.0.0.1:${port}`;
+    console.log(`Dashboard: ${url}`);
+    if (open && process.platform === "darwin" && process.stdout.isTTY) {
+        try {
+            execFileSync("open", [url]);
+        }
+        catch { /* non-fatal — the link is printed above */ }
+    }
+}
 function die(msg) {
     console.error(msg);
     process.exit(1);

package/build/src/lifecycle.d.ts

@@ -12,3 +12,13 @@ export declare function stopDaemon(): Promise<number | null>;
 export declare function autostartInstalled(): boolean;
 export declare function installAutostart(cliPath: string, port: number): string;
 export declare function removeAutostart(): boolean;
+/**
+ * Reload the launchd job so the daemon restarts on the currently-installed build.
+ * `unload` then `load` — a plain `load` can't replace an already-loaded job, which
+ * is how a plist path silently drifts from the running process. Rewriting from the
+ * caller's cliPath also heals that drift. Returns the new daemon's /health once it
+ * answers, or null if it didn't come up in time.
+ */
+export declare function reloadAutostart(cliPath: string, port: number): Promise<{
+    version: string;
+} | null>;

package/build/src/lifecycle.js

@@ -118,6 +118,27 @@ export function removeAutostart() {
     rmSync(PLIST_PATH);
     return true;
 }
+/**
+ * Reload the launchd job so the daemon restarts on the currently-installed build.
+ * `unload` then `load` — a plain `load` can't replace an already-loaded job, which
+ * is how a plist path silently drifts from the running process. Rewriting from the
+ * caller's cliPath also heals that drift. Returns the new daemon's /health once it
+ * answers, or null if it didn't come up in time.
+ */
+export async function reloadAutostart(cliPath, port) {
+    removeAutostart();
+    installAutostart(cliPath, port);
+    for (let i = 0; i < 30; i++) {
+        await sleep(100);
+        try {
+            const r = await fetch(`http://127.0.0.1:${port}/health`);
+            if (r.ok)
+                return (await r.json());
+        }
+        catch { /* launchd hasn't brought it up yet */ }
+    }
+    return null;
+}
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "persnally",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "license": "FSL-1.1-MIT",
   "description": "Your own context engine — local-first, across every AI. So every AI finally knows you.",
   "type": "module",