@intangle/mcp-server 2.6.7 → 2.6.9

package/index.ts

@@ -1,813 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Intangle MCP Server - Exposes Intangle context functionality through MCP
- */
-
-import { readFileSync } from "fs"
-import { dirname, join } from "path"
-import { fileURLToPath } from "url"
-import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListResourceTemplatesRequestSchema,
-  ListResourcesRequestSchema,
-  ListToolsRequestSchema,
-  McpError,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js"
-import { config } from "dotenv"
-import fetch from "node-fetch"
-import { TOOLS } from "./tool-definitions.js"
-
-// ... imports ...
-
-// Debug logging
-import { appendFileSync } from "fs"
-const DEBUG_LOG = "/tmp/intangle-mcp-debug.log"
-function log(msg: string) {
-  try {
-    appendFileSync(DEBUG_LOG, `${new Date().toISOString()}: ${msg}\n`)
-  } catch (e) {}
-}
-
-log("--- Server Starting ---")
-
-// Client info captured from MCP initialize handshake
-let mcpClientName: string | undefined
-let mcpClientVersion: string | undefined
-
-try {
-  // Load environment variables from .env and .env.local
-  config({ quiet: true })
-  config({ path: ".env.local", quiet: true })
-
-  // Base URL for API calls to Next.js app
-  const API_BASE_URL = process.env.NEXT_APP_URL || "https://renvoi.co/intangle"
-  const MCP_API_KEY = process.env.MCP_API_KEY
-  const VERCEL_BYPASS_TOKEN =
-    process.env.VERCEL_BYPASS_TOKEN || process.env.VERCEL_PROTECTION_BYPASS
-
-  log(`CWD: ${process.cwd()}`)
-  log(`Has API Key: ${!!MCP_API_KEY}`)
-  log(`Has Vercel Bypass Token: ${!!VERCEL_BYPASS_TOKEN}`)
-  log(`Node Version: ${process.version}`)
-
-  if (!MCP_API_KEY) {
-    log("Error: MCP_API_KEY environment variable is required")
-    console.error("Error: MCP_API_KEY environment variable is required")
-    console.error(
-      "Please set your Intangle API key in the Claude Desktop configuration"
-    )
-    process.exit(1)
-  }
-
-  console.error("Intangle MCP Server starting - connecting to", API_BASE_URL)
-
-  // Version checking - automatically read from package.json
-  const __dirname = dirname(fileURLToPath(import.meta.url))
-  let packageJson
-  try {
-    packageJson = JSON.parse(
-      readFileSync(join(__dirname, "package.json"), "utf-8")
-    )
-  } catch {
-    packageJson = JSON.parse(
-      readFileSync(join(__dirname, "../package.json"), "utf-8")
-    )
-  }
-  const CURRENT_VERSION = packageJson.version
-  let latestVersion: string | null = null
-  let versionCheckDone = false
-
-  async function checkVersion() {
-    if (versionCheckDone) return
-
-    try {
-      const response = await fetch(
-        "https://registry.npmjs.org/@intangle/mcp-server/latest"
-      )
-      const data = (await response.json()) as { version: string }
-      latestVersion = data.version
-      versionCheckDone = true
-
-      if (latestVersion && latestVersion !== CURRENT_VERSION) {
-        console.error("\n UPDATE AVAILABLE ")
-        console.error(`Current version: ${CURRENT_VERSION}`)
-        console.error(`Latest version: ${latestVersion}`)
-        console.error("Update with: npx @intangle/mcp-server@latest\n")
-      } else {
-        console.error(`✓ Running latest version (${CURRENT_VERSION})`)
-      }
-    } catch (error) {
-      // Silently fail version check - don't block startup
-      versionCheckDone = true
-    }
-  }
-
-  // Check version on startup (non-blocking)
-  checkVersion()
-
-  // Helper to ensure client info is captured (called before API requests)
-  function ensureClientInfo() {
-    if (!mcpClientName) {
-      const clientInfo = server.getClientVersion()
-      if (clientInfo) {
-        mcpClientName = clientInfo.name
-        mcpClientVersion = clientInfo.version
-        log(
-          `Client identified (on-demand): ${mcpClientName} v${mcpClientVersion}`
-        )
-      }
-    }
-  }
-
-  // Default timeout for API calls (90 seconds)
-  const API_TIMEOUT_MS = 90_000
-
-  function buildApiUrl(endpoint: string) {
-    const url = new URL(`/api/mcp/${endpoint}`, API_BASE_URL)
-
-    if (VERCEL_BYPASS_TOKEN) {
-      url.searchParams.set("x-vercel-protection-bypass", VERCEL_BYPASS_TOKEN)
-    }
-
-    return url.toString()
-  }
-
-  function buildRemoteApiUrl() {
-    const url = new URL("/api/mcp-remote", API_BASE_URL)
-
-    if (VERCEL_BYPASS_TOKEN) {
-      url.searchParams.set("x-vercel-protection-bypass", VERCEL_BYPASS_TOKEN)
-    }
-
-    return url.toString()
-  }
-
-  async function makeApiCall(endpoint: string, data: any, timeoutMs?: number) {
-    // Ensure we have client info before making requests
-    ensureClientInfo()
-
-    // Build headers with client info if available
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${MCP_API_KEY}`,
-      "User-Agent": mcpClientName
-        ? `${mcpClientName}/${mcpClientVersion || "unknown"} (mcp-stdio)`
-        : "MCP-Client-Stdio/1.1.2 (mcp)",
-    }
-
-    // Add explicit client info headers for backend processing
-    if (mcpClientName) {
-      headers["X-MCP-Client-Name"] = mcpClientName
-    }
-    if (mcpClientVersion) {
-      headers["X-MCP-Client-Version"] = mcpClientVersion
-    }
-    if (VERCEL_BYPASS_TOKEN) {
-      headers["x-vercel-protection-bypass"] = VERCEL_BYPASS_TOKEN
-    }
-
-    // Apply timeout to prevent hanging requests
-    const controller = new AbortController()
-    const effectiveTimeout = timeoutMs || API_TIMEOUT_MS
-    const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout)
-
-    try {
-      const response = await fetch(buildApiUrl(endpoint), {
-        method: "POST",
-        headers,
-        body: JSON.stringify(data),
-        signal: controller.signal as AbortSignal,
-      })
-
-      const contentType = response.headers.get("content-type") || ""
-      const responseBody = await response.text()
-
-      if (!response.ok) {
-        if (
-          response.status === 401 &&
-          contentType.includes("text/html") &&
-          responseBody.includes("Vercel Authentication")
-        ) {
-          throw new Error(
-            VERCEL_BYPASS_TOKEN
-              ? "API call blocked by Vercel deployment protection despite bypass token. Check token validity and deployment protection settings."
-              : "API call blocked by Vercel deployment protection. Set VERCEL_BYPASS_TOKEN in MCP server env."
-          )
-        }
-
-        throw new Error(
-          `API call failed: ${response.status} ${response.statusText}`
-        )
-      }
-
-      if (responseBody.trim() === "") {
-        return {}
-      }
-
-      if (
-        contentType.includes("text/html") ||
-        /^\s*<!DOCTYPE\s+html/i.test(responseBody) ||
-        /^\s*<html\b/i.test(responseBody)
-      ) {
-        throw new Error(
-          `API call to ${buildApiUrl(endpoint)} returned HTML instead of JSON. Check NEXT_APP_URL and point it at the app host, e.g. https://renvoi.co/intangle.`
-        )
-      }
-
-      return JSON.parse(responseBody)
-    } catch (error: unknown) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(
-          `API call to ${endpoint} timed out after ${effectiveTimeout / 1000}s`
-        )
-      }
-      throw error
-    } finally {
-      clearTimeout(timeoutId)
-    }
-  }
-
-  async function makeRemoteRpcCall(
-    method: string,
-    params: Record<string, unknown>
-  ) {
-    ensureClientInfo()
-
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${MCP_API_KEY}`,
-      "User-Agent": mcpClientName
-        ? `${mcpClientName}/${mcpClientVersion || "unknown"} (mcp-stdio)`
-        : "MCP-Client-Stdio/1.1.2 (mcp)",
-    }
-
-    if (mcpClientName) {
-      headers["X-MCP-Client-Name"] = mcpClientName
-    }
-    if (mcpClientVersion) {
-      headers["X-MCP-Client-Version"] = mcpClientVersion
-    }
-    if (VERCEL_BYPASS_TOKEN) {
-      headers["x-vercel-protection-bypass"] = VERCEL_BYPASS_TOKEN
-    }
-
-    const requestId = Date.now()
-    const rpcBody = {
-      jsonrpc: "2.0",
-      id: requestId,
-      method,
-      params,
-    }
-
-    const response = await fetch(buildRemoteApiUrl(), {
-      method: "POST",
-      headers,
-      body: JSON.stringify(rpcBody),
-    })
-
-    const responseText = await response.text()
-    let responseJson: any = {}
-
-    try {
-      responseJson = responseText ? JSON.parse(responseText) : {}
-    } catch {
-      throw new Error(`Failed to parse MCP remote ${method} response`)
-    }
-
-    if (!response.ok) {
-      const message =
-        responseJson?.error?.message ||
-        responseJson?.message ||
-        `${response.status} ${response.statusText}`
-      throw new Error(`MCP remote ${method} failed: ${message}`)
-    }
-
-    if (responseJson?.error) {
-      const code = responseJson.error.code
-      const message = responseJson.error.message || "Unknown MCP remote error"
-      throw new Error(`MCP remote ${method} error (${code}): ${message}`)
-    }
-
-    return responseJson?.result ?? {}
-  }
-
-  const server = new Server(
-    {
-      name: "intangle-context",
-      version: "1.0.0",
-      icons: [
-        {
-          src: "https://intangle.tools/icon.png",
-          mimeType: "image/png",
-        },
-      ],
-    },
-    {
-      capabilities: {
-        resources: {},
-        tools: {},
-      },
-    }
-  )
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOLS,
-  }))
-
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    const result = await makeRemoteRpcCall("resources/list", {})
-    return {
-      resources: Array.isArray(result?.resources) ? result.resources : [],
-      nextCursor:
-        typeof result?.nextCursor === "string" ? result.nextCursor : undefined,
-    }
-  })
-
-  server.setRequestHandler(ReadResourceRequestSchema, async (request: any) => {
-    const uri = request?.params?.uri
-    if (!uri || typeof uri !== "string") {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        "uri is required for resources/read"
-      )
-    }
-
-    const result = await makeRemoteRpcCall("resources/read", { uri })
-    return {
-      contents: Array.isArray(result?.contents) ? result.contents : [],
-    }
-  })
-
-  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
-    const result = await makeRemoteRpcCall("resources/templates/list", {})
-    return {
-      resourceTemplates: Array.isArray(result?.resourceTemplates)
-        ? result.resourceTemplates
-        : [],
-    }
-  })
-
-  async function handleSearchContext(args: any) {
-    const { space_id, query, topics, group_id, project_id, folder_id } = args as {
-      space_id: string
-      query: string
-      topics?: string[]
-      group_id?: string
-      project_id?: string
-      folder_id?: string
-    }
-
-    // Require space_id
-    if (!space_id) {
-      throw new Error(
-        "space_id is required. Use list_spaces to see available options."
-      )
-    }
-
-    return makeApiCall("search", {
-      space_id,
-      query,
-      group_id,
-      project_id,
-      folder_id,
-      topics,
-    })
-  }
-
-  async function handleFetch(args: any) {
-    const { id, ids, space_id } = args as {
-      id?: string
-      ids?: string[]
-      space_id?: string
-    }
-
-    return makeApiCall("fetch", { id, ids, space_id })
-  }
-
-  async function handleUsageStatus() {
-    return makeApiCall("usage-status", {})
-  }
-
-  async function handleFetchConversationMessages(args: any) {
-    const { space_id, conversation_id } = args as {
-      space_id?: string
-      conversation_id?: string
-    }
-
-    if (!space_id || !conversation_id) {
-      throw new Error("space_id and conversation_id are required")
-    }
-
-    return makeApiCall("conversation-messages", args)
-  }
-
-  async function handleSubscribeConversation(args: any) {
-    const { space_id, conversation_id } = args as {
-      space_id?: string
-      conversation_id?: string
-    }
-
-    if (!space_id || !conversation_id) {
-      throw new Error("space_id and conversation_id are required")
-    }
-
-    return makeApiCall("conversation-subscribe", args)
-  }
-
-  async function handleConversationInbox(args: any) {
-    const { space_id } = args as { space_id?: string }
-
-    if (!space_id) {
-      throw new Error("space_id is required")
-    }
-
-    return makeApiCall("conversation-inbox", args)
-  }
-
-  async function handleMarkConversationRead(args: any) {
-    const { space_id, conversation_id } = args as {
-      space_id?: string
-      conversation_id?: string
-    }
-
-    if (!space_id || !conversation_id) {
-      throw new Error("space_id and conversation_id are required")
-    }
-
-    return makeApiCall("conversation-read", args)
-  }
-
-  async function handleViewSpaces() {
-    return makeApiCall("list-spaces", {})
-  }
-
-  async function handleViewGroups(args: any) {
-    const { space_id } = args as { space_id?: string }
-    if (!space_id) {
-      throw new Error(
-        "space_id is required. Use view_spaces to see available options."
-      )
-    }
-
-    return makeApiCall("view-groups", args)
-  }
-
-  async function handleViewProjects(args: any) {
-    const { space_id } = args as { space_id: string }
-    if (!space_id) {
-      throw new Error(
-        "space_id is required. Use view_spaces to see available options."
-      )
-    }
-    return makeApiCall("view-projects", args)
-  }
-
-  async function handleViewProject(args: any) {
-    const { project_id, space_id, slug } = args as {
-      project_id?: string
-      space_id?: string
-      slug?: string
-    }
-
-    if (!project_id && !slug) {
-      throw new Error(
-        "Either project_id or slug (with space_id) is required. Use view_projects to get valid IDs."
-      )
-    }
-
-    if (!space_id) {
-      throw new Error(
-        "space_id is required. Use view_spaces to see available options."
-      )
-    }
-
-    return makeApiCall("view-project", args)
-  }
-
-  async function handleCreateGroup(args: any) {
-    const { space_id, name } = args as { space_id?: string; name?: string }
-    if (!space_id || !name) {
-      throw new Error("space_id and name are required")
-    }
-
-    return makeApiCall("create-group", args)
-  }
-
-  async function handleRenameGroup(args: any) {
-    const { space_id, group_id, name } = args as {
-      space_id?: string
-      group_id?: string
-      name?: string
-    }
-
-    if (!space_id || !group_id || !name) {
-      throw new Error("space_id, group_id, and name are required")
-    }
-
-    return makeApiCall("rename-group", args)
-  }
-
-  async function handleDeleteGroup(args: any) {
-    const { space_id, group_id } = args as {
-      space_id?: string
-      group_id?: string
-    }
-
-    if (!space_id || !group_id) {
-      throw new Error("space_id and group_id are required")
-    }
-
-    return makeApiCall("delete-group", args)
-  }
-
-  async function handleCreateProject(args: any) {
-    const { space_id, name, group_id } = args as {
-      space_id?: string
-      name?: string
-      group_id?: string
-    }
-
-    if (!space_id || !name) {
-      throw new Error("space_id and name are required")
-    }
-
-    return makeApiCall("create-project", args)
-  }
-
-  async function handleRenameProject(args: any) {
-    const { space_id, project_id, name } = args as {
-      space_id?: string
-      project_id?: string
-      name?: string
-    }
-
-    if (!space_id || !project_id || !name) {
-      throw new Error("space_id, project_id, and name are required")
-    }
-
-    return makeApiCall("rename-project", args)
-  }
-
-  async function handleDeleteProject(args: any) {
-    const { space_id, project_id } = args as {
-      space_id?: string
-      project_id?: string
-    }
-
-    if (!space_id || !project_id) {
-      throw new Error("space_id and project_id are required")
-    }
-
-    return makeApiCall("delete-project", args)
-  }
-
-  async function handleAssignProjectToGroup(args: any) {
-    const { space_id, project_id, group_id } = args as {
-      space_id?: string
-      project_id?: string
-      group_id?: string | null
-    }
-
-    if (!space_id || !project_id) {
-      throw new Error("space_id and project_id are required")
-    }
-
-    return makeApiCall("assign-project-to-group", args)
-  }
-
-  async function handleCreateSpace(args: any) {
-    return makeApiCall("create-space", args)
-  }
-
-  async function handleViewSpace(args: any) {
-    const { space_id } = args as { space_id: string }
-    return makeApiCall("view-space", args)
-  }
-
-  async function handleStart(args: any) {
-    const { space_id } = args as { space_id: string }
-    return makeApiCall("start", args)
-  }
-
-  async function handleUpdateSpace(args: any) {
-    if (!args.space_id) {
-      throw new Error(
-        "space_id is required. Use view_spaces to see available options."
-      )
-    }
-
-    if (!args.add && !args.update && !args.delete) {
-      throw new Error("At least one operation must be provided")
-    }
-
-    // Ensure all add items have a type field to prevent classification timeout
-    const add = args.add
-    if (add?.items && Array.isArray(add.items)) {
-      for (const item of add.items) {
-        if (!item.type) {
-          log(
-            `WARNING: Item "${item.title}" missing type field, defaulting to "context" to prevent classification timeout`
-          )
-          item.type = "context"
-        }
-      }
-    }
-
-    // Pass through to API with new structure
-    return makeApiCall("update-memory", {
-      space_id: args.space_id,
-      project_id: args.project_id,
-      add,
-      update: args.update,
-      delete: args.delete,
-    })
-  }
-
-  async function handleUpdateFolders(args: any) {
-    if (!args.space_id) {
-      throw new Error(
-        "space_id is required. Use view_spaces to see available options."
-      )
-    }
-
-    const hasOperation =
-      !!args.list ||
-      (Array.isArray(args.create) && args.create.length > 0) ||
-      (Array.isArray(args.rename) && args.rename.length > 0) ||
-      (Array.isArray(args.move_items) && args.move_items.length > 0) ||
-      (Array.isArray(args.delete) && args.delete.length > 0)
-
-    if (!hasOperation) {
-      throw new Error(
-        "At least one operation is required: list, create, rename, move_items, or delete."
-      )
-    }
-
-    return makeApiCall("update-folders", {
-      space_id: args.space_id,
-      list: args.list,
-      create: args.create,
-      rename: args.rename,
-      move_items: args.move_items,
-      delete: args.delete,
-    })
-  }
-
-  async function handleMessage(args: any) {
-    if (!args.space_id || !args.content) {
-      throw new Error("space_id and content are required")
-    }
-
-    // Keep one-turn MCP calls safely under common external tool-call deadlines
-    // while still allowing caller override for longer jobs.
-    const timeoutMs =
-      typeof args.timeout_ms === "number" && Number.isFinite(args.timeout_ms)
-        ? Math.max(10_000, Math.min(300_000, Math.trunc(args.timeout_ms)))
-        : 100_000
-
-    // Give backend a little extra headroom beyond requested assistant timeout.
-    const requestTimeout = timeoutMs + 10_000
-
-    return makeApiCall(
-      "message",
-      { ...args, timeout_ms: timeoutMs },
-      requestTimeout
-    )
-  }
-
-  server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
-    const { name, arguments: args } = request.params
-
-    try {
-      let result: any
-
-      switch (name) {
-        case "search":
-          result = await handleSearchContext(args)
-          break
-        case "fetch_items":
-          result = await handleFetch(args)
-          break
-        case "usage_status":
-          result = await handleUsageStatus()
-          break
-        case "fetch_conversation_messages":
-          result = await handleFetchConversationMessages(args)
-          break
-        case "subscribe_conversation":
-          result = await handleSubscribeConversation(args)
-          break
-        case "list_conversation_inbox":
-          result = await handleConversationInbox(args)
-          break
-        case "mark_conversation_read":
-          result = await handleMarkConversationRead(args)
-          break
-        case "view_spaces":
-          result = await handleViewSpaces()
-          break
-        case "view_groups":
-          result = await handleViewGroups(args)
-          break
-        case "create_group":
-          result = await handleCreateGroup(args)
-          break
-        case "rename_group":
-          result = await handleRenameGroup(args)
-          break
-        case "delete_group":
-          result = await handleDeleteGroup(args)
-          break
-        case "view_projects":
-          result = await handleViewProjects(args)
-          break
-        case "view_project":
-          result = await handleViewProject(args)
-          break
-        case "create_project":
-          result = await handleCreateProject(args)
-          break
-        case "rename_project":
-          result = await handleRenameProject(args)
-          break
-        case "delete_project":
-          result = await handleDeleteProject(args)
-          break
-        case "assign_project_to_group":
-          result = await handleAssignProjectToGroup(args)
-          break
-        case "create_space":
-          result = await handleCreateSpace(args)
-          break
-        case "view_space":
-          result = await handleViewSpace(args)
-          break
-        case "start":
-          result = await handleStart(args)
-          break
-        case "update_memory":
-        case "update_space":
-          result = await handleUpdateSpace(args)
-          break
-        case "update_folders":
-          result = await handleUpdateFolders(args)
-          break
-        case "message":
-          result = await handleMessage(args)
-          break
-        default:
-          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
-      }
-
-      // Extract response field for Layer 2 compressed tools, otherwise stringify full result
-      let responseText: string
-      if (
-        result &&
-        typeof result === "object" &&
-        "response" in result &&
-        typeof result.response === "string"
-      ) {
-        // Tool has Layer 2 compression - use the formatted response field
-        responseText = result.response
-      } else {
-        // Standard tool - return full JSON
-        responseText = JSON.stringify(result, null, 2)
-      }
-
-      // Add version warning to response if outdated
-      if (latestVersion && latestVersion !== CURRENT_VERSION) {
-        const warning = `\n\n UPDATE AVAILABLE: MCP Server v${latestVersion} is available (you're on v${CURRENT_VERSION}). Update with: npx @intangle/mcp-server@latest`
-        responseText += warning
-      }
-
-      return {
-        content: [{ type: "text", text: responseText }],
-      }
-    } catch (error) {
-      throw new McpError(
-        ErrorCode.InternalError,
-        `Error executing tool ${name}: ${error instanceof Error ? error.message : String(error)}`
-      )
-    }
-  })
-
-  async function main() {
-    const transport = new StdioServerTransport()
-    await server.connect(transport)
-    log("Server connected to transport")
-    // Client info is captured on-demand in ensureClientInfo() before first API call
-  }
-
-  main().catch((err) => {
-    log(`Error in main: ${err}`)
-    process.exit(1)
-  })
-} catch (err) {
-  log(`Fatal startup error: ${err}`)
-  process.exit(1)
-}