@openlap/openlap 1.0.1 → 1.1.1

package/dist/channel.d.ts

@@ -0,0 +1,53 @@
+interface ChannelUpdate {
+    id: string;
+    session_id?: string;
+    project_name: string;
+    display_name?: string;
+    body: string;
+    health: string;
+    created_at: string;
+}
+interface PresenceEvent {
+    action: "join" | "leave" | "timeout";
+    display_name: string;
+    channel: string;
+}
+interface JoinResponse {
+    channel: string;
+    present: string[];
+    recent: Array<{
+        id: string;
+        project_name?: string;
+        body: string;
+        health: string;
+        created_at: string;
+    }>;
+}
+type UpdateCallback = (channel: string, update: ChannelUpdate) => void;
+type PresenceCallback = (channel: string, event: PresenceEvent) => void;
+export declare class ChannelManager {
+    private baseUrl;
+    private channels;
+    private seenIds;
+    private onUpdate;
+    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>;
+    leave(channel: string): Promise<void>;
+    mute(channel: string): boolean;
+    focus(channel: string): boolean;
+    getFocusedChannel(): string | undefined;
+    isJoined(channel: string): boolean;
+    isMuted(channel: string): boolean;
+    private connectSSE;
+    private readStream;
+    private handleSSEEvent;
+    private startHeartbeat;
+    private stopHeartbeat;
+    stop(): void;
+}
+export {};

package/dist/channel.js

