@lightupai/polaris 0.0.106 → 0.0.110

package/hooks/statusline.sh

@@ -24,6 +24,44 @@ if [ -n "$CC_SESSION_ID" ]; then
   CONNECTED=$(echo "$STATUS" | jq -r '.connected' 2>/dev/null || echo "false")
 fi
 
+# --- Update check (cached, non-blocking) ---
+# Reads installed version from the MCP package, caches the latest npm version
+# for up to 1 hour. Background curl refresh never blocks the status line.
+UPDATE_MSG=""
+INSTALLED_PKG="$HOME/.polaris/mcp/node_modules/@lightupai/polaris/package.json"
+UPDATE_CACHE="$HOME/.polaris/update-check.json"
+
+if [ -f "$INSTALLED_PKG" ]; then
+  INSTALLED_VERSION=$(jq -r '.version // ""' "$INSTALLED_PKG" 2>/dev/null || echo "")
+
+  CACHED_LATEST=""
+  if [ -f "$UPDATE_CACHE" ]; then
+    CACHED_LATEST=$(jq -r '.latest // ""' "$UPDATE_CACHE" 2>/dev/null || echo "")
+    CACHE_TS=$(jq -r '.checked // 0' "$UPDATE_CACHE" 2>/dev/null || echo "0")
+    NOW=$(date +%s 2>/dev/null || echo "0")
+    CACHE_AGE=$(( NOW - CACHE_TS )) 2>/dev/null || CACHE_AGE=9999
+    STALE=false
+    [ "$CACHE_AGE" -gt 3600 ] 2>/dev/null && STALE=true
+  else
+    STALE=true
+  fi
+
+  if [ "$STALE" = "true" ]; then
+    # Refresh in background — never blocks the status line
+    (
+      LATEST_V=$(curl -sf --max-time 5 "https://registry.npmjs.org/@lightupai/polaris/latest" 2>/dev/null \
+        | jq -r '.version // ""' 2>/dev/null)
+      if [ -n "$LATEST_V" ]; then
+        printf '{"latest":"%s","checked":%s}\n' "$LATEST_V" "$(date +%s)" > "$UPDATE_CACHE"
+      fi
+    ) &
+  fi
+
+  if [ -n "$CACHED_LATEST" ] && [ -n "$INSTALLED_VERSION" ] && [ "$CACHED_LATEST" != "$INSTALLED_VERSION" ]; then
+    UPDATE_MSG=" [update available: v${CACHED_LATEST}]"
+  fi
+fi
+
 if [ "$CONNECTED" = "true" ]; then
   PROJECT=$(echo "$STATUS" | jq -r '.project' 2>/dev/null)
   SESSION=$(echo "$STATUS" | jq -r '.session' 2>/dev/null)
@@ -35,10 +73,10 @@ if [ "$CONNECTED" = "true" ]; then
     ACCOUNT_TAG="[${ACCOUNT}] "
   fi
   if [ -n "$SLACK" ]; then
-    echo "polaris: ${ACCOUNT_TAG}${PROJECT}/${SESSION} (${USER}) #${SLACK}"
+    echo "polaris: ${ACCOUNT_TAG}${PROJECT}/${SESSION} (${USER}) #${SLACK}${UPDATE_MSG}"
   else
-    echo "polaris: ${ACCOUNT_TAG}${PROJECT}/${SESSION} (${USER})"
+    echo "polaris: ${ACCOUNT_TAG}${PROJECT}/${SESSION} (${USER})${UPDATE_MSG}"
   fi
 else
