@openlap/openlap 1.0.0

package/dist/auth.d.ts

@@ -0,0 +1,17 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { OAuthClientMetadata, OAuthClientInformationFull, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+export declare class FileOAuthProvider implements OAuthClientProvider {
+    authCode: string | null;
+    get redirectUrl(): URL;
+    get clientMetadata(): OAuthClientMetadata;
+    clientInformation(): Promise<OAuthClientInformationFull | undefined>;
+    saveClientInformation(info: OAuthClientInformationFull): Promise<void>;
+    tokens(): Promise<OAuthTokens | undefined>;
+    saveTokens(tokens: OAuthTokens): Promise<void>;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    saveCodeVerifier(codeVerifier: string): Promise<void>;
+    codeVerifier(): Promise<string>;
+    private waitForCallback;
+}
+export declare function hasToken(): boolean;
+export declare function clearAuth(): void;

package/dist/auth.js

@@ -0,0 +1,109 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createServer } from "http";
+const CONFIG_DIR = join(homedir(), ".openlap");
+const AUTH_FILE = join(CONFIG_DIR, "auth.json");
+function load() {
+    if (!existsSync(AUTH_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function save(data) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2));
+}
+const CALLBACK_PORT = 19284;
+export class FileOAuthProvider {
+    // Captured auth code from callback, used by proxy to call finishAuth
+    authCode = null;
+    get redirectUrl() {
+        return new URL(`http://127.0.0.1:${CALLBACK_PORT}/callback`);
+    }
+    get clientMetadata() {
+        return {
+            client_name: "openlap",
+            redirect_uris: [`http://127.0.0.1:${CALLBACK_PORT}/callback`],
+            grant_types: ["authorization_code"],
+            response_types: ["code"],
+        };
+    }
+    async clientInformation() {
+        return load().client;
+    }
+    async saveClientInformation(info) {
+        const data = load();
+        data.client = info;
+        save(data);
+    }
+    async tokens() {
+        return load().tokens;
+    }
+    async saveTokens(tokens) {
+        const data = load();
+        data.tokens = tokens;
+        save(data);
+    }
+    async redirectToAuthorization(authorizationUrl) {
+        process.stderr.write(`\nOpening browser for authentication...\n`);
+        process.stderr.write(`If the browser doesn't open, visit:\n${authorizationUrl.toString()}\n\n`);
+        const { default: openUrl } = await import("open");
+        await openUrl(authorizationUrl.toString());
+        // Wait for callback and capture auth code
+        this.authCode = await this.waitForCallback();
+    }
+    async saveCodeVerifier(codeVerifier) {
+        const data = load();
+        data.codeVerifier = codeVerifier;
+        save(data);
+    }
+    async codeVerifier() {
+        return load().codeVerifier ?? "";
+    }
+    waitForCallback() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                server.close();
+                reject(new Error("OAuth callback timed out after 2 minutes"));
+            }, 120_000);
+            const server = createServer((req, res) => {
+                if (!req.url?.startsWith("/callback")) {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                const url = new URL(req.url, `http://127.0.0.1:${CALLBACK_PORT}`);
+                const code = url.searchParams.get("code");
+                if (!code) {
+                    const error = url.searchParams.get("error") ?? "no code received";
+                    res.writeHead(400, { "Content-Type": "text/html" });
+                    res.end(`<html><body><h2>Authentication failed: ${error}</h2></body></html>`);
+                    clearTimeout(timeout);
+                    server.close();
+                    reject(new Error(`OAuth failed: ${error}`));
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end("<html><body><h2>Authenticated. You can close this tab.</h2></body></html>");
+                clearTimeout(timeout);
+                server.close();
+                resolve(code);
+            });
+            server.listen(CALLBACK_PORT, "127.0.0.1");
+        });
+    }
+}
+export function hasToken() {
+    const data = load();
+    return !!data.tokens?.access_token;
+}
+export function clearAuth() {
+    if (existsSync(AUTH_FILE)) {
+        writeFileSync(AUTH_FILE, "{}");
+    }
+}

package/dist/feed.d.ts

@@ -0,0 +1,23 @@
+interface TrackUpdate {
+    id: string;
+    project_name: string;
+    body: string;
+    health: string;
+    created_at: string;
+}
+type UpdateCallback = (tag: string, update: TrackUpdate) => void;
+export declare class FeedManager {
+    private baseUrl;
+    private streams;
+    private seenIds;
+    private callback;
+    constructor(baseUrl: string, callback: UpdateCallback);
+    /**
+     * Subscribe to a tag's feed if not already subscribed.
+     */
+    subscribe(tag: string): void;
+    private connect;
+    private readStream;
+    stop(): void;
+}
+export {};