@@ -0,0 +1,256 @@
+// v2: ChannelManager replaces FeedManager.
+// Adds: join/leave via server API, mute/focus as local state,
+// heartbeat loop, echo suppression by session_id.
+export class ChannelManager {
+    baseUrl;
+    channels = new Map();
+    seenIds = new Set();
+    onUpdate;
+    onPresence;
+    getToken;
+    mySessionId;
+    heartbeatInterval = null;
+    constructor(baseUrl, onUpdate, getToken, onPresence) {
+        this.baseUrl = baseUrl;
+        this.onUpdate = onUpdate;
+        this.onPresence = onPresence;
+        this.getToken = getToken;
+    }
+    setSessionId(sessionId) {
+        this.mySessionId = sessionId;
+    }
+    // join calls the server API to register presence, then opens SSE.
+    async join(channel, name) {
+        if (this.channels.has(channel))
+            return null;
+        const token = this.getToken();
+        const headers = { "Content-Type": "application/json" };
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
+        try {
+            const res = await fetch(`${this.baseUrl}/api/channels/${encodeURIComponent(channel)}/join`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ name: name ?? undefined }),
+            });
+            if (!res.ok) {
+                process.stderr.write(`[openlap] join ${channel} failed: ${res.status}\n`);
+                return null;
+            }
+            const data = (await res.json());
+            process.stderr.write(`[openlap] joined ${channel} (${data.present?.length ?? 0} present)\n`);
+            // Start SSE subscription
+            const controller = new AbortController();
+            this.channels.set(channel, { controller, muted: false, focused: false });
+            this.connectSSE(channel, controller);
+            // Start heartbeat if first channel
+            if (this.channels.size === 1) {
+                this.startHeartbeat();
+            }
+            return data;
+        }
+        catch (err) {
+            process.stderr.write(`[openlap] join ${channel} error: ${err}\n`);
+            return null;
+        }
+    }
+    // leave calls the server API to remove presence, then closes SSE.
+    async leave(channel) {
+        const state = this.channels.get(channel);
+        if (!state)
+            return;
+        state.controller.abort();
+        this.channels.delete(channel);
+        // Stop heartbeat if no channels
+        if (this.channels.size === 0) {
+            this.stopHeartbeat();
+        }
+        const token = this.getToken();
+        const headers = {};
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
+        try {
+            await fetch(`${this.baseUrl}/api/channels/${encodeURIComponent(channel)}/leave`, {
+                method: "POST",
+                headers,
+            });
+            process.stderr.write(`[openlap] left ${channel}\n`);
+        }
+        catch {
+            // best effort
+        }
+    }
+    // mute stops forwarding notifications but stays present (heartbeat continues).
+    mute(channel) {
+        const state = this.channels.get(channel);
+        if (!state)
+            return false;
+        state.muted = true;
+        process.stderr.write(`[openlap] muted ${channel}\n`);
+        return true;
+    }
+    // focus unmutes a channel and sets it as the focused channel for briefings.
+    focus(channel) {
+        const state = this.channels.get(channel);
+        if (!state)
+            return false;
+        // Unmute the focused channel
+        state.focused = true;
+        state.muted = false;
+        // Unfocus all others (only one focused at a time)
+        for (const [name, s] of this.channels) {
+            if (name !== channel)
+                s.focused = false;
+        }
+        process.stderr.write(`[openlap] focused ${channel}\n`);
+        return true;
+    }
+    getFocusedChannel() {
+        for (const [name, state] of this.channels) {
+            if (state.focused)
+                return name;
+        }
+        return undefined;
+    }
+    isJoined(channel) {
+        return this.channels.has(channel);
+    }
+    isMuted(channel) {
+        return this.channels.get(channel)?.muted ?? false;
+    }
+    // SSE connection for a channel
+    connectSSE(channel, controller) {
+        const url = `${this.baseUrl}/feed/${channel}/sse`;
+        const headers = {};
+        const token = this.getToken();
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
+        fetch(url, { headers, signal: controller.signal })
+            .then((res) => {
+            if (!res.ok || !res.body)
+                throw new Error(`SSE connect failed: ${res.status}`);
+            return this.readStream(channel, res.body, controller);
+        })
+            .catch((err) => {
+            if (err.name === "AbortError")
+                return;
+            if (this.channels.has(channel)) {
+                setTimeout(() => this.connectSSE(channel, controller), 5000);
+            }
+        });
+    }
+    async readStream(channel, body, controller) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let eventType = "";
+        let eventData = "";
+        let eventId = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (line.startsWith("event: ")) {
+                        eventType = line.slice(7);
+                    }
+                    else if (line.startsWith("data: ")) {
+                        eventData = line.slice(6);
+                    }
+                    else if (line.startsWith("id: ")) {
+                        eventId = line.slice(4);
+                    }
+                    else if (line === "") {
+                        this.handleSSEEvent(channel, eventType, eventData, eventId);
+                        eventType = "";
+                        eventData = "";
+                        eventId = "";
+                    }
+                }
+            }
+        }
+        catch {
+            // stream ended
+        }
+        // Reconnect if still joined
+        if (this.channels.has(channel) && !controller.signal.aborted) {
+            setTimeout(() => this.connectSSE(channel, controller), 5000);
+        }
+    }
+    handleSSEEvent(channel, eventType, data, id) {
+        if (eventType === "update" && data && id) {
+            if (this.seenIds.has(id))
+                return;
+            this.seenIds.add(id);
+            // Cap seen set
+            if (this.seenIds.size > 500) {
+                const iter = this.seenIds.values();
+                for (let i = 0; i < 100; i++)
+                    iter.next();
+                const toKeep = new Set();
+                for (const v of iter)
+                    toKeep.add(v);
+                this.seenIds = toKeep;
+            }
+            try {
+                const update = JSON.parse(data);
+                // Echo suppression: skip own posts
+                if (this.mySessionId && update.session_id === this.mySessionId)
+                    return;
+                // Mute check: skip if channel is muted
+                if (this.channels.get(channel)?.muted)
+                    return;
+                this.onUpdate(channel, update);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        if (eventType === "presence" && data) {
+            try {
+                const event = JSON.parse(data);
+                event.channel = channel;
+                this.onPresence?.(channel, event);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+    }
+    // Heartbeat: POST /api/presence/heartbeat every 30s
+    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);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    stop() {
+        this.stopHeartbeat();
+        for (const [, state] of this.channels) {
+            state.controller.abort();
+        }
+        this.channels.clear();
+    }
+}

package/dist/index.js

@@ -6,44 +6,37 @@ if (command === "setup") {
     console.log("Setting up openlap...");
     console.log("");
     try {
-        // Add new "openlap" entry first (safe -- if this fails, old config still works)
-        let added = false;
+        // Add MCP server entry
         try {
-            execSync(`claude mcp add -s user openlap -- npx -y @openlap/openlap`, { stdio: "pipe" });
-            added = true;
+            execSync(`claude mcp add -s user openlap -- openlap`, { stdio: "pipe" });
             console.log("Added openlap MCP server.");
         }
         catch (err) {
             const msg = err instanceof Error ? err.stderr?.toString() ?? err.message : String(err);
             if (msg.includes("already exists")) {
-                console.log("openlap MCP server already installed.");
-                added = true;
+                console.log("openlap MCP server already configured.");
             }
             else {
                 throw err;
             }
         }
-        // Only remove old entries after new one is confirmed
-        if (added) {
-            // Remove old "anylap" entry if present (migration from @openlap/anylap)
-            try {
-                execSync("claude mcp remove anylap", { stdio: "pipe" });
-                console.log("Migrated: removed old 'anylap' entry.");
-            }
-            catch {
-                // Not present, fine
-            }
-            // Remove old "lap" HTTP entry if present (migration from direct HTTP setup)
-            try {
-                execSync("claude mcp remove lap", { stdio: "pipe" });
-                console.log("Migrated: removed old 'lap' HTTP entry.");
-            }
-            catch {
-                // Not present, fine
-            }
+        // Remove old entries
+        try {
+            execSync("claude mcp remove anylap", { stdio: "pipe" });
+            console.log("Migrated: removed old 'anylap' entry.");
+        }
+        catch { }
+        try {
+            execSync("claude mcp remove lap", { stdio: "pipe" });
+            console.log("Migrated: removed old 'lap' HTTP entry.");
         }
+        catch { }
+        console.log("");
+        console.log("Done. Start Claude Code with live feeds:");
+        console.log("");
+        console.log("  claude --dangerously-load-development-channels");
         console.log("");
-        console.log("Done. Open Claude Code -- first message triggers GitHub login.");
+        console.log("First session triggers GitHub login in browser.");
     }
     catch {
         console.error("Failed to add MCP server. Is Claude Code installed?");
@@ -76,5 +69,26 @@ if (command && command !== "serve") {
     console.error("Run 'npx @openlap/openlap help' for usage.");
     process.exit(1);
 }
+// -- Auto-update -------------------------------------------------------------
+try {
+    const { readFileSync } = await import("fs");
+    const { join, dirname } = await import("path");
+    const { fileURLToPath } = await import("url");
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const current = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+    const latest = execSync("npm view @openlap/openlap version", {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (latest && latest !== current) {
+        process.stderr.write(`[openlap] updating ${current} -> ${latest}\n`);
+        execSync("npm install -g @openlap/openlap@latest", { stdio: "pipe", timeout: 30000 });
+        process.stderr.write(`[openlap] updated to ${latest}\n`);
+    }
+}
+catch {
+    // not critical
+}
 const { startProxy } = await import("./proxy.js");
 await startProxy();

package/dist/proxy.js

@@ -8,6 +8,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { FileOAuthProvider } from "./auth.js";
 import { detectProject, autoSave } from "./git.js";
+import { ChannelManager } from "./channel.js";
 import { FeedManager } from "./feed.js";
 const BASE_URL = process.env.OPENLAP_URL ?? "https://openlap.app";
 // Tools that accept a 'project' parameter
@@ -15,22 +16,32 @@ const PROJECT_TOOLS = new Set([
     "list_laps", "get_lap", "create_lap", "save_lap", "update_lap",
     "post_update", "list_updates",
     "create_project", "update_project", "remove_project",
+    "check_lap", "post_channel",
 ]);
+// v2 channel tools handled locally by the proxy
+const PROXY_CHANNEL_TOOLS = new Set([
+    "join_channel", "leave_channel", "mute_channel", "focus_channel",
+]);
+function getAuthToken() {
+    try {
+        const data = JSON.parse(readFileSync(join(homedir(), ".openlap", "auth.json"), "utf-8"));
+        return data?.tokens?.access_token;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function startProxy() {
     const authProvider = new FileOAuthProvider();
     // -- Connect to remote MCP server ----------------------------------------
     const remoteTransport = new StreamableHTTPClientTransport(new URL(`${BASE_URL}/mcp`), { authProvider });
     const remote = new Client({ name: "openlap-proxy", version: "1.0.0" }, { capabilities: {} });
-    // Try connecting -- if auth is needed, the provider opens the browser
     try {
         await remote.connect(remoteTransport);
     }
     catch (err) {
-        // After redirectToAuthorization, the SDK throws UnauthorizedError.
-        // We have the auth code from the callback -- finish the flow.
         if (authProvider.authCode) {
             await remoteTransport.finishAuth(authProvider.authCode);
-            // Retry connection
             await remote.connect(remoteTransport);
         }
         else {
@@ -39,7 +50,15 @@ export async function startProxy() {
             process.exit(1);
         }
     }
-    // -- Auto-detect project from git remote ----------------------------------
+    // -- Version + project -------------------------------------------------------
+    try {
+        const { dirname } = await import("path");
+        const { fileURLToPath } = await import("url");
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        const ver = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+        process.stderr.write(`[openlap] v${ver}\n`);
+    }
+    catch { }
     const detectedProject = detectProject();
     if (detectedProject) {
         process.stderr.write(`[openlap] project: ${detectedProject}\n`);
@@ -51,19 +70,19 @@ export async function startProxy() {
             experimental: { "claude/channel": {} },
         },
     });
-    // -- Experimental: dynamic feed subscription ------------------------------
-    const feeds = new FeedManager(BASE_URL, (tag, update) => {
+    // -- v2: ChannelManager ---------------------------------------------------
+    const channels = new ChannelManager(BASE_URL, (channel, update) => {
         const who = update.project_name || "unknown";
         const health = update.health && update.health !== "on_track" ? ` [${update.health}]` : "";
-        const content = `[${who}]${health} ${update.body}`;
-        process.stderr.write(`[openlap] feed ${tag}: ${content}\n`);
+        const displayName = update.display_name ? `${update.display_name}` : who;
+        const content = `[${channel}] ${displayName}${health}: ${update.body}`;
         server.notification({
             method: "notifications/claude/channel",
             params: {
                 content,
                 meta: {
                     update_id: update.id,
-                    tag,
+                    tag: channel,
                     created_at: update.created_at,
                     health: update.health ?? "on_track",
                 },
@@ -73,47 +92,149 @@ export async function startProxy() {
                 process.stderr.write(`[openlap] notification error: ${err}\n`);
             }
         });
-    }, () => {
-        // Provide auth token for SSE feed connections
-        try {
-            const data = JSON.parse(readFileSync(join(homedir(), ".openlap", "auth.json"), "utf-8"));
-            return data?.tokens?.access_token;
-        }
-        catch {
-            return undefined;
-        }
+    }, getAuthToken, (channel, event) => {
+        // Presence events
+        const content = `[${channel}] ${event.display_name} ${event.action === "join" ? "joined" : event.action === "timeout" ? "timed out" : "left"}`;
+        server.notification({
+            method: "notifications/claude/channel",
+            params: { content, meta: { tag: channel, action: event.action } },
+        }).catch(() => { });
     });
-    // Forward tool listing from remote
+    // -- v1 compat: FeedManager for old track subscriptions -------------------
+    const feeds = new FeedManager(BASE_URL, (tag, update) => {
+        const who = update.project_name || "unknown";
+        const health = update.health && update.health !== "on_track" ? ` [${update.health}]` : "";
+        const content = `[${who}]${health} ${update.body}`;
+        server.notification({
+            method: "notifications/claude/channel",
+            params: {
+                content,
+                meta: { update_id: update.id, tag, created_at: update.created_at, health: update.health ?? "on_track" },
+            },
+        }).catch((err) => {
+            if (!String(err).includes("Not connected")) {
+                process.stderr.write(`[openlap] notification error: ${err}\n`);
+            }
+        });
+    }, getAuthToken);
+    // Forward tool listing from remote + inject proxy-side channel tools
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         const result = await remote.listTools();
-        return { tools: result.tools };
+        // v2: proxy-side channel tools (not registered on server)
+        const proxyTools = [
+            {
+                name: "join_channel",
+                description: "Join a channel. Registers presence, opens SSE subscription, returns who's here and recent posts. You'll receive live updates from this channel. Use leave_channel to unsubscribe.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        channel: { type: "string", description: "Channel name (e.g. \"openlap-v2\")" },
+                        name: { type: "string", description: "Display name (defaults to GitHub login). Use for role names like \"worker\" or \"adversary\"." },
+                    },
+                    required: ["channel"],
+                },
+            },
+            {
+                name: "leave_channel",
+                description: "Leave a channel. Removes presence and stops SSE subscription. Other members see you leave.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        channel: { type: "string", description: "Channel name" },
+                    },
+                    required: ["channel"],
+                },
+            },
+            {
+                name: "mute_channel",
+                description: "Mute a channel. Still present (heartbeat continues) but notifications stop. Other members still see you as present. Use focus_channel to unmute.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        channel: { type: "string", description: "Channel name" },
+                    },
+                    required: ["channel"],
+                },
+            },
+            {
+                name: "focus_channel",
+                description: "Focus on a channel. Unmutes it and pins it to briefings. Only one channel can be focused at a time.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        channel: { type: "string", description: "Channel name" },
+                    },
+                    required: ["channel"],
+                },
+            },
+        ];
+        return { tools: [...result.tools, ...proxyTools] };
     });
     // Forward tool calls with local enhancements
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
         const { name } = req.params;
         const args = { ...(req.params.arguments ?? {}) };
-        // Auto-inject project if not provided and detectable
+        // -- v2 proxy-side channel tools (handled locally) ----------------------
+        if (name === "join_channel") {
+            const channel = args.channel;
+            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" }) }] };
+        }
+        if (name === "leave_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            await channels.leave(channel);
+            return { content: [{ type: "text", text: JSON.stringify({ status: "left", channel }) }] };
+        }
+        if (name === "mute_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            const ok = channels.mute(channel);
+            return { content: [{ type: "text", text: ok ? `Muted ${channel}. Still present, notifications paused.` : `Not in ${channel}.` }] };
+        }
+        if (name === "focus_channel") {
+            const channel = args.channel;
+            if (!channel)
+                return { content: [{ type: "text", text: "channel required" }], isError: true };
+            const ok = channels.focus(channel);
+            return { content: [{ type: "text", text: ok ? `Focused on ${channel}. Unmuted and pinned to briefings.` : `Not in ${channel}.` }] };
+        }
+        // -- Auto-inject project ------------------------------------------------
         if (detectedProject && PROJECT_TOOLS.has(name) && !args.project) {
             args.project = detectedProject;
         }
-        // Auto-save before post_update
-        if (name === "post_update" && typeof args.body === "string") {
+        // -- Auto-inject channel from project for post_channel ------------------
+        if (name === "post_channel" && !args.channel && detectedProject) {
+            args.channel = detectedProject;
+        }
+        // -- Auto-save before post_update and post_channel ----------------------
+        if ((name === "post_update" || name === "post_channel") && typeof args.body === "string") {
             const saved = autoSave(args.body);
             if (saved) {
                 process.stderr.write(`[openlap] auto-saved: ${saved}\n`);
             }
         }
-        // Forward to remote
+        // -- Forward to remote --------------------------------------------------
         const result = await remote.callTool({ name, arguments: args });
-        // Experimental: auto-subscribe to feeds from tool usage
+        // v1 compat: auto-subscribe to feeds from track tool usage
         if (typeof args.tag === "string" && args.tag) {
-            feeds.subscribe(args.tag);
+            if (!channels.isJoined(args.tag)) {
+                feeds.subscribe(args.tag);
+            }
         }
         if (name === "get_track" && typeof args.name === "string" && args.name) {
-            feeds.subscribe(args.name);
+            if (!channels.isJoined(args.name)) {
+                feeds.subscribe(args.name);
+            }
         }
         if (name === "create_track" && typeof args.name === "string" && args.name) {
-            feeds.subscribe(args.name);
+            if (!channels.isJoined(args.name)) {
+                feeds.subscribe(args.name);
+            }
         }
         return {
             content: result.content,

package/package.json

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