@lightupai/polaris 0.0.105 → 0.0.109

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.105",
+  "version": "0.0.109",
   "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

@@ -428,8 +428,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 +453,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 +575,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 +600,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,41 @@ 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 global binary
+    const npmResult = Bun.spawnSync(["npm", "install", "-g", "@lightupai/polaris@latest"], { stdout: "pipe", stderr: "pipe" });
+    if (npmResult.exitCode !== 0) {
+      return { content: [{ type: "text", text: `Update failed:\n${npmResult.stderr.toString().trim()}` }] };
+    }
+
+    // Refresh hooks, MCP package, and daemon registration
+    const installResult = Bun.spawnSync(["polaris", "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 global binary 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`);
@@ -402,6 +487,16 @@ async function backfill(mapping: SessionMapping, duration?: string, from?: strin
     }
   }
 
+  // Collect all CC session IDs that belong to this mapping (MCP UUID + any hook alias).
+  // Both the MCP client's UUID and the CC hook session_id (if they differ) must match.
+  const knownCcIds = new Set<string>();
+  knownCcIds.add(mapping.ccSessionId);
+  for (const [id, m] of sessions) {
+    if (m.project === mapping.project && m.session === mapping.session) {
+      knownCcIds.add(id);
+    }
+  }
+
   // Read daemon log files covering the time range
   const logEntries: Array<{ t: string; endpoint: string; payload: Record<string, unknown>; project?: string; session?: string; ccSessionId?: string; response?: unknown }> = [];
   const startDate = since.toISOString().slice(0, 10);
@@ -426,14 +521,16 @@ async function backfill(mapping: SessionMapping, duration?: string, from?: strin
           if (entry.endpoint !== "/events") continue;
           if (new Date(entry.t) <= since) continue;
           if (new Date(entry.t) > now) continue;
-          // Filter by origin (added since v0.0.105). Old entries without these fields
-          // pass through for backwards compatibility with pre-105 logs.
-          if (entry.project !== undefined && entry.project !== mapping.project) continue;
-          if (entry.session !== undefined && entry.session !== mapping.session) continue;
-          if (entry.ccSessionId !== undefined && entry.ccSessionId !== mapping.ccSessionId) continue;
           // Skip error-response entries — they're duplicates of the primary entry
           // and would cause the same event to be replayed twice.
           if (entry.response !== undefined) continue;
+          // Filter by origin. New entries (v0.0.105+) have explicit context fields;
+          // old entries can be matched via payload.session_id. Both must belong to
+          // this mapping's known CC session IDs to prevent cross-session pollution.
+          const entrySessionId: string | undefined = entry.ccSessionId ?? entry.payload.session_id;
+          if (entrySessionId !== undefined && !knownCcIds.has(entrySessionId)) continue;
+          if (entry.project !== undefined && entry.project !== mapping.project) continue;
+          if (entry.session !== undefined && entry.session !== mapping.session) continue;
           logEntries.push(entry);
         } catch { /* skip malformed lines */ }
       }
@@ -681,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,
@@ -710,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);
@@ -727,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" });
       }
 
@@ -761,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
@@ -868,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);
@@ -899,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);
@@ -916,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);
@@ -1123,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();