@tobiashochguertel/taskbook-mcp-server 1.9.0

package/dist/index.js

@@ -0,0 +1,876 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/transport/stdio.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/client/crypto.ts
+var HEX_RE = /^[0-9a-fA-F]+$/;
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function base64Encode(data) {
+  let binary = "";
+  for (const byte of data) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function base64Decode(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function parseKeyBytes(key) {
+  const trimmed = key.trim();
+  if (trimmed.length === 64 && HEX_RE.test(trimmed)) {
+    return hexToBytes(trimmed);
+  }
+  return base64Decode(trimmed);
+}
+async function deriveKey(encryptionKey) {
+  const keyData = parseKeyBytes(encryptionKey);
+  if (keyData.length !== 32) {
+    throw new Error(`Invalid key length: expected 32 bytes, got ${keyData.length}`);
+  }
+  return crypto.subtle.importKey("raw", keyData.buffer, "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+async function encrypt(plaintext, key) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoded = new TextEncoder().encode(plaintext);
+  const ciphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
+  return {
+    data: base64Encode(new Uint8Array(ciphertext)),
+    nonce: base64Encode(iv)
+  };
+}
+async function decrypt(data, nonce, key) {
+  const ciphertext = base64Decode(data);
+  const iv = base64Decode(nonce);
+  const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext.buffer);
+  return new TextDecoder().decode(plaintext);
+}
+
+// src/client/api.ts
+class TaskbookClient {
+  baseUrl;
+  token;
+  cryptoKey = null;
+  encryptionKeyRaw;
+  constructor(config) {
+    this.baseUrl = config.serverUrl.replace(/\/+$/, "");
+    this.token = config.token;
+    this.encryptionKeyRaw = config.encryptionKey;
+  }
+  async getKey() {
+    if (!this.cryptoKey) {
+      this.cryptoKey = await deriveKey(this.encryptionKeyRaw);
+    }
+    return this.cryptoKey;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+    const resp = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Taskbook API ${method} ${path}: ${resp.status} ${text}`);
+    }
+    const contentType = resp.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await resp.json();
+    }
+    return {};
+  }
+  async decryptItems(encrypted) {
+    const key = await this.getKey();
+    const result = {};
+    for (const [id, item] of Object.entries(encrypted)) {
+      try {
+        const json = await decrypt(item.data, item.nonce, key);
+        result[id] = JSON.parse(json);
+      } catch {}
+    }
+    return result;
+  }
+  async encryptItem(item) {
+    const key = await this.getKey();
+    return encrypt(JSON.stringify(item), key);
+  }
+  async health() {
+    return this.request("GET", "/api/v1/health");
+  }
+  async me() {
+    return this.request("GET", "/api/v1/me");
+  }
+  async getItems() {
+    const resp = await this.request("GET", "/api/v1/items");
+    return this.decryptItems(resp.items);
+  }
+  async getArchive() {
+    const resp = await this.request("GET", "/api/v1/items/archive");
+    return this.decryptItems(resp.items);
+  }
+  async putItems(items) {
+    const encrypted = {};
+    for (const [id, item] of Object.entries(items)) {
+      encrypted[id] = await this.encryptItem(item);
+    }
+    await this.request("PUT", "/api/v1/items", { items: encrypted });
+  }
+  async putArchive(items) {
+    const encrypted = {};
+    for (const [id, item] of Object.entries(items)) {
+      encrypted[id] = await this.encryptItem(item);
+    }
+    await this.request("PUT", "/api/v1/items/archive", { items: encrypted });
+  }
+  async listTasks(board) {
+    const items = await this.getItems();
+    const tasks = Object.values(items).filter((i) => i._isTask);
+    if (board) {
+      return tasks.filter((t) => t.boards.includes(board));
+    }
+    return tasks;
+  }
+  async listNotes(board) {
+    const items = await this.getItems();
+    const notes = Object.values(items).filter((i) => !i._isTask);
+    if (board) {
+      return notes.filter((n) => n.boards.includes(board));
+    }
+    return notes;
+  }
+  async listBoards() {
+    const items = await this.getItems();
+    const boardSet = new Set;
+    for (const item of Object.values(items)) {
+      for (const b of item.boards)
+        boardSet.add(b);
+    }
+    return [...boardSet].sort();
+  }
+  async createTask(description, board = "My Board", priority = 1, tags = []) {
+    const items = await this.getItems();
+    const maxId = Math.max(0, ...Object.values(items).map((i) => i._id));
+    const now = new Date;
+    const task = {
+      _id: maxId + 1,
+      _date: now.toDateString().slice(0, 10),
+      _timestamp: now.getTime(),
+      _isTask: true,
+      description,
+      isStarred: false,
+      isComplete: false,
+      inProgress: false,
+      priority: Math.min(3, Math.max(1, priority)),
+      boards: [board.replace(/^@+/, "")],
+      tags: tags.map((t) => t.replace(/^\++/, "").toLowerCase())
+    };
+    items[String(task._id)] = task;
+    await this.putItems(items);
+    return task;
+  }
+  async createNote(description, board = "My Board", body, tags = []) {
+    const items = await this.getItems();
+    const maxId = Math.max(0, ...Object.values(items).map((i) => i._id));
+    const now = new Date;
+    const note = {
+      _id: maxId + 1,
+      _date: now.toDateString().slice(0, 10),
+      _timestamp: now.getTime(),
+      _isTask: false,
+      description,
+      body,
+      isStarred: false,
+      boards: [board.replace(/^@+/, "")],
+      tags: tags.map((t) => t.replace(/^\++/, "").toLowerCase())
+    };
+    items[String(note._id)] = note;
+    await this.putItems(items);
+    return note;
+  }
+  async completeTask(taskId) {
+    const items = await this.getItems();
+    const item = items[String(taskId)];
+    if (!item || !item._isTask) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    const task = item;
+    task.isComplete = !task.isComplete;
+    task.inProgress = false;
+    items[String(taskId)] = task;
+    await this.putItems(items);
+    return task;
+  }
+  async beginTask(taskId) {
+    const items = await this.getItems();
+    const item = items[String(taskId)];
+    if (!item || !item._isTask) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    const task = item;
+    task.inProgress = !task.inProgress;
+    items[String(taskId)] = task;
+    await this.putItems(items);
+    return task;
+  }
+  async starItem(itemId) {
+    const items = await this.getItems();
+    const item = items[String(itemId)];
+    if (!item)
+      throw new Error(`Item ${itemId} not found`);
+    item.isStarred = !item.isStarred;
+    items[String(itemId)] = item;
+    await this.putItems(items);
+    return item;
+  }
+  async deleteItem(itemId) {
+    const items = await this.getItems();
+    if (!items[String(itemId)]) {
+      throw new Error(`Item ${itemId} not found`);
+    }
+    delete items[String(itemId)];
+    await this.putItems(items);
+  }
+  async archiveItem(itemId) {
+    const items = await this.getItems();
+    const item = items[String(itemId)];
+    if (!item)
+      throw new Error(`Item ${itemId} not found`);
+    delete items[String(itemId)];
+    const archive = await this.getArchive();
+    archive[String(itemId)] = item;
+    await this.putItems(items);
+    await this.putArchive(archive);
+  }
+  async moveToBoard(itemId, targetBoard) {
+    const items = await this.getItems();
+    const item = items[String(itemId)];
+    if (!item)
+      throw new Error(`Item ${itemId} not found`);
+    item.boards = [targetBoard.replace(/^@+/, "")];
+    items[String(itemId)] = item;
+    await this.putItems(items);
+    return item;
+  }
+  async editItem(itemId, description) {
+    const items = await this.getItems();
+    const item = items[String(itemId)];
+    if (!item)
+      throw new Error(`Item ${itemId} not found`);
+    item.description = description;
+    items[String(itemId)] = item;
+    await this.putItems(items);
+    return item;
+  }
+  async searchItems(query) {
+    const items = await this.getItems();
+    const lower = query.toLowerCase();
+    return Object.values(items).filter((item) => item.description.toLowerCase().includes(lower) || item.tags.some((t) => t.includes(lower)) || item.boards.some((b) => b.toLowerCase().includes(lower)));
+  }
+}
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function loadTaskbookConfig() {
+  const envUrl = process.env.TB_SERVER_URL;
+  const envToken = process.env.TB_TOKEN;
+  const envKey = process.env.TB_ENCRYPTION_KEY;
+  if (envUrl && envToken && envKey) {
+    return { serverUrl: envUrl, token: envToken, encryptionKey: envKey };
+  }
+  const configPath = process.env.TB_CONFIG_PATH ?? join(homedir(), ".taskbook.json");
+  if (!existsSync(configPath)) {
+    throw new Error(`Taskbook config not found at ${configPath}. ` + "Run 'tb --login' or set TB_SERVER_URL, TB_TOKEN, TB_ENCRYPTION_KEY env vars.");
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const config = JSON.parse(raw);
+  const serverUrl = envUrl ?? config.sync?.server_url;
+  const token = envToken ?? config.sync?.token;
+  const encryptionKey = envKey ?? config.encryption_key;
+  if (!serverUrl)
+    throw new Error("Missing server URL in taskbook config");
+  if (!token)
+    throw new Error("Missing auth token in taskbook config");
+  if (!encryptionKey)
+    throw new Error("Missing encryption key in taskbook config");
+  return { serverUrl, token, encryptionKey };
+}
+function loadMcpConfig() {
+  const transport = process.env.TB_MCP_TRANSPORT ?? "stdio";
+  const port = Number.parseInt(process.env.TB_MCP_PORT ?? "3100", 10);
+  const host = process.env.TB_MCP_HOST ?? "127.0.0.1";
+  return { port, host, transport };
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/tasks.ts
+import { z } from "zod";
+function formatTask(t) {
+  const status = t.isComplete ? "\u2714" : t.inProgress ? "\u2026" : "\u2610";
+  const star = t.isStarred ? "\u2605 " : "";
+  const pri = t.priority > 1 ? ` [P${t.priority}]` : "";
+  const tags = t.tags.length > 0 ? ` +${t.tags.join(" +")}` : "";
+  const boards = t.boards.map((b) => `@${b}`).join(" ");
+  return `${status} ${t._id}. ${star}${t.description}${pri}${tags}  (${boards})`;
+}
+function registerTaskTools(server, getClient) {
+  server.tool("list_tasks", "List all tasks, optionally filtered by board name", { board: z.string().optional().describe("Board name to filter by") }, async ({ board }) => {
+    const tasks = await getClient().listTasks(board);
+    if (tasks.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: board ? `No tasks found on board @${board}.` : "No tasks found."
+          }
+        ]
+      };
+    }
+    const pending = tasks.filter((t) => !t.isComplete);
+    const done = tasks.filter((t) => t.isComplete);
+    const lines = [
+      `**Tasks** (${pending.length} pending, ${done.length} done)`,
+      "",
+      ...pending.map(formatTask),
+      ...done.length > 0 ? ["", "--- Completed ---", ...done.map(formatTask)] : []
+    ];
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  });
+  server.tool("create_task", "Create a new task on a board", {
+    description: z.string().describe("Task description"),
+    board: z.string().optional().describe("Board name (default: My Board)"),
+    priority: z.number().min(1).max(3).optional().describe("Priority 1-3 (1=normal, 2=medium, 3=high)"),
+    tags: z.array(z.string()).optional().describe("Tags to attach to the task")
+  }, async ({ description, board, priority, tags }) => {
+    const task = await getClient().createTask(description, board ?? "My Board", priority ?? 1, tags ?? []);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Created task #${task._id}: ${task.description} on @${task.boards[0]}`
+        }
+      ]
+    };
+  });
+  server.tool("complete_task", "Toggle a task's completion status", {
+    task_id: z.number().describe("The task ID number")
+  }, async ({ task_id }) => {
+    const task = await getClient().completeTask(task_id);
+    const status = task.isComplete ? "completed" : "uncompleted";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Task #${task._id} marked as ${status}: ${task.description}`
+        }
+      ]
+    };
+  });
+  server.tool("begin_task", "Toggle a task's in-progress status", {
+    task_id: z.number().describe("The task ID number")
+  }, async ({ task_id }) => {
+    const task = await getClient().beginTask(task_id);
+    const status = task.inProgress ? "in-progress" : "paused";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Task #${task._id} marked as ${status}: ${task.description}`
+        }
+      ]
+    };
+  });
+  server.tool("set_task_priority", "Set a task's priority level (1=normal, 2=medium, 3=high)", {
+    task_id: z.number().describe("The task ID number"),
+    priority: z.number().min(1).max(3).describe("Priority level 1-3")
+  }, async ({ task_id, priority }) => {
+    const client = getClient();
+    const items = await client.getItems();
+    const item = items[String(task_id)];
+    if (!item || !item._isTask)
+      throw new Error(`Task ${task_id} not found`);
+    item.priority = priority;
+    items[String(task_id)] = item;
+    await client.putItems(items);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Task #${task_id} priority set to P${priority}`
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/notes.ts
+import { z as z2 } from "zod";
+function formatNote(n) {
+  const star = n.isStarred ? "\u2605 " : "";
+  const tags = n.tags.length > 0 ? ` +${n.tags.join(" +")}` : "";
+  const boards = n.boards.map((b) => `@${b}`).join(" ");
+  const body = n.body ? `
+   ${n.body}` : "";
+  return `\uD83D\uDCDD ${n._id}. ${star}${n.description}${tags}  (${boards})${body}`;
+}
+function registerNoteTools(server, getClient) {
+  server.tool("list_notes", "List all notes, optionally filtered by board", { board: z2.string().optional().describe("Board name to filter by") }, async ({ board }) => {
+    const notes = await getClient().listNotes(board);
+    if (notes.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: board ? `No notes found on board @${board}.` : "No notes found."
+          }
+        ]
+      };
+    }
+    const lines = [
+      `**Notes** (${notes.length})`,
+      "",
+      ...notes.map(formatNote)
+    ];
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  });
+  server.tool("create_note", "Create a new note on a board", {
+    description: z2.string().describe("Note title/description"),
+    board: z2.string().optional().describe("Board name (default: My Board)"),
+    body: z2.string().optional().describe("Note body content"),
+    tags: z2.array(z2.string()).optional().describe("Tags to attach to the note")
+  }, async ({ description, board, body, tags }) => {
+    const note = await getClient().createNote(description, board ?? "My Board", body, tags ?? []);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Created note #${note._id}: ${note.description} on @${note.boards[0]}`
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/boards.ts
+import { z as z3 } from "zod";
+function registerBoardTools(server, getClient) {
+  server.tool("list_boards", "List all boards with item counts", {}, async () => {
+    const items = await getClient().getItems();
+    const boardCounts = new Map;
+    for (const item of Object.values(items)) {
+      for (const board of item.boards) {
+        const counts = boardCounts.get(board) ?? { tasks: 0, notes: 0 };
+        if (item._isTask)
+          counts.tasks++;
+        else
+          counts.notes++;
+        boardCounts.set(board, counts);
+      }
+    }
+    if (boardCounts.size === 0) {
+      return {
+        content: [{ type: "text", text: "No boards found." }]
+      };
+    }
+    const lines = [
+      "**Boards**",
+      "",
+      ...[...boardCounts.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, counts]) => `\uD83D\uDCCB @${name}  (${counts.tasks} tasks, ${counts.notes} notes)`)
+    ];
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  });
+  server.tool("move_item", "Move a task or note to a different board", {
+    item_id: z3.number().describe("The item ID to move"),
+    target_board: z3.string().describe("The target board name")
+  }, async ({ item_id, target_board }) => {
+    const item = await getClient().moveToBoard(item_id, target_board);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Moved item #${item._id} to @${item.boards[0]}`
+        }
+      ]
+    };
+  });
+}
+
+// src/tools/general.ts
+import { z as z4 } from "zod";
+function registerGeneralTools(server, getClient) {
+  server.tool("search_items", "Search tasks and notes by description, tag, or board name", {
+    query: z4.string().describe("Search query text")
+  }, async ({ query }) => {
+    const results = await getClient().searchItems(query);
+    if (results.length === 0) {
+      return {
+        content: [
+          { type: "text", text: `No items matching "${query}".` }
+        ]
+      };
+    }
+    const lines = results.map((item) => {
+      const type = item._isTask ? item.isComplete ? "\u2714" : "\u2610" : "\uD83D\uDCDD";
+      return `${type} ${item._id}. ${item.description}  (@${item.boards.join(", @")})`;
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: [`**Search results for "${query}"** (${results.length})`, "", ...lines].join(`
+`)
+        }
+      ]
+    };
+  });
+  server.tool("edit_item", "Edit an item's description", {
+    item_id: z4.number().describe("The item ID to edit"),
+    description: z4.string().describe("New description text")
+  }, async ({ item_id, description }) => {
+    const item = await getClient().editItem(item_id, description);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Updated item #${item._id}: ${item.description}`
+        }
+      ]
+    };
+  });
+  server.tool("delete_item", "Permanently delete a task or note", {
+    item_id: z4.number().describe("The item ID to delete")
+  }, async ({ item_id }) => {
+    await getClient().deleteItem(item_id);
+    return {
+      content: [{ type: "text", text: `Deleted item #${item_id}` }]
+    };
+  });
+  server.tool("archive_item", "Move an item to the archive", {
+    item_id: z4.number().describe("The item ID to archive")
+  }, async ({ item_id }) => {
+    await getClient().archiveItem(item_id);
+    return {
+      content: [{ type: "text", text: `Archived item #${item_id}` }]
+    };
+  });
+  server.tool("star_item", "Toggle the star/bookmark on a task or note", {
+    item_id: z4.number().describe("The item ID to star/unstar")
+  }, async ({ item_id }) => {
+    const item = await getClient().starItem(item_id);
+    const status = item.isStarred ? "starred" : "unstarred";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Item #${item._id} ${status}: ${item.description}`
+        }
+      ]
+    };
+  });
+  server.tool("get_status", "Check taskbook server health and current user info", {}, async () => {
+    const client = getClient();
+    const [health, me] = await Promise.all([client.health(), client.me()]);
+    const items = await client.getItems();
+    const tasks = Object.values(items).filter((i) => i._isTask);
+    const done = tasks.filter((t) => t._isTask && t.isComplete).length;
+    const pending = tasks.length - done;
+    const notes = Object.values(items).filter((i) => !i._isTask).length;
+    const boards = await client.listBoards();
+    const lines = [
+      `**Taskbook Status**`,
+      `Server: ${health.status}`,
+      `User: ${me.username} (${me.email})`,
+      `Boards: ${boards.length} (${boards.map((b) => `@${b}`).join(", ")})`,
+      `Tasks: ${tasks.length} total (${done} done, ${pending} pending)`,
+      `Notes: ${notes}`
+    ];
+    return { content: [{ type: "text", text: lines.join(`
+`) }] };
+  });
+}
+
+// src/resources/index.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server, getClient) {
+  server.resource("status", "taskbook://status", { description: "Taskbook server status and user info", mimeType: "application/json" }, async (uri) => {
+    const client = getClient();
+    const [health, me] = await Promise.all([client.health(), client.me()]);
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          text: JSON.stringify({ health, user: me }, null, 2)
+        }
+      ]
+    };
+  });
+  server.resource("board", new ResourceTemplate("taskbook://boards/{boardName}", {
+    list: async () => {
+      const boards = await getClient().listBoards();
+      return {
+        resources: boards.map((b) => ({
+          uri: `taskbook://boards/${encodeURIComponent(b)}`,
+          name: `@${b}`,
+          description: `Tasks and notes on board @${b}`
+        }))
+      };
+    }
+  }), { description: "Tasks and notes on a specific board", mimeType: "application/json" }, async (uri, { boardName }) => {
+    const board = decodeURIComponent(boardName);
+    const client = getClient();
+    const [tasks, notes] = await Promise.all([
+      client.listTasks(board),
+      client.listNotes(board)
+    ]);
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          text: JSON.stringify({ board, tasks, notes }, null, 2)
+        }
+      ]
+    };
+  });
+  server.resource("all-items", "taskbook://items", { description: "All tasks and notes across all boards", mimeType: "application/json" }, async (uri) => {
+    const items = await getClient().getItems();
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          text: JSON.stringify(Object.values(items), null, 2)
+        }
+      ]
+    };
+  });
+  server.resource("archive", "taskbook://archive", { description: "Archived tasks and notes", mimeType: "application/json" }, async (uri) => {
+    const archive = await getClient().getArchive();
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          text: JSON.stringify(Object.values(archive), null, 2)
+        }
+      ]
+    };
+  });
+}
+
+// src/server.ts
+var SERVER_NAME = "taskbook-mcp";
+var SERVER_VERSION = "1.0.0";
+function createMcpServer(getClient) {
+  const server = new McpServer({
+    name: SERVER_NAME,
+    version: SERVER_VERSION
+  }, {
+    capabilities: {
+      logging: {}
+    }
+  });
+  registerTaskTools(server, getClient);
+  registerNoteTools(server, getClient);
+  registerBoardTools(server, getClient);
+  registerGeneralTools(server, getClient);
+  registerResources(server, getClient);
+  return server;
+}
+
+// src/transport/stdio.ts
+async function startStdioTransport() {
+  const config = loadTaskbookConfig();
+  const client = new TaskbookClient(config);
+  const server = createMcpServer(() => client);
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  process.stderr.write(`[taskbook-mcp] stdio transport connected (server: ${config.serverUrl})
+`);
+}
+
+// src/transport/http.ts
+import { randomUUID } from "crypto";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+async function startHttpTransport(config) {
+  const sessions = new Map;
+  const { port, host } = config;
+  const requiredToken = process.env.TB_MCP_ACCESS_TOKEN;
+  function verifyAuth(req) {
+    if (!requiredToken)
+      return true;
+    const auth = req.headers.get("authorization");
+    if (!auth)
+      return false;
+    const [scheme, token] = auth.split(" ", 2);
+    return scheme?.toLowerCase() === "bearer" && token === requiredToken;
+  }
+  function corsHeaders() {
+    return {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, mcp-session-id, MCP-Protocol-Version",
+      "Access-Control-Expose-Headers": "mcp-session-id"
+    };
+  }
+  Bun.serve({
+    port,
+    hostname: host,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/health") {
+        return Response.json({
+          status: "ok",
+          server: SERVER_NAME,
+          version: SERVER_VERSION
+        });
+      }
+      if (url.pathname !== "/mcp") {
+        return new Response("Not Found", { status: 404 });
+      }
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: corsHeaders() });
+      }
+      if (!verifyAuth(req)) {
+        return Response.json({
+          jsonrpc: "2.0",
+          error: { code: -32001, message: "Unauthorized" },
+          id: null
+        }, { status: 401, headers: corsHeaders() });
+      }
+      if (req.method === "POST") {
+        const sessionId = req.headers.get("mcp-session-id");
+        if (sessionId && sessions.has(sessionId)) {
+          const session = sessions.get(sessionId);
+          return session.transport.handleRequest(req);
+        }
+        const body = await req.json();
+        if (isInitializeRequest(body)) {
+          const tbConfig = loadTaskbookConfig();
+          const client = new TaskbookClient(tbConfig);
+          const transport = new WebStandardStreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (id) => {
+              sessions.set(id, { transport, client });
+              console.log(`[taskbook-mcp] HTTP session created: ${id}`);
+            }
+          });
+          transport.onclose = () => {
+            if (transport.sessionId) {
+              sessions.delete(transport.sessionId);
+              console.log(`[taskbook-mcp] HTTP session closed: ${transport.sessionId}`);
+            }
+          };
+          const mcpServer = createMcpServer(() => client);
+          await mcpServer.connect(transport);
+          return transport.handleRequest(req, { parsedBody: body });
+        }
+        return Response.json({
+          jsonrpc: "2.0",
+          error: { code: -32000, message: "Invalid or missing session" },
+          id: null
+        }, { status: 400, headers: corsHeaders() });
+      }
+      if (req.method === "GET") {
+        const sessionId = req.headers.get("mcp-session-id");
+        if (sessionId && sessions.has(sessionId)) {
+          return sessions.get(sessionId).transport.handleRequest(req);
+        }
+        return new Response("Invalid session", {
+          status: 400,
+          headers: corsHeaders()
+        });
+      }
+      if (req.method === "DELETE") {
+        const sessionId = req.headers.get("mcp-session-id");
+        if (sessionId && sessions.has(sessionId)) {
+          const session = sessions.get(sessionId);
+          await session.transport.close();
+          sessions.delete(sessionId);
+          return new Response(null, { status: 204, headers: corsHeaders() });
+        }
+        return new Response("Invalid session", {
+          status: 400,
+          headers: corsHeaders()
+        });
+      }
+      return new Response("Method Not Allowed", { status: 405 });
+    }
+  });
+  console.log(`[taskbook-mcp] HTTP transport listening on http://${host}:${port}/mcp`);
+  console.log(`[taskbook-mcp] Health check: http://${host}:${port}/health`);
+}
+
+// src/index.ts
+async function main() {
+  const args = process.argv.slice(2);
+  let transportOverride;
+  for (const arg of args) {
+    if (arg.startsWith("--transport=")) {
+      transportOverride = arg.split("=")[1];
+    }
+    if (arg === "--help" || arg === "-h") {
+      console.log(`Taskbook MCP Server
+
+Usage:
+  taskbook-mcp [--transport=stdio|http] [--port=PORT] [--host=HOST]
+
+Environment variables:
+  TB_MCP_TRANSPORT     Transport type: stdio (default) or http
+  TB_MCP_PORT          HTTP port (default: 3100)
+  TB_MCP_HOST          HTTP bind address (default: 127.0.0.1)
+  TB_MCP_ACCESS_TOKEN  Optional: require this token for HTTP connections
+  TB_SERVER_URL        Taskbook server URL (overrides ~/.taskbook.json)
+  TB_TOKEN             Taskbook session token (overrides ~/.taskbook.json)
+  TB_ENCRYPTION_KEY    Encryption key (overrides ~/.taskbook.json)
+  TB_CONFIG_PATH       Path to taskbook config (default: ~/.taskbook.json)
+`);
+      process.exit(0);
+    }
+  }
+  if (transportOverride) {
+    process.env.TB_MCP_TRANSPORT = transportOverride;
+  }
+  for (const arg of args) {
+    if (arg.startsWith("--port=")) {
+      process.env.TB_MCP_PORT = arg.split("=")[1];
+    }
+    if (arg.startsWith("--host=")) {
+      process.env.TB_MCP_HOST = arg.split("=")[1];
+    }
+  }
+  const config = loadMcpConfig();
+  if (config.transport === "http") {
+    await startHttpTransport(config);
+  } else {
+    await startStdioTransport();
+  }
+}
+main().catch((err) => {
+  console.error("[taskbook-mcp] Fatal error:", err.message ?? err);
+  process.exit(1);
+});
+
+//# debugId=A2D3326EC19207DD64756E2164756E21
+//# sourceMappingURL=index.js.map