package/dist/feed.js

@@ -0,0 +1,110 @@
+// Experimental: dynamic SSE feed subscription.
+// Auto-subscribes when agent uses get_track or post_update with a tag.
+export class FeedManager {
+    baseUrl;
+    streams = new Map();
+    seenIds = new Set();
+    callback;
+    constructor(baseUrl, callback) {
+        this.baseUrl = baseUrl;
+        this.callback = callback;
+    }
+    /**
+     * Subscribe to a tag's feed if not already subscribed.
+     */
+    subscribe(tag) {
+        if (this.streams.has(tag))
+            return;
+        process.stderr.write(`[openlap] subscribed to feed: ${tag} (experimental)\n`);
+        const controller = new AbortController();
+        this.streams.set(tag, controller);
+        this.connect(tag, controller);
+    }
+    connect(tag, controller) {
+        const url = `${this.baseUrl}/feed/${tag}/sse`;
+        fetch(url, { signal: controller.signal })
+            .then((res) => {
+            if (!res.ok || !res.body) {
+                throw new Error(`SSE connect failed: ${res.status}`);
+            }
+            return this.readStream(tag, res.body, controller);
+        })
+            .catch((err) => {
+            if (err.name === "AbortError")
+                return;
+            // Reconnect after 5s
+            if (this.streams.has(tag)) {
+                setTimeout(() => this.connect(tag, controller), 5000);
+            }
+        });
+    }
+    async readStream(tag, 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 === "") {
+                        if (eventType === "update" && eventData && eventId) {
+                            if (!this.seenIds.has(eventId)) {
+                                this.seenIds.add(eventId);
+                                // Cap at 500
+                                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(eventData);
+                                    this.callback(tag, update);
+                                }
+                                catch {
+                                    // skip malformed
+                                }
+                            }
+                        }
+                        eventType = "";
+                        eventData = "";
+                        eventId = "";
+                    }
+                }
+            }
+        }
+        catch {
+            // stream ended
+        }
+        // Reconnect if still subscribed
+        if (this.streams.has(tag) && !controller.signal.aborted) {
+            setTimeout(() => this.connect(tag, controller), 5000);
+        }
+    }
+    stop() {
+        for (const [, controller] of this.streams) {
+            controller.abort();
+        }
+        this.streams.clear();
+    }
+}

package/dist/git.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Detect project (owner/repo) from git remote origin.
+ */
+export declare function detectProject(): string | null;
+/**
+ * Auto-save: git add, commit, push before post_update.
+ * Returns the commit message used, or null if nothing to commit.
+ */
+export declare function autoSave(body: string): string | null;

package/dist/git.js

