@lightupai/polaris 0.0.100 → 0.0.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightupai/polaris",
-  "version": "0.0.100",
+  "version": "0.0.102",
   "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/client/client.ts

@@ -47,14 +47,18 @@ async function daemonGet(path: string): Promise<Response> {
 // --- Session state persistence ---
 
 function sessionStatePath(): string {
-  const hash = createHash("sha256").update(process.cwd()).digest("hex").slice(0, 16);
+  // Keyed by CC session ID so two Claude Code sessions in the same directory
+  // get independent state files and never auto-reconnect into each other's
+  // project. Previously keyed by cwd hash, which caused unrelated sessions to
+  // silently inherit another session's project connection (#154, #153).
+  const hash = createHash("sha256").update(CC_SESSION_ID).digest("hex").slice(0, 16);
   return `${homedir()}/.polaris/sessions/${hash}.json`;
 }
 
 async function saveSessionState(project: string, session: string, user: string, profile: string): Promise<void> {
   try {
     await mkdir(`${homedir()}/.polaris/sessions`, { recursive: true });
-    await writeFile(sessionStatePath(), JSON.stringify({ project, session, user, profile, cwd: process.cwd() }));
+    await writeFile(sessionStatePath(), JSON.stringify({ project, session, user, profile, cwd: process.cwd(), ccSessionId: CC_SESSION_ID }));
   } catch { /* best-effort */ }
 }
 
@@ -188,6 +192,7 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: {
           duration: { type: "string", description: "Time range to backfill (e.g., '2h', '30m', '1d'). Auto-detects if omitted." },
           from: { type: "string", description: "ISO timestamp to backfill from. Overrides duration." },
+          dry_run: { type: "boolean", description: "If true, report how many events would be sent without actually sending them." },
         },
       },
     },
@@ -393,16 +398,20 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     if (!currentProject) {
       return { content: [{ type: "text", text: "Not connected to a Polaris session. Use polaris_connect first." }] };
     }
-    const { duration, from } = (args ?? {}) as { duration?: string; from?: string };
+    const { duration, from, dry_run } = (args ?? {}) as { duration?: string; from?: string; dry_run?: boolean };
     try {
       const res = await daemonPost("/backfill", {
         ccSessionId: CC_SESSION_ID,
         ...(duration ? { duration } : {}),
         ...(from ? { from } : {}),
+        ...(dry_run ? { dry_run: true } : {}),
       });
-      const body = await res.json() as { recovered: number; source: string; gaps: string[] };
+      const body = await res.json() as { recovered: number; would_recover?: number; source: string; gaps: string[] };
       if (res.ok) {
         const gapInfo = body.gaps.length > 0 ? `\nGaps: ${body.gaps.join(", ")}` : "";
+        if (dry_run) {
+          return { content: [{ type: "text", text: `Dry run: ${body.would_recover ?? 0} events in daemon log would be sent.${gapInfo}` }] };
+        }
         return { content: [{ type: "text", text: `Backfill complete: ${body.recovered} events recovered from ${body.source}.${gapInfo}` }] };
       }
       return { content: [{ type: "text", text: `Backfill failed: ${(body as unknown as { error?: string }).error ?? "unknown error"}` }] };
@@ -456,6 +465,34 @@ async function main() {
     }
   }
 
+  // Heartbeat: check every 60s whether the daemon still has our session mapped.
+  // If not (dropped WS, daemon restart, compaction), silently re-connect so
+  // activity reaches the channel without a manual /polaris join.
+  setInterval(async () => {
+    if (!currentProject) return; // not connected — nothing to heartbeat
+    try {
+      const res = await daemonGet(`/status/${CC_SESSION_ID}`);
+      const body = await res.json() as { connected?: boolean; project?: string; session?: string };
+      if (body.connected) return; // all good
+      // Daemon lost the mapping — attempt to reconnect to the same session
+      const reconnectRes = await daemonPost("/connect", {
+        ccSessionId: CC_SESSION_ID,
+        project: currentProject,
+        session: currentSession,
+        user: currentUser,
+        profile: currentProfile,
+      });
+      if (reconnectRes.ok) {
+        console.error(`Polaris: session dropped; auto-reconnected to #${currentProject}/${currentSession}`);
+      } else {
+        console.error(`Polaris: session dropped and reconnect failed. Run /polaris to check status.`);
+        currentProject = "";
+        currentSession = "";
+        currentUser = "";
+      }
+    } catch { /* daemon unreachable — will retry next heartbeat */ }
+  }, 60_000);
+
   // inject delivery is handled via the UserPromptSubmit hook (see daemon injectQueues); claude/channel push deferred
 
   const transport = new StdioServerTransport();