-  echo "polaris: not connected"
+  echo "polaris: not connected${UPDATE_MSG}"
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightupai/polaris",
-  "version": "0.0.106",
+  "version": "0.0.110",
   "description": "Record and stream Claude Code sessions to Slack. Like Gong for AI coding — capture every prompt, response, and tool call. Multiplayer collaboration across AI coding agents.",
   "keywords": [
     "claude-code",

package/src/cli/cli.ts

@@ -275,7 +275,52 @@ async function removeSystemdService(): Promise<void> {
 }
 
 // Platform dispatcher
+// --- Session state migration ---
+//
+// When upgrading from a pre-0.0.109 daemon (which never wrote daemon-state.json),
+// the new daemon would start with an empty session map and drop every connected
+// session. This function fetches the running daemon's session list via GET /status
+// and writes daemon-state.json before the daemon is stopped, so the new daemon
+// can restore the map and reconnect cloud WebSockets without any user action.
+// Best-effort: failures are silent (daemon may not be running, or already migrated).
+async function migrateSessionState(): Promise<void> {
+  const stateFile = join(POLARIS_DIR, "sessions", "daemon-state.json");
+  // If a 0.0.109+ daemon already wrote the file, its state is more complete
+  // (includes learned hook aliases) — don't overwrite it.
+  try { await readFile(stateFile); return; } catch { /* doesn't exist — proceed */ }
+
+  try {
+    const config = await loadConfig();
+    const secret = resolveDaemonSecret(config);
+    const headers: Record<string, string> = {};
+    if (secret) headers["x-polaris-daemon-secret"] = secret;
+    const res = await fetch("http://127.0.0.1:4322/status", {
+      headers,
+      signal: AbortSignal.timeout(2000),
+    });
+    if (!res.ok) return;
+    const data = await res.json() as { sessions?: Array<{ ccSessionId: string; project: string; session: string; user: string }> };
+    if (!data.sessions || data.sessions.length === 0) return;
+
+    const activeProfile = config?.active || "";
+    const sessions = data.sessions.map((s) => ({
+      ccSessionId: s.ccSessionId,
+      project: s.project,
+      session: s.session,
+      user: s.user,
+      agent: "agent:claude",
+      profile: activeProfile,
+    }));
+
+    await mkdir(join(POLARIS_DIR, "sessions"), { recursive: true });
+    await writeFile(stateFile, JSON.stringify({ sessions }));
+    console.log(`  ✓ Migrated ${sessions.length} active session(s) to persistent state`);
+  } catch { /* best-effort — daemon not running or unreachable */ }
+}
+
 async function installDaemonService(daemonSecret?: string): Promise<void> {
+  // Migrate session state from older daemon before it is stopped
+  await migrateSessionState();
   if (process.platform === "darwin") return installLaunchAgent(daemonSecret);
   if (process.platform === "linux") return installSystemdService(daemonSecret);
   // Windows and others: no managed service; daemon is started manually
@@ -428,8 +473,8 @@ async function install(participantId?: string) {
   const skillContent = `---
 name: polaris
 description: Connect to a Polaris multiplayer collaboration session
-allowed-tools: polaris_connect polaris_disconnect polaris_status polaris_reply polaris_context polaris_rename polaris_rename_session
-argument-hint: [join #channel [session-name] | rename <new-name> | rename-session <name> | disconnect | (no args for status)]
+allowed-tools: polaris_connect polaris_disconnect polaris_status polaris_reply polaris_context polaris_rename polaris_rename_session polaris_update
+argument-hint: [join #channel [session-name] | rename <new-name> | rename-session <name> | disconnect | update | (no args for status)]
 ---
 
 ## Polaris — Multiplayer Collaboration
@@ -453,6 +498,10 @@ Based on the arguments provided, do ONE of the following:
 1. Call \`polaris_rename_session\` with the new name
 2. Report the result
 
+**\`/polaris update\`** — Update Polaris to the latest version:
+1. Call \`polaris_update\`
+2. Report what changed and remind the user to restart Claude Code if the MCP server was updated
+
 **\`/polaris disconnect\`** — Disconnect:
 1. Call \`polaris_disconnect\`
 2. Confirm disconnection
@@ -571,8 +620,8 @@ async function login(appUrl: string, profileName?: string, loginHint?: string) {
   const skillContent = `---
 name: polaris
 description: Connect to a Polaris multiplayer collaboration session
-allowed-tools: polaris_connect polaris_disconnect polaris_status polaris_reply polaris_context polaris_rename polaris_rename_session
-argument-hint: [join #channel [session-name] | rename <new-name> | rename-session <name> | disconnect | (no args for status)]
+allowed-tools: polaris_connect polaris_disconnect polaris_status polaris_reply polaris_context polaris_rename polaris_rename_session polaris_update
+argument-hint: [join #channel [session-name] | rename <new-name> | rename-session <name> | disconnect | update | (no args for status)]
 ---
 
 ## Polaris — Multiplayer Collaboration
@@ -596,6 +645,10 @@ Based on the arguments provided, do ONE of the following:
 1. Call \`polaris_rename_session\` with the new name
 2. Report the result
 
+**\`/polaris update\`** — Update Polaris to the latest version:
+1. Call \`polaris_update\`
+2. Report what changed and remind the user to restart Claude Code if the MCP server was updated
+
 **\`/polaris disconnect\`** — Disconnect:
 1. Call \`polaris_disconnect\`
 2. Confirm disconnection

package/src/client/client.ts

@@ -195,6 +195,14 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: {},
       },
     },
+    {
+      name: "polaris_update",
+      description: "Update Polaris to the latest version. Runs npm install -g then polaris install to refresh hooks and the MCP server.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {},
+      },
+    },
     {
       name: "polaris_backfill",
       description: "Recover lost events from local daemon logs. Use when events were lost due to disconnection or API downtime.",
@@ -466,6 +474,49 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     }
   }
 
+  if (name === "polaris_update") {
+    const installedPkgPath = `${homedir()}/.polaris/mcp/node_modules/@lightupai/polaris/package.json`;
+    let currentVersion = "";
+    try {
+      const pkg = JSON.parse(await readFile(installedPkgPath, "utf-8")) as { version: string };
+      currentVersion = pkg.version ?? "";
+    } catch { /* package not installed yet */ }
+
+    let latestVersion = "";
+    try {
+      const res = await fetch("https://registry.npmjs.org/@lightupai/polaris/latest", { signal: AbortSignal.timeout(5000) });
+      if (res.ok) ({ version: latestVersion } = await res.json() as { version: string });
+    } catch { /* network unavailable */ }
+
+    if (!latestVersion) {
+      return { content: [{ type: "text", text: "Could not reach npm to check for updates. Check your network connection." }] };
+    }
+    if (latestVersion === currentVersion) {
+      return { content: [{ type: "text", text: `Polaris is already up to date (v${currentVersion}).` }] };
+    }
+
+    // Update the copy that's actually in use: ~/.polaris/mcp (no sudo required).
+    // This is the same location the version was read from, and where the daemon
+    // and MCP server binaries are resolved by run-daemon.sh and claude mcp add.
+    const mcpDir = `${homedir()}/.polaris/mcp`;
+    const npmResult = Bun.spawnSync(
+      ["npm", "install", "--prefix", mcpDir, `@lightupai/polaris@${latestVersion}`],
+      { stdout: "pipe", stderr: "pipe" }
+    );
+    if (npmResult.exitCode !== 0) {
+      return { content: [{ type: "text", text: `Update failed:\n${npmResult.stderr.toString().trim()}` }] };
+    }
+
+    // Refresh hooks, migrate session state, and restart the daemon using the
+    // local polaris binary (not relying on PATH, which may not include it).
+    const polarisBin = `${mcpDir}/node_modules/.bin/polaris`;
+    const installResult = Bun.spawnSync([polarisBin, "install"], { stdout: "pipe", stderr: "pipe" });
+    const msg = installResult.exitCode === 0
+      ? `Updated Polaris from v${currentVersion} to v${latestVersion}.\n\nRestart Claude Code for the new MCP server to take effect.`
+      : `Updated package to v${latestVersion}, but \`polaris install\` failed — run it manually.\n${installResult.stderr.toString().trim()}`;
+    return { content: [{ type: "text", text: msg }] };
+  }
+
   throw new Error(`Unknown tool: ${name}`);
 });
 

package/src/daemon/daemon.ts

@@ -328,6 +328,93 @@ async function logSessionChange(action: "connect" | "disconnect" | "ws-drop", cc
   } catch { /* best-effort */ }
 }
 
+// --- Session persistence ---
+//
+// The daemon writes its session map to ~/.polaris/sessions/daemon-state.json
+// after every mutation, and reloads it on startup. This makes daemon restarts
+// (e.g. during `polaris update`) invisible to connected sessions: the new daemon
+// loads the map and re-opens cloud WebSocket connections before serving requests.
+//
+// Persistence is only active when the daemon is run as main (import.meta.main).
+// Tests that call startDaemon() in-process never enable it, so developer state
+// is never overwritten by the test suite.
+
+const SESSIONS_DIR = join(homedir(), ".polaris", "sessions");
+const DAEMON_STATE_FILE = join(SESSIONS_DIR, "daemon-state.json");
+let persistenceEnabled = false;
+
+interface PersistedSession {
+  ccSessionId: string;
+  project: string;
+  session: string;
+  user: string;
+  agent: string;
+  profile: string;
+  slackChannel?: string;
+}
+
+async function persistSessions(): Promise<void> {
+  if (!persistenceEnabled) return;
+  try {
+    await mkdir(SESSIONS_DIR, { recursive: true });
+    const active: PersistedSession[] = [];
+    for (const m of sessions.values()) {
+      if (!m.project) continue; // skip empty stubs from /register
+      active.push({
+        ccSessionId: m.ccSessionId,
+        project: m.project,
+        session: m.session,
+        user: m.user,
+        agent: m.agent,
+        profile: m.profile,
+        ...(m.slackChannel ? { slackChannel: m.slackChannel } : {}),
+      });
+    }
+    await writeFile(DAEMON_STATE_FILE, JSON.stringify({ sessions: active }));
+  } catch { /* best-effort */ }
+}
+
+async function loadPersistedSessions(): Promise<void> {
+  try {
+    const data = JSON.parse(await readFile(DAEMON_STATE_FILE, "utf-8")) as { sessions: PersistedSession[] };
+    if (!Array.isArray(data.sessions)) return;
+
+    // Populate the sessions map
+    for (const s of data.sessions) {
+      if (!s.ccSessionId || !s.project || !s.session) continue;
+      sessions.set(s.ccSessionId, {
+        ccSessionId: s.ccSessionId,
+        project: s.project,
+        session: s.session,
+        user: s.user,
+        agent: s.agent,
+        profile: s.profile || "",
+        slackChannel: s.slackChannel,
+        ws: null,
+        pendingMapping: false, // aliases are already known — no claiming needed
+      });
+    }
+
+    // Open one cloud WebSocket per (project, session) pair; alias entries share it
+    const primaryForPair = new Map<string, SessionMapping>();
+    for (const mapping of sessions.values()) {
+      if (!mapping.project) continue;
+      const key = `${mapping.project}/${mapping.session}`;
+      if (!primaryForPair.has(key)) {
+        primaryForPair.set(key, mapping);
+        connectCloudWs(mapping);
+      } else {
+        mapping.ws = primaryForPair.get(key)!.ws;
+      }
+    }
+
+    const count = Array.from(sessions.values()).filter((m) => m.project).length;
+    if (count > 0) {
+      console.error(`polaris daemon: restored ${count} mapping(s) across ${primaryForPair.size} session(s)`);
+    }
+  } catch { /* no state file — fresh start */ }
+}
+
 // --- Delivery checkpoint ---
 //
 // After each successful event relay, the daemon writes a tiny checkpoint file
@@ -335,8 +422,6 @@ async function logSessionChange(action: "connect" | "disconnect" | "ws-drop", cc
 // where {hash} is the same SHA-256 prefix used by the client. On reconnect,
 // the checkpoint is used to auto-backfill the gap without any manual action.
 
-const SESSIONS_DIR = join(homedir(), ".polaris", "sessions");
-
 function checkpointPath(ccSessionId: string): string {
   const hash = createHash("sha256").update(ccSessionId).digest("hex").slice(0, 16);
   return join(SESSIONS_DIR, `${hash}-checkpoint.json`);
@@ -693,6 +778,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
             void unlink(checkpointPath(mapping.ccSessionId)).catch(() => {});
           }
 
+          void persistSessions();
           return json({
             status: "connected",
             project: mapping.project,
@@ -722,6 +808,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
           }
           // Clear checkpoint — a deliberate disconnect means there is nothing to recover
           void unlink(checkpointPath(body.ccSessionId)).catch(() => {});
+          void persistSessions();
           return json({ status: "disconnected" });
         } catch {
           return error("Invalid JSON", 400);
@@ -739,6 +826,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
         }
         sessions.clear();
         injectQueues.clear();
+        void persistSessions();
         return json({ status: "all_disconnected" });
       }
 
@@ -773,6 +861,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
               mapping.pendingMapping = false;
               // Register under the real CC session ID for future events
               sessions.set(ccSessionId, { ...mapping, ccSessionId });
+              void persistSessions();
               console.error(`[daemon] Mapped CC session ${ccSessionId.slice(0, 8)} → ${mapping.project}/${mapping.session}`);
               // Share the inject queue between the original ccSessionId (where the
               // cloud WS enqueues) and this CC hook session_id alias, so injected
@@ -880,7 +969,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
               m.slackChannel = body.newName;
             }
           }
-
+          void persistSessions();
           return json({ status: "renamed", oldName: body.oldName, newName: body.newName });
         } catch {
           return error("Invalid JSON", 400);
@@ -911,6 +1000,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
 
           const oldName = mapping.session;
           mapping.session = body.newName;
+          void persistSessions();
           return json({ status: "renamed", oldName, newName: body.newName });
         } catch {
           return error("Invalid JSON", 400);
@@ -928,6 +1018,7 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
               m.slackChannel = body.slackChannel;
             }
           }
+          void persistSessions();
           return json({ status: "updated" });
         } catch {
           return error("Invalid JSON", 400);
@@ -1135,6 +1226,11 @@ if (import.meta.main) {
   // Load config before starting so getServiceUrl() has the active profile
   // (and getDaemonSecret() the configured daemonSecret)
   await loadConfig();
+  // Enable session persistence (only when running as main, never in tests)
+  persistenceEnabled = true;
+  // Restore sessions from disk before opening the port — new daemon is ready
+  // to serve hook events immediately, before clients notice the restart
+  await loadPersistedSessions();
   // Replay any events left in the outbox by a previous daemon run
   await scanOutbox();
   const { server } = startDaemon();