@limeadelabs/launchpad-mcp 1.1.0 → 1.2.0

package/dist/index.js

@@ -20,8 +20,8 @@ var LaunchPadClient = class {
     this.apiKey = config.apiKey;
     this.timeoutMs = config.timeoutMs ?? 1e4;
   }
-  async request(method, path, body) {
-    const url = `${this.baseUrl}/api/v1${path}`;
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}/api/v1${path2}`;
     const res = await fetch(url, {
       method,
       headers: {
@@ -34,7 +34,7 @@ var LaunchPadClient = class {
     if (!res.ok) {
       const error = await res.json().catch(() => ({ error: res.statusText }));
       throw new LaunchPadError(
-        `${method} ${path}: ${res.status} \u2014 ${error.error || res.statusText}`,
+        `${method} ${path2}: ${res.status} \u2014 ${error.error || res.statusText}`,
         res.status
       );
     }
@@ -107,16 +107,35 @@ var LaunchPadClient = class {
     if (params?.limit !== void 0) searchParams.set("limit", String(params.limit));
     if (params?.offset !== void 0) searchParams.set("offset", String(params.offset));
     const query = searchParams.toString();
-    return this.request("GET", `/context_entries${query ? `?${query}` : ""}`);
+    return this.request("GET", `/contexts${query ? `?${query}` : ""}`);
   }
   getContextEntry(identifier) {
-    return this.request("GET", `/context_entries/${encodeURIComponent(identifier)}`);
+    return this.request("GET", `/contexts/${encodeURIComponent(identifier)}`);
   }
   getTaskContextPackage(taskId) {
     return this.request("GET", `/tasks/${taskId}/context`);
   }
   updateContextEntry(identifier, data) {
-    return this.request("PATCH", `/context_entries/${encodeURIComponent(identifier)}`, data);
+    return this.request("PATCH", `/contexts/${encodeURIComponent(identifier)}`, data);
+  }
+  createSession(taskId, agentType, agentId) {
+    return this.request("POST", "/sessions", {
+      task_id: taskId,
+      agent_type: agentType ?? "claude_code",
+      ...agentId !== void 0 && { agent_id: agentId }
+    });
+  }
+  sessionHeartbeat(sessionId) {
+    return this.request("POST", `/sessions/${sessionId}/heartbeat`);
+  }
+  updateSession(sessionId, data) {
+    return this.request("PATCH", `/sessions/${sessionId}`, data);
+  }
+  createSessionEvent(sessionId, eventType, payload) {
+    return this.request("POST", `/sessions/${sessionId}/events`, {
+      event_type: eventType,
+      payload
+    });
   }
 };
 
@@ -468,7 +487,7 @@ function registerContextTools(server2, client2) {
   );
   server2.tool(
     "lp_context_package",
-    "Get the assembled context package for a task \u2014 org entries, project entries, specs, comments",
+    "Get the assembled context package for a task \u2014 task details, context entries, specs, pages, comments",
     {
       task_id: z8.number().describe("Task ID")
     },
@@ -511,6 +530,191 @@ function registerContextTools(server2, client2) {
   );
 }
 
+// src/tools/sessions.ts
+import { z as z9 } from "zod";
+
+// src/session-store.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var SESSION_FILE = path.join(os.homedir(), ".launchpad", "active-session.json");
+function saveSession(taskId, sessionId) {
+  const dir = path.dirname(SESSION_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const data = fs.existsSync(SESSION_FILE) ? JSON.parse(fs.readFileSync(SESSION_FILE, "utf8")) : {};
+  data[String(taskId)] = sessionId;
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+function getSessionId(taskId) {
+  if (!fs.existsSync(SESSION_FILE)) return null;
+  const data = JSON.parse(fs.readFileSync(SESSION_FILE, "utf8"));
+  return data[String(taskId)] ?? null;
+}
+function clearSession(taskId) {
+  if (!fs.existsSync(SESSION_FILE)) return;
+  const data = JSON.parse(fs.readFileSync(SESSION_FILE, "utf8"));
+  delete data[String(taskId)];
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+
+// src/tools/sessions.ts
+function registerSessionTools(server2, client2) {
+  server2.tool(
+    "lp_session_start",
+    "Start a new agent session for a task. Creates session via API and saves session_id to disk for later lookup.",
+    {
+      task_id: z9.number().describe("LaunchPad task ID"),
+      agent_type: z9.string().optional().describe("Agent type (default: claude_code)")
+    },
+    async ({ task_id, agent_type }) => {
+      try {
+        const result = await client2.createSession(task_id, agent_type);
+        saveSession(task_id, result.session.id);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_heartbeat",
+    "Send a heartbeat for an active session. Provide session_id directly or task_id to look up session from disk. Graceful no-op if neither provided.",
+    {
+      session_id: z9.number().optional().describe("Session ID"),
+      task_id: z9.number().optional().describe("Task ID to look up session from disk")
+    },
+    async ({ session_id, task_id }) => {
+      try {
+        const resolvedId = session_id ?? (task_id !== void 0 ? getSessionId(task_id) : null);
+        if (resolvedId === null) {
+          return {
+            content: [{ type: "text", text: "No active session found. Provide session_id or task_id." }]
+          };
+        }
+        const result = await client2.sessionHeartbeat(resolvedId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_progress",
+    'Report progress on an active session. Sends an activity update with action "progress".',
+    {
+      session_id: z9.number().describe("Session ID"),
+      detail: z9.string().describe("Description of progress made")
+    },
+    async ({ session_id, detail }) => {
+      try {
+        const result = await client2.updateSession(session_id, {
+          activity: { action: "progress", detail }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_event",
+    "Log a discrete event for a session (commit, ci_pass, ci_fail, pr_opened, blocker, cost_update).",
+    {
+      session_id: z9.number().describe("Session ID"),
+      event_type: z9.enum(["commit", "ci_pass", "ci_fail", "pr_opened", "blocker", "cost_update"]).describe("Type of event"),
+      payload: z9.record(z9.unknown()).describe("Event payload data")
+    },
+    async ({ session_id, event_type, payload }) => {
+      try {
+        const result = await client2.createSessionEvent(session_id, event_type, payload);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_blocked",
+    'Mark a session as blocked. Updates status to "blocked" and logs a blocker event.',
+    {
+      session_id: z9.number().describe("Session ID"),
+      reason: z9.string().describe("Reason the session is blocked")
+    },
+    async ({ session_id, reason }) => {
+      try {
+        const [sessionResult, eventResult] = await Promise.all([
+          client2.updateSession(session_id, { status: "blocked" }),
+          client2.createSessionEvent(session_id, "blocker", { reason })
+        ]);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ session: sessionResult.session, event: eventResult.event }, null, 2)
+          }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_complete",
+    "Mark a session as completed with a result summary. Clears session from disk.",
+    {
+      session_id: z9.number().describe("Session ID"),
+      result_summary: z9.string().describe("Summary of what was accomplished"),
+      task_id: z9.number().optional().describe("Task ID to clear from disk (if not provided, derived from session)")
+    },
+    async ({ session_id, result_summary, task_id }) => {
+      try {
+        const result = await client2.updateSession(session_id, {
+          status: "completed",
+          result_summary
+        });
+        const resolvedTaskId = task_id ?? result.session.task_id;
+        clearSession(resolvedTaskId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+  server2.tool(
+    "lp_session_fail",
+    "Mark a session as failed with an error detail. Clears session from disk.",
+    {
+      session_id: z9.number().describe("Session ID"),
+      error_detail: z9.string().describe("Description of the failure"),
+      task_id: z9.number().optional().describe("Task ID to clear from disk (if not provided, derived from session)")
+    },
+    async ({ session_id, error_detail, task_id }) => {
+      try {
+        const result = await client2.updateSession(session_id, {
+          status: "failed",
+          result_summary: error_detail
+        });
+        const resolvedTaskId = task_id ?? result.session.task_id;
+        clearSession(resolvedTaskId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return handleError(error, client2.timeoutMs);
+      }
+    }
+  );
+}
+
 // src/resources/project-context.ts
 function registerProjectContextResource(server2, client2) {
   server2.resource(
@@ -625,6 +829,7 @@ function registerContextEntriesResource(server2, client2) {
         throw new Error(`Invalid URI: ${uri.href}`);
       }
       const slug = decodeURIComponent(uri.pathname.slice(1));
+      if (!slug) throw new Error("Empty slug in context entry URI");
       const result = await client2.getContextEntry(slug);
       const entry = result.entry;
       const text = [
@@ -654,13 +859,13 @@ function registerContextEntriesResource(server2, client2) {
 }
 
 // src/prompts/start-task.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function registerStartTaskPrompt(server2) {
   server2.prompt(
     "lp_start_task",
     "Guided workflow: find a task, claim it, get context, start working",
     {
-      project_id: z9.string().optional().describe("Optional project ID to filter tasks")
+      project_id: z10.string().optional().describe("Optional project ID to filter tasks")
     },
     async (args) => {
       const projectLine = args.project_id ? ` Project ID: ${args.project_id}.` : "";
@@ -690,14 +895,14 @@ IMPORTANT: If this task takes more than 20 minutes, call lp_heartbeat every 20 m
 }
 
 // src/prompts/submit-task.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function registerSubmitTaskPrompt(server2) {
   server2.prompt(
     "lp_submit_task",
     "Guided workflow: mark task done, add summary comment, release claim",
     {
-      task_id: z10.string().describe("Task ID to submit"),
-      summary: z10.string().describe("Summary of what was completed")
+      task_id: z11.string().describe("Task ID to submit"),
+      summary: z11.string().describe("Summary of what was completed")
     },
     async (args) => {
       return {
@@ -746,7 +951,7 @@ try {
 }
 var server = new McpServer({
   name: "launchpad",
-  version: "1.1.0"
+  version: "1.2.0"
 });
 registerBootstrapTool(server, client);
 registerProjectTools(server, client);
@@ -757,6 +962,7 @@ registerTimeTools(server, client);
 registerPromptTools(server, client);
 registerPageTools(server, client);
 registerContextTools(server, client);
+registerSessionTools(server, client);
 registerProjectContextResource(server, client);
 registerTaskSpecResource(server, client);
 registerContextEntriesResource(server, client);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limeadelabs/launchpad-mcp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "LaunchPad MCP server for Claude Code — AI-native project management integration",
   "type": "module",
   "exports": {