@@ -0,0 +1,56 @@
+import { execSync } from "child_process";
+/**
+ * Detect project (owner/repo) from git remote origin.
+ */
+export function detectProject() {
+    try {
+        const remote = execSync("git remote get-url origin", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        // Handle SSH: git@github.com:owner/repo.git
+        const sshMatch = remote.match(/git@[^:]+:(.+?)(?:\.git)?$/);
+        if (sshMatch)
+            return sshMatch[1];
+        // Handle HTTPS: https://github.com/owner/repo.git
+        const httpsMatch = remote.match(/https?:\/\/[^/]+\/(.+?)(?:\.git)?$/);
+        if (httpsMatch)
+            return httpsMatch[1];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Auto-save: git add, commit, push before post_update.
+ * Returns the commit message used, or null if nothing to commit.
+ */
+export function autoSave(body) {
+    try {
+        // Stage all changes
+        execSync("git add -A", { stdio: "pipe" });
+        // Check if there are staged changes
+        try {
+            execSync("git diff --cached --quiet", { stdio: "pipe" });
+            return null; // nothing staged
+        }
+        catch {
+            // diff --cached --quiet exits 1 when there are changes
+        }
+        // Commit with first line of update body as message
+        const msg = body.split("\n")[0].slice(0, 72);
+        execSync(`git commit -m ${JSON.stringify(msg)}`, { stdio: "pipe" });
+        // Push (best effort)
+        try {
+            execSync("git push", { stdio: "pipe" });
+        }
+        catch {
+            // push failure shouldn't block the update
+        }
+        return msg;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { execSync } from "child_process";
+const command = process.argv[2];
+// -- Setup subcommand: adds MCP server to Claude Code -----------------------
+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;
+        try {
+            execSync(`claude mcp add -s user openlap -- npx -y @openlap/openlap`, { stdio: "pipe" });
+            added = true;
+            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;
+            }
+            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
+            }
+        }
+        console.log("");
+        console.log("Done. Open Claude Code -- first message triggers GitHub login.");
+    }
+    catch {
+        console.error("Failed to add MCP server. Is Claude Code installed?");
+        process.exit(1);
+    }
+    process.exit(0);
+}
+// -- Login subcommand: force re-authentication ------------------------------
+if (command === "login") {
+    const { clearAuth } = await import("./auth.js");
+    clearAuth();
+    console.log("Cleared stored credentials. Next Claude Code session will re-authenticate.");
+    process.exit(0);
+}
+// -- Help -------------------------------------------------------------------
+if (command === "help" || command === "--help" || command === "-h") {
+    console.log("Usage: npx @openlap/openlap <command>");
+    console.log("");
+    console.log("Commands:");
+    console.log("  setup    Add openlap MCP server to Claude Code");
+    console.log("  login    Clear stored credentials and re-authenticate");
+    console.log("  help     Show this help");
+    console.log("");
+    console.log("When run without arguments, starts the MCP proxy server (used by Claude Code).");
+    process.exit(0);
+}
+// -- Default: run as MCP proxy server (called by Claude Code) ---------------
+if (command && command !== "serve") {
+    console.error(`Unknown command: ${command}`);
+    console.error("Run 'npx @openlap/openlap help' for usage.");
+    process.exit(1);
+}
+const { startProxy } = await import("./proxy.js");
+await startProxy();

package/dist/proxy.d.ts

@@ -0,0 +1 @@
+export declare function startProxy(): Promise<void>;

package/dist/proxy.js

@@ -0,0 +1,114 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { FileOAuthProvider } from "./auth.js";
+import { detectProject, autoSave } from "./git.js";
+import { FeedManager } from "./feed.js";
+const BASE_URL = process.env.ANYLAP_URL ?? "https://openlap.app";
+// Tools that accept a 'project' parameter
+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",
+]);
+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 {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[openlap] auth error: ${msg}\n`);
+            process.exit(1);
+        }
+    }
+    // -- Auto-detect project from git remote ----------------------------------
+    const detectedProject = detectProject();
+    if (detectedProject) {
+        process.stderr.write(`[openlap] project: ${detectedProject}\n`);
+    }
+    // -- Local MCP server (stdio) ---------------------------------------------
+    const server = new Server({ name: "openlap", version: "1.0.0" }, {
+        capabilities: {
+            tools: {},
+            experimental: { "claude/channel": {} },
+        },
+    });
+    // -- Experimental: dynamic feed subscription ------------------------------
+    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}`;
+        process.stderr.write(`[openlap] feed ${tag}: ${content}\n`);
+        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`);
+            }
+        });
+    });
+    // Forward tool listing from remote
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const result = await remote.listTools();
+        return { tools: result.tools };
+    });
+    // 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
+        if (detectedProject && PROJECT_TOOLS.has(name) && !args.project) {
+            args.project = detectedProject;
+        }
+        // Auto-save before post_update
+        if (name === "post_update" && typeof args.body === "string") {
+            const saved = autoSave(args.body);
+            if (saved) {
+                process.stderr.write(`[openlap] auto-saved: ${saved}\n`);
+            }
+        }
+        // Forward to remote
+        const result = await remote.callTool({ name, arguments: args });
+        // Experimental: auto-subscribe to feeds from tool usage
+        if (typeof args.tag === "string" && args.tag) {
+            feeds.subscribe(args.tag);
+        }
+        if (name === "get_track" && typeof args.name === "string" && args.name) {
+            feeds.subscribe(args.name);
+        }
+        if (name === "create_track" && typeof args.name === "string" && args.name) {
+            feeds.subscribe(args.name);
+        }
+        return {
+            content: result.content,
+            isError: result.isError,
+        };
+    });
+    // -- Start stdio transport ------------------------------------------------
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@openlap/openlap",
+  "version": "1.0.0",
+  "description": "Local MCP proxy for openlap.app -- auto-save, live feeds, project detection, one install",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "openlap": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "npx tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "open": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wildreason/openlap"
+  },
+  "keywords": [
+    "claude-code",
+    "mcp",
+    "openlap",
+    "agent-coordination"
+  ]
+}