@openlap/openlap 1.1.1 → 1.1.3

package/dist/channel.d.ts

@@ -33,7 +33,6 @@ export declare class ChannelManager {
     private onPresence;
     private getToken;
     private mySessionId;
-    private heartbeatInterval;
     constructor(baseUrl: string, onUpdate: UpdateCallback, getToken: () => string | undefined, onPresence?: PresenceCallback);
     setSessionId(sessionId: string): void;
     join(channel: string, name?: string): Promise<JoinResponse | null>;
@@ -43,6 +42,8 @@ export declare class ChannelManager {
     getFocusedChannel(): string | undefined;
     isJoined(channel: string): boolean;
     isMuted(channel: string): boolean;
+    hasChannels(): boolean;
+    heartbeat(): Promise<void>;
     private connectSSE;
     private readStream;
     private handleSSEEvent;

package/dist/channel.js

@@ -9,7 +9,6 @@ export class ChannelManager {
     onPresence;
     getToken;
     mySessionId;
-    heartbeatInterval = null;
     constructor(baseUrl, onUpdate, getToken, onPresence) {
         this.baseUrl = baseUrl;
         this.onUpdate = onUpdate;
@@ -39,6 +38,10 @@ export class ChannelManager {
             }
             const data = (await res.json());
             process.stderr.write(`[openlap] joined ${channel} (${data.present?.length ?? 0} present)\n`);
+            // Set session_id for echo suppression BEFORE opening SSE (fixes race condition)
+            if (data.session_id) {
+                this.mySessionId = data.session_id;
+            }
             // Start SSE subscription
             const controller = new AbortController();
             this.channels.set(channel, { controller, muted: false, focused: false });
@@ -118,6 +121,24 @@ export class ChannelManager {
     isMuted(channel) {
         return this.channels.get(channel)?.muted ?? false;
     }
+    hasChannels() {
+        return this.channels.size > 0;
+    }
+    // Public heartbeat -- called by proxy on every tool invocation.
+    async heartbeat() {
+        const token = this.getToken();
+        if (!token)
+            return;
+        try {
+            await fetch(`${this.baseUrl}/api/presence/heartbeat`, {
+                method: "POST",
+                headers: { "Authorization": `Bearer ${token}` },
+            });
+        }
+        catch {
+            // not critical
+        }
+    }
     // SSE connection for a channel
     connectSSE(channel, controller) {
         const url = `${this.baseUrl}/feed/${channel}/sse`;
@@ -221,30 +242,13 @@ export class ChannelManager {
             }
         }
     }
-    // Heartbeat: POST /api/presence/heartbeat every 30s
+    // Immediate heartbeat on join. Ongoing heartbeats piggyback on tool calls
+    // (setInterval doesn't fire reliably in MCP stdio context).
     startHeartbeat() {
-        if (this.heartbeatInterval)
-            return;
-        this.heartbeatInterval = setInterval(async () => {
-            const token = this.getToken();
-            if (!token)
-                return;
-            try {
-                await fetch(`${this.baseUrl}/api/presence/heartbeat`, {
-                    method: "POST",
-                    headers: { "Authorization": `Bearer ${token}` },
-                });
-            }
-            catch {
-                // heartbeat failure is not critical
-            }
-        }, 30_000);
+        this.heartbeat().catch(() => { });
     }
     stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
+        // No interval to clear -- heartbeats piggyback on tool calls
     }
     stop() {
         this.stopHeartbeat();

package/dist/proxy.js

@@ -180,7 +180,19 @@ export async function startProxy() {
             if (!channel)
                 return { content: [{ type: "text", text: "channel required" }], isError: true };
             const result = await channels.join(channel, args.name);
-            return { content: [{ type: "text", text: JSON.stringify(result ?? { error: "already joined or failed" }) }] };
+            // session_id set internally by ChannelManager.join (before SSE opens)
+            if (!result)
+                return { content: [{ type: "text", text: JSON.stringify({ error: "already joined or failed" }) }] };
+            const r = result;
+            const lines = [`Joined ${channel}.`];
+            if (r.feed_url)
+                lines.push(`Feed: ${r.feed_url}`);
+            if (r.present?.length)
+                lines.push(`Present: ${r.present.join(", ")}`);
+            if (r.recent?.length)
+                lines.push(`Recent: ${r.recent.length} posts`);
+            lines.push("", JSON.stringify(result));
+            return { content: [{ type: "text", text: lines.join("\n") }] };
         }
         if (name === "leave_channel") {
             const channel = args.channel;
@@ -218,6 +230,10 @@ export async function startProxy() {
                 process.stderr.write(`[openlap] auto-saved: ${saved}\n`);
             }
         }
+        // -- Heartbeat on every tool call (replaces unreliable setInterval) ------
+        if (channels.hasChannels()) {
+            channels.heartbeat().catch(() => { });
+        }
         // -- Forward to remote --------------------------------------------------
         const result = await remote.callTool({ name, arguments: args });
         // v1 compat: auto-subscribe to feeds from track tool usage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlap/openlap",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Local MCP proxy for openlap.app -- auto-save, live feeds, project detection, one install",
   "type": "module",
   "main": "dist/index.js",