linkagogo-mcp 0.1.0

package/README.md

@@ -0,0 +1,114 @@
+# LinkaGoGo MCP Server
+
+Manage your LinkaGoGo bookmarks with Claude using the [Model Context Protocol](https://modelcontextprotocol.io/). Search, add, organize, tag, and export bookmarks conversationally — no need to open the web UI.
+
+## What You Need
+
+1. **A LinkaGoGo account** with a Plus or Premium subscription — [sign up](https://www.linkagogo.com/app/?signup)
+2. **An API key** — generate one in your LinkaGoGo account under Account > API Keys
+3. **Node.js 18 or later** — [download](https://nodejs.org/)
+4. **Claude Desktop** — [download](https://claude.ai/download)
+
+## Step 1: Get Your API Key
+
+1. Log in to [LinkaGoGo](https://www.linkagogo.com/app/)
+2. Click your avatar in the top-right corner and select **Account**
+3. Scroll down to the **API Keys** section
+4. Enter a name (e.g. "Claude Desktop") and click **Generate Key**
+5. Copy the key immediately — it starts with `lgg_` and won't be shown again
+
+## Step 2: Configure Claude Desktop
+
+Open the Claude Desktop configuration file:
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+If the file doesn't exist, create it. Add the LinkaGoGo MCP server:
+
+```json
+{
+  "mcpServers": {
+    "linkagogo": {
+      "command": "npx",
+      "args": ["-y", "linkagogo-mcp"],
+      "env": {
+        "LINKAGOGO_API_TOKEN": "lgg_your_api_key_here"
+      }
+    }
+  }
+}
+```
+
+Replace `lgg_your_api_key_here` with your API key from Step 1. No download or build step needed — Claude Desktop installs the server automatically via `npx`.
+
+## Step 3: Restart Claude Desktop
+
+Quit Claude Desktop completely (Cmd+Q on macOS, not just close the window), then reopen it.
+
+You should see the hammer icon in the chat input area. Click it to verify LinkaGoGo's tools are listed.
+
+## Try It Out
+
+Ask Claude naturally:
+
+- "How many bookmarks do I have?"
+- "Search my bookmarks for Python tutorials"
+- "Add https://example.com to my Dev folder with tags 'reference' and 'docs'"
+- "What are my most visited bookmarks?"
+- "Show me my folder tree"
+- "Move all bookmarks tagged 'old' into an Archive folder"
+- "Export my Recipes folder as XBEL"
+- "What reminders are due?"
+
+## Available Tools
+
+| Tool | What It Does |
+|------|-------------|
+| `search_bookmarks` | Search by keyword, filter by folder, sort by date/visits/rating |
+| `add_bookmark` | Save a new bookmark (auto-fetches title if omitted) |
+| `update_bookmark` | Update title, URL, keywords, rating, favorite, reminder |
+| `delete_bookmark` | Delete a bookmark |
+| `move_bookmarks` | Move bookmarks to a folder (bulk) |
+| `tag_bookmarks` | Add or remove keyword tags (bulk) |
+| `list_folders` | Show folder tree or children of a folder |
+| `create_folder` | Create a folder or a nested path (e.g. "Dev/Python/Libs") |
+| `rename_folder` | Rename a folder |
+| `move_folder` | Move a folder to a new parent |
+| `delete_folder` | Delete a folder and its contents |
+| `export_bookmarks` | Export as XBEL or Netscape HTML (full or by folder) |
+| `import_bookmarks` | Import from XBEL or Netscape HTML |
+| `get_stats` | Account statistics |
+| `get_reminders` | Bookmarks with due reminders |
+
+## Troubleshooting
+
+**"LINKAGOGO_API_TOKEN environment variable is required"**
+Your API key is missing from the Claude Desktop config. Check `claude_desktop_config.json`.
+
+**Tools not showing up in Claude Desktop**
+Make sure you quit and reopened Claude Desktop (not just closed the window). Check that `node` is in your PATH and the path to `dist/index.js` is correct.
+
+**"Invalid API key" errors**
+Your API key may have been revoked or mistyped. Generate a new one in Account > API Keys.
+
+**"Rate limit exceeded"**
+The API allows 5,000 requests/day on Plus and 10,000/day on Premium per API key. Wait until the next day or generate an additional key.
+
+## Updating
+
+The MCP server updates automatically — `npx` fetches the latest version each time Claude Desktop starts.
+
+## Development
+
+To run without building (uses tsx):
+
+```bash
+LINKAGOGO_API_TOKEN=lgg_your_key npm run dev
+```
+
+To test with the MCP Inspector:
+
+```bash
+LINKAGOGO_API_TOKEN=lgg_your_key LINKAGOGO_API_URL=http://localhost:8000 npx @modelcontextprotocol/inspector node dist/index.js
+```

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * LinkaGoGo API client — thin fetch wrapper with Bearer auth.
+ */
+export declare class ApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function api<T = unknown>(method: string, path: string, body?: unknown, contentType?: string): Promise<T>;

package/dist/client.js

@@ -0,0 +1,48 @@
+/**
+ * LinkaGoGo API client — thin fetch wrapper with Bearer auth.
+ */
+const API_URL = (process.env.LINKAGOGO_API_URL || "https://www.linkagogo.com").replace(/\/$/, "");
+const API_TOKEN = process.env.LINKAGOGO_API_TOKEN || "";
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+export async function api(method, path, body, contentType) {
+    const url = `${API_URL}/api/v1${path}`;
+    const headers = {
+        Authorization: `Bearer ${API_TOKEN}`,
+    };
+    let reqBody;
+    if (body !== undefined) {
+        if (contentType) {
+            headers["Content-Type"] = contentType;
+            reqBody = typeof body === "string" ? body : JSON.stringify(body);
+        }
+        else {
+            headers["Content-Type"] = "application/json";
+            reqBody = JSON.stringify(body);
+        }
+    }
+    const resp = await fetch(url, { method, headers, body: reqBody });
+    if (resp.status === 204)
+        return undefined;
+    const ct = resp.headers.get("content-type") || "";
+    // Handle non-JSON responses (XBEL export, etc.)
+    if (!ct.includes("application/json")) {
+        if (!resp.ok) {
+            throw new ApiError(resp.status, `API error (${resp.status})`);
+        }
+        return (await resp.text());
+    }
+    const data = await resp.json();
+    if (!resp.ok) {
+        const detail = data?.detail;
+        const message = typeof detail === "string" ? detail : detail?.message || `API error (${resp.status})`;
+        throw new ApiError(resp.status, message);
+    }
+    return data;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * LinkaGoGo MCP Server — expose bookmark management to AI assistants.
+ *
+ * Environment variables:
+ *   LINKAGOGO_API_TOKEN  — Required. API key (lgg_...) from Account > API Keys.
+ *   LINKAGOGO_API_URL    — Optional. Base URL (default: https://www.linkagogo.com).
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * LinkaGoGo MCP Server — expose bookmark management to AI assistants.
+ *
+ * Environment variables:
+ *   LINKAGOGO_API_TOKEN  — Required. API key (lgg_...) from Account > API Keys.
+ *   LINKAGOGO_API_URL    — Optional. Base URL (default: https://www.linkagogo.com).
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerBookmarkTools } from "./tools/bookmarks.js";
+import { registerBulkTools } from "./tools/bulk.js";
+import { registerFolderTools } from "./tools/folders.js";
+import { registerImportExportTools } from "./tools/importexport.js";
+import { registerAccountTools } from "./tools/account.js";
+import { registerFolderResource } from "./resources/folders.js";
+import { registerRecentResource } from "./resources/recent.js";
+// Validate required env var
+if (!process.env.LINKAGOGO_API_TOKEN) {
+    console.error("Error: LINKAGOGO_API_TOKEN environment variable is required.");
+    console.error("Generate an API key at https://www.linkagogo.com/app (Account > API Keys).");
+    process.exit(1);
+}
+const server = new McpServer({
+    name: "linkagogo",
+    version: "0.1.0",
+});
+// Register tools
+registerBookmarkTools(server);
+registerBulkTools(server);
+registerFolderTools(server);
+registerImportExportTools(server);
+registerAccountTools(server);
+// Register resources
+registerFolderResource(server);
+registerRecentResource(server);
+// Start stdio transport
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/resources/folders.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Folder tree resource — bookmarks://folders
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerFolderResource(server: McpServer): void;

package/dist/resources/folders.js

@@ -0,0 +1,36 @@
+/**
+ * Folder tree resource — bookmarks://folders
+ */
+import { api } from "../client.js";
+function buildTree(folders) {
+    const childrenMap = new Map();
+    for (const f of folders) {
+        const parent = f.folder_id || 0;
+        if (!childrenMap.has(parent))
+            childrenMap.set(parent, []);
+        childrenMap.get(parent).push(f);
+    }
+    const lines = [];
+    function walk(parentId, indent) {
+        const children = childrenMap.get(parentId) || [];
+        for (const f of children) {
+            const pub = f.is_public ? " (public)" : "";
+            lines.push(`${indent}[${f.id}] ${f.name}${pub}`);
+            walk(f.id, indent + "  ");
+        }
+    }
+    walk(0, "");
+    return lines.join("\n") || "(no folders)";
+}
+export function registerFolderResource(server) {
+    server.resource("folder-tree", "bookmarks://folders", async (uri) => {
+        const folders = await api("GET", "/folders");
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `Folder Tree:\n${buildTree(folders)}`,
+                }],
+        };
+    });
+}

package/dist/resources/recent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Recent bookmarks resource — bookmarks://recent
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRecentResource(server: McpServer): void;

package/dist/resources/recent.js

@@ -0,0 +1,18 @@
+/**
+ * Recent bookmarks resource — bookmarks://recent
+ */
+import { api } from "../client.js";
+export function registerRecentResource(server) {
+    server.resource("recent-bookmarks", "bookmarks://recent", async (uri) => {
+        const data = await api("GET", "/urls?sort=date_desc&page_size=25");
+        const lines = data.bookmarks.map((bm) => `[${bm.id}] ${bm.title || "(untitled)"}\n    ${bm.url}\n    Added: ${bm.added_date}${bm.folder_id ? ` | Folder: ${bm.folder_id}` : ""}`);
+        lines.push(`\n--- ${data.total} total bookmarks ---`);
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: `Recent Bookmarks (25 most recent):\n\n${lines.join("\n\n")}`,
+                }],
+        };
+    });
+}

package/dist/tools/account.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Account tools — stats, reminders.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAccountTools(server: McpServer): void;

package/dist/tools/account.js

@@ -0,0 +1,61 @@
+/**
+ * Account tools — stats, reminders.
+ */
+import { z } from "zod";
+import { api } from "../client.js";
+const REMINDER_LABELS = {
+    0: "Daily",
+    [-1]: "Monday", [-2]: "Tuesday", [-3]: "Wednesday", [-4]: "Thursday",
+    [-5]: "Friday", [-6]: "Saturday", [-7]: "Sunday",
+};
+function reminderLabel(r) {
+    if (REMINDER_LABELS[r])
+        return REMINDER_LABELS[r];
+    if (r >= -41 && r <= -11)
+        return `${-(r + 10)}th of each month`;
+    if (r > 0)
+        return `Every ${r} days`;
+    return "Unknown";
+}
+export function registerAccountTools(server) {
+    server.tool("get_stats", "Get account statistics: bookmark count, folder count, favorites, tags, and date range.", {}, async () => {
+        try {
+            const stats = await api("GET", "/account/stats");
+            const lines = [
+                `Bookmarks: ${stats.bookmark_count}`,
+                `Folders: ${stats.folder_count}`,
+                `Favorites: ${stats.favorite_count}`,
+                `Unique tags: ${stats.tag_count}`,
+            ];
+            if (stats.oldest_bookmark)
+                lines.push(`Oldest: ${stats.oldest_bookmark}`);
+            if (stats.newest_bookmark)
+                lines.push(`Newest: ${stats.newest_bookmark}`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("get_reminders", "Get bookmarks with active reminders that are due.", {
+        page: z.number().optional().describe("Page number (default 1)"),
+    }, async (params) => {
+        try {
+            const qs = new URLSearchParams({ sort: "reminders" });
+            if (params.page)
+                qs.set("page", String(params.page));
+            const data = await api("GET", `/urls?${qs}`);
+            if (data.bookmarks.length === 0) {
+                return { content: [{ type: "text", text: "No reminders due." }] };
+            }
+            const lines = data.bookmarks.map((bm) => {
+                return `[${bm.id}] ${bm.title || "(untitled)"}\n    URL: ${bm.url}\n    Reminder: ${reminderLabel(bm.reminder)}${bm.last_visited ? `\n    Last visited: ${bm.last_visited}` : ""}`;
+            });
+            lines.push(`\n--- ${data.total} reminder(s) due ---`);
+            return { content: [{ type: "text", text: lines.join("\n\n") }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+}

package/dist/tools/bookmarks.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bookmark tools — search, add, update, delete.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerBookmarkTools(server: McpServer): void;

package/dist/tools/bookmarks.js

@@ -0,0 +1,110 @@
+/**
+ * Bookmark tools — search, add, update, delete.
+ */
+import { z } from "zod";
+import { api } from "../client.js";
+function formatBookmark(bm) {
+    const parts = [`[${bm.id}] ${bm.title || "(untitled)"}`];
+    parts.push(`    URL: ${bm.url}`);
+    if (bm.keywords)
+        parts.push(`    Keywords: ${bm.keywords}`);
+    if (bm.folder_id)
+        parts.push(`    Folder ID: ${bm.folder_id}`);
+    if (bm.rating)
+        parts.push(`    Rating: ${"*".repeat(bm.rating)}`);
+    if (bm.is_favorite)
+        parts.push(`    Favorite: yes`);
+    if (bm.last_visited)
+        parts.push(`    Last visited: ${bm.last_visited}`);
+    return parts.join("\n");
+}
+export function registerBookmarkTools(server) {
+    server.tool("search_bookmarks", "Search and list bookmarks. Use sort=visit_count_desc for most used, sort=visit_date_desc for last visited, sort=date_desc for newest, sort=rating_desc for top rated. Omit q to list all bookmarks with the given sort/filter.", {
+        q: z.string().optional().describe("Search query (searches title, URL, keywords, comments). Omit to list all."),
+        folder_id: z.number().optional().describe("Filter by folder ID"),
+        sort: z.enum(["title_asc", "date_desc", "visit_date_desc", "visit_count_desc", "rating_desc"]).optional().describe("title_asc=alphabetical, date_desc=newest first, visit_date_desc=last visited first, visit_count_desc=most visited first, rating_desc=highest rated first"),
+        page: z.number().optional().describe("Page number (default 1)"),
+        page_size: z.number().optional().describe("Items per page (default 50, max 200)"),
+        favorite: z.boolean().optional().describe("Filter favorites only"),
+    }, async (params) => {
+        try {
+            const qs = new URLSearchParams();
+            if (params.q)
+                qs.set("q", params.q);
+            if (params.folder_id !== undefined)
+                qs.set("folder_id", String(params.folder_id));
+            if (params.sort)
+                qs.set("sort", params.sort);
+            if (params.page)
+                qs.set("page", String(params.page));
+            if (params.page_size)
+                qs.set("page_size", String(params.page_size));
+            if (params.favorite)
+                qs.set("favorite", "true");
+            const query = qs.toString();
+            const data = await api("GET", `/urls${query ? "?" + query : ""}`);
+            const lines = data.bookmarks.map(formatBookmark);
+            lines.push(`\n--- Page ${data.page}, ${data.total} total ---`);
+            return { content: [{ type: "text", text: lines.join("\n\n") || "No bookmarks found." }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("add_bookmark", "Save a new bookmark. Title is auto-fetched from the page if omitted.", {
+        url: z.string().describe("URL to bookmark"),
+        title: z.string().optional().describe("Bookmark title (auto-fetched if omitted)"),
+        folder_id: z.number().optional().describe("Folder ID (0 = root)"),
+        keywords: z.string().optional().describe("Space-separated keywords/tags"),
+        comments: z.string().optional().describe("Notes or description"),
+    }, async (params) => {
+        try {
+            const body = { url: params.url };
+            if (params.title)
+                body.title = params.title;
+            if (params.folder_id !== undefined)
+                body.folder_id = params.folder_id;
+            if (params.keywords)
+                body.keywords = params.keywords;
+            if (params.comments)
+                body.comments = params.comments;
+            const bm = await api("POST", "/urls", body);
+            return { content: [{ type: "text", text: `Bookmark created:\n${formatBookmark(bm)}` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("update_bookmark", "Update a bookmark's metadata. Only include the fields you want to change.", {
+        id: z.number().describe("Bookmark ID"),
+        url: z.string().optional().describe("New URL"),
+        title: z.string().optional().describe("New title"),
+        folder_id: z.number().optional().describe("Move to folder ID"),
+        keywords: z.string().optional().describe("New keywords (replaces all)"),
+        comments: z.string().optional().describe("New comments"),
+        rating: z.number().min(0).max(5).optional().describe("Rating 0-5"),
+        is_favorite: z.boolean().optional().describe("Favorite flag"),
+        reminder: z.number().optional().describe("Reminder: 0=daily, -1=Monday..-7=Sunday, -11..-41=1st..31st of month, positive N=every N days, -9=off"),
+    }, async (params) => {
+        try {
+            const { id, ...fields } = params;
+            const body = Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== undefined));
+            const bm = await api("PATCH", `/urls/${id}`, body);
+            return { content: [{ type: "text", text: `Bookmark updated:\n${formatBookmark(bm)}` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("delete_bookmark", "Delete a bookmark by ID.", {
+        id: z.number().describe("Bookmark ID to delete"),
+    }, async (params) => {
+        try {
+            await api("DELETE", `/urls/${params.id}`);
+            return { content: [{ type: "text", text: `Bookmark ${params.id} deleted.` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+}

package/dist/tools/bulk.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bulk tools — move bookmarks, tag bookmarks.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerBulkTools(server: McpServer): void;

package/dist/tools/bulk.js

@@ -0,0 +1,39 @@
+/**
+ * Bulk tools — move bookmarks, tag bookmarks.
+ */
+import { z } from "zod";
+import { api } from "../client.js";
+export function registerBulkTools(server) {
+    server.tool("move_bookmarks", "Move one or more bookmarks to a folder.", {
+        ids: z.array(z.number()).describe("Bookmark IDs to move"),
+        folder_id: z.number().describe("Target folder ID (0 = root)"),
+    }, async (params) => {
+        try {
+            const result = await api("POST", "/urls/move", {
+                ids: params.ids,
+                folder_id: params.folder_id,
+            });
+            return { content: [{ type: "text", text: `Moved ${result.moved} bookmark(s) to folder ${params.folder_id}.` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("tag_bookmarks", "Add or remove keyword tags on one or more bookmarks.", {
+        ids: z.array(z.number()).describe("Bookmark IDs to tag"),
+        add: z.array(z.string()).optional().describe("Tags to add"),
+        remove: z.array(z.string()).optional().describe("Tags to remove"),
+    }, async (params) => {
+        try {
+            const result = await api("POST", "/urls/tag", {
+                ids: params.ids,
+                add: params.add || [],
+                remove: params.remove || [],
+            });
+            return { content: [{ type: "text", text: `Modified tags on ${result.modified} bookmark(s).` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+}

package/dist/tools/folders.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Folder tools — create, rename, delete.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerFolderTools(server: McpServer): void;

package/dist/tools/folders.js

@@ -0,0 +1,111 @@
+/**
+ * Folder tools — create, rename, delete.
+ */
+import { z } from "zod";
+import { api } from "../client.js";
+function buildTree(folders, parentId, indent) {
+    const children = folders.filter((f) => f.folder_id === parentId);
+    const lines = [];
+    for (const f of children) {
+        const pub = f.is_public ? " (public)" : "";
+        lines.push(`${indent}[${f.id}] ${f.name}${pub}`);
+        lines.push(...buildTree(folders, f.id, indent + "  "));
+    }
+    return lines;
+}
+export function registerFolderTools(server) {
+    server.tool("list_folders", "List folders. With no arguments returns the full folder tree. With parent_id returns only direct children of that folder.", {
+        parent_id: z.number().optional().describe("Parent folder ID to list children of. Omit for full tree. Use 0 for root-level folders."),
+    }, async (params) => {
+        try {
+            const folders = await api("GET", "/folders");
+            if (params.parent_id !== undefined) {
+                const children = folders.filter((f) => f.folder_id === params.parent_id);
+                if (children.length === 0) {
+                    return { content: [{ type: "text", text: "No subfolders found." }] };
+                }
+                const lines = children.map((f) => `[${f.id}] ${f.name}${f.is_public ? " (public)" : ""}`);
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
+            // Full tree
+            const lines = buildTree(folders, 0, "");
+            return { content: [{ type: "text", text: lines.join("\n") || "No folders." }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("create_folder", "Create a folder. Use 'path' for nested creation (e.g. 'Dev/Python/Libraries') or 'name' + 'parent_id' for a single folder.", {
+        name: z.string().optional().describe("Folder name (for single folder creation)"),
+        parent_id: z.number().optional().describe("Parent folder ID (0 = root, used with 'name')"),
+        path: z.string().optional().describe("Slash-separated path (e.g. 'Dev/Python/Libraries') — creates intermediates"),
+    }, async (params) => {
+        try {
+            let folder;
+            if (params.path) {
+                folder = await api("POST", "/folders/create-path", { path: params.path });
+            }
+            else if (params.name) {
+                folder = await api("POST", "/folders", {
+                    name: params.name,
+                    folder_id: params.parent_id || 0,
+                });
+            }
+            else {
+                return { content: [{ type: "text", text: "Error: Provide either 'path' or 'name'." }], isError: true };
+            }
+            return { content: [{ type: "text", text: `Folder created: [${folder.id}] ${folder.name}` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("rename_folder", "Rename a folder.", {
+        id: z.number().describe("Folder ID"),
+        name: z.string().describe("New folder name"),
+    }, async (params) => {
+        try {
+            // GET current folder to preserve other fields
+            const current = await api("GET", `/folders/${params.id}`);
+            const updated = await api("PUT", `/folders/${params.id}`, {
+                name: params.name,
+                folder_id: current.folder_id,
+                is_public: current.is_public,
+                comments: current.comments,
+            });
+            return { content: [{ type: "text", text: `Folder renamed: [${updated.id}] ${updated.name}` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("move_folder", "Move a folder to a new parent folder.", {
+        id: z.number().describe("Folder ID to move"),
+        parent_id: z.number().describe("New parent folder ID (0 = root)"),
+    }, async (params) => {
+        try {
+            const current = await api("GET", `/folders/${params.id}`);
+            const updated = await api("PUT", `/folders/${params.id}`, {
+                name: current.name,
+                folder_id: params.parent_id,
+                is_public: current.is_public,
+                comments: current.comments,
+            });
+            return { content: [{ type: "text", text: `Folder [${updated.id}] ${updated.name} moved to parent ${params.parent_id}.` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("delete_folder", "Delete a folder and all its contents (bookmarks and subfolders).", {
+        id: z.number().describe("Folder ID to delete"),
+    }, async (params) => {
+        try {
+            await api("DELETE", `/folders/${params.id}`);
+            return { content: [{ type: "text", text: `Folder ${params.id} deleted.` }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+}

package/dist/tools/importexport.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Import/export tools — XBEL export, bookmark import.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerImportExportTools(server: McpServer): void;

package/dist/tools/importexport.js

@@ -0,0 +1,40 @@
+/**
+ * Import/export tools — XBEL export, bookmark import.
+ */
+import { z } from "zod";
+import { api } from "../client.js";
+export function registerImportExportTools(server) {
+    server.tool("export_bookmarks", "Export bookmarks as XBEL XML or Netscape HTML. Optionally export only a specific folder and its subfolders.", {
+        format: z.enum(["xbel", "netscape"]).optional().describe("Export format (default: xbel)"),
+        folder_id: z.number().optional().describe("Export only this folder and its subfolders. Omit for full export."),
+    }, async (params) => {
+        try {
+            const fmt = params.format || "xbel";
+            const qs = params.folder_id !== undefined ? `?folder_id=${params.folder_id}` : "";
+            const content = await api("GET", `/export/${fmt}${qs}`);
+            return { content: [{ type: "text", text: content }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    server.tool("import_bookmarks", "Import bookmarks from XBEL XML or Netscape HTML content.", {
+        content: z.string().describe("The bookmark file content (XML for XBEL, HTML for Netscape)"),
+        format: z.enum(["xbel", "netscape"]).describe("File format: 'xbel' or 'netscape'"),
+    }, async (params) => {
+        try {
+            const endpoint = params.format === "xbel" ? "/import/xbel" : "/import/netscape";
+            const ct = params.format === "xbel" ? "application/xml" : "text/html";
+            const result = await api("POST", endpoint, params.content, ct);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Import complete: ${result.bookmarks_created} bookmarks created, ${result.folders_created} folders created, ${result.bookmarks_skipped} duplicates skipped.`,
+                    }],
+            };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "linkagogo-mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP server for LinkaGoGo — manage bookmarks with Claude AI",
+  "keywords": ["mcp", "bookmarks", "claude", "ai", "linkagogo", "model-context-protocol"],
+  "license": "MIT",
+  "author": "LinkaGoGo",
+  "homepage": "https://www.linkagogo.com/mcp-setup",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hbroek/lgg-claude.git",
+    "directory": "mcp"
+  },
+  "bin": {
+    "linkagogo-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}