package/src/daemon/daemon.ts

@@ -15,6 +15,7 @@ interface SessionMapping {
   slackChannel?: string;
   ws: WebSocket | null;
   pendingMapping?: boolean; // true until the first hook event from this shell claims the mapping
+  closingIntentionally?: boolean; // set before deliberate ws.close() so onclose can distinguish drops
 }
 
 function generateSessionName(): string {
@@ -164,14 +165,18 @@ function connectCloudWs(mapping: SessionMapping) {
   };
 
   ws.onclose = () => {
-    // Reconnect if still registered
-    if (sessions.has(mapping.ccSessionId) && sessions.get(mapping.ccSessionId)!.project === mapping.project) {
+    const m = sessions.get(mapping.ccSessionId);
+    if (m && m.project === mapping.project && mapping.project !== "" && !m.closingIntentionally) {
+      // Unexpected cloud WS drop — log it so the user has a record
+      void logSessionChange("ws-drop", mapping.ccSessionId, mapping.project, mapping.session, mapping.user, mapping.agent);
       setTimeout(() => {
-        if (sessions.has(mapping.ccSessionId)) {
-          connectCloudWs(sessions.get(mapping.ccSessionId)!);
+        const current = sessions.get(mapping.ccSessionId);
+        if (current && current.project) {
+          connectCloudWs(current);
         }
       }, 3000);
     }
+    if (m) m.closingIntentionally = false;
   };
 
   ws.onerror = () => {
@@ -184,6 +189,7 @@ function connectCloudWs(mapping: SessionMapping) {
 function disconnectCloudWs(ccSessionId: string) {
   const mapping = sessions.get(ccSessionId);
   if (mapping?.ws) {
+    mapping.closingIntentionally = true;
     mapping.ws.close();
     mapping.ws = null;
   }
@@ -310,7 +316,7 @@ async function scanOutbox(): Promise<void> {
 
 const SESSION_HISTORY_FILE = join(homedir(), ".polaris", "session-history.jsonl");
 
-async function logSessionChange(action: "connect" | "disconnect", ccSessionId: string, project: string, session: string, user: string, agent: string): Promise<void> {
+async function logSessionChange(action: "connect" | "disconnect" | "ws-drop", ccSessionId: string, project: string, session: string, user: string, agent: string): Promise<void> {
   try {
     await ensureLogDir();
     const entry = JSON.stringify({ t: new Date().toISOString(), action, ccSessionId, project, session, user, agent });
@@ -320,7 +326,7 @@ async function logSessionChange(action: "connect" | "disconnect", ccSessionId: s
 
 // --- Backfill: recover lost events from daemon log ---
 
-async function backfill(mapping: SessionMapping, duration?: string, from?: string): Promise<{ recovered: number; source: string; gaps: string[] }> {
+async function backfill(mapping: SessionMapping, duration?: string, from?: string, dryRun = false): Promise<{ recovered: number; would_recover?: number; source: string; gaps: string[] }> {
   const now = new Date();
   let since: Date;
 
@@ -389,6 +395,11 @@ async function backfill(mapping: SessionMapping, duration?: string, from?: strin
     return { recovered: 0, source: "daemon_log", gaps: [`no log entries found since ${since.toISOString()}`] };
   }
 
+  // Dry-run: report how many events would be sent without actually sending
+  if (dryRun) {
+    return { recovered: 0, would_recover: logEntries.length, source: "daemon_log", gaps: [] };
+  }
+
   // Replay events to the API
   let recovered = 0;
   const serviceUrl = getServiceUrlForProfile(mapping.profile);
@@ -929,12 +940,12 @@ export function startDaemon(port = Number(process.env.POLARIS_DAEMON_PORT ?? 432
       // POST /backfill — recover lost events from daemon log
       if (method === "POST" && pathname === "/backfill") {
         try {
-          const body = (await req.json()) as { ccSessionId: string; duration?: string; from?: string };
+          const body = (await req.json()) as { ccSessionId: string; duration?: string; from?: string; dry_run?: boolean };
           if (!body.ccSessionId) return error("ccSessionId required", 400);
           const mapping = sessions.get(body.ccSessionId);
           if (!mapping || !mapping.project) return error("Not connected", 400);
 
-          const result = await backfill(mapping, body.duration, body.from);
+          const result = await backfill(mapping, body.duration, body.from, body.dry_run ?? false);
           return json(result);
         } catch {
           return error("Invalid JSON", 400);