lantern-connect 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# lantern-connect
+
+CLI installer to connect AI tools to Lantern.
+
+## Installation
+
+```bash
+npx lantern-connect
+```
+
+Or install globally:
+
+```bash
+npm install -g lantern-connect
+lantern-connect
+```
+
+## Usage
+
+```bash
+# Production (default)
+lantern-connect
+
+# Local development with ngrok
+lantern-connect --mcp-url https://your-ngrok-url.ngrok-free.dev/mcp
+
+# Custom Lantern instance
+lantern-connect --lantern-url https://your-lantern.com --mcp-url https://api.your-lantern.com/mcp
+```
+
+## Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--mcp-url <url>` | MCP server URL | `https://api.onlantern.com/mcp` |
+| `--lantern-url <url>` | Lantern web URL for authentication | `https://onlantern.com` |
+| `--help, -h` | Show help message | |
+
+## What it does
+
+1. **Detects** installed AI tools (Claude Desktop, Claude Code, Gemini CLI, Cursor)
+2. **Authenticates** with your Lantern account via browser
+3. **Configures** each detected tool to connect to Lantern's MCP server
+
+## Supported Tools
+
+| Tool | Config Location | Method |
+|------|-----------------|--------|
+| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` | mcp-remote |
+| Claude Code | `~/.claude.json` | `claude mcp add` |
+| Gemini CLI | `~/.gemini/settings.json` | httpUrl config |
+| Cursor | `~/.cursor/mcp.json` | url config |
+
+## After Installation
+
+1. **Fully quit and reopen** your AI tools (Cmd+Q on macOS)
+2. **Claude Desktop only:** Go to Settings → Connectors → click "lantern" to authenticate
+3. Start using Lantern:
+   - Say "save to lantern" to export a conversation
+   - Say "list my lantern conversations" to see your library
+   - Say "load my lantern collection" to import a collection
+
+## Local Development
+
+```bash
+# Start your local Lantern backend and frontend
+cd lantern && npm run dev
+cd lantern/frontend && npm run dev
+
+# Start ngrok to expose backend (required for Claude Desktop)
+ngrok http 3001
+
+# Run the CLI with your ngrok URL
+cd lantern-connect
+node bin/lantern-connect.js --mcp-url https://your-ngrok-url.ngrok-free.dev/mcp --lantern-url http://localhost:3000
+```
+
+## Troubleshooting
+
+### Claude Desktop shows "Server disconnected"
+- Make sure you're using an ngrok URL (Claude Desktop can't reach localhost)
+- Restart Claude Desktop completely (Cmd+Q, not just close window)
+
+### Gemini CLI shows "Bad Request" for SSE
+- Make sure your backend has the latest MCP session handling code
+- Restart your backend server
+
+### CORS errors on localhost:3000
+- Make sure your frontend's `.env.local` has `NEXT_PUBLIC_API_URL=http://localhost:3001`
+- The `--mcp-url` flag is for the CLI/MCP tools, not the frontend

package/bin/lantern-connect.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from '../src/index.js'
+
+main().catch((err) => {
+  console.error('\n❌ Error:', err.message)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "lantern-connect",
+  "version": "0.1.0",
+  "description": "CLI installer to connect AI tools (Claude, Gemini, Cursor) to Lantern",
+  "type": "module",
+  "bin": {
+    "lantern-connect": "./bin/lantern-connect.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "start": "node bin/lantern-connect.js"
+  },
+  "keywords": [
+    "lantern",
+    "mcp",
+    "claude",
+    "gemini",
+    "cursor",
+    "ai",
+    "cli",
+    "model-context-protocol"
+  ],
+  "author": "Lantern",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onlantern/lantern-connect"
+  },
+  "homepage": "https://onlantern.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "open": "^10.1.0"
+  }
+}

package/src/auth.js

@@ -0,0 +1,171 @@
+import { createServer } from 'http'
+import { URL } from 'url'
+import open from 'open'
+
+const CALLBACK_PORT = 8765
+const DEFAULT_LANTERN_URL = process.env.LANTERN_URL || 'https://onlantern.com'
+const DEFAULT_MCP_URL = process.env.MCP_URL || 'https://api.onlantern.com/mcp'
+
+function createSuccessHtml(email) {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Lantern Connected</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: #0a0a0a;
+      color: #fafafa;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      font-size: 1.5rem;
+      margin-bottom: 0.5rem;
+    }
+    p {
+      color: #a1a1aa;
+      margin-bottom: 1.5rem;
+    }
+    .close-note {
+      font-size: 0.875rem;
+      color: #71717a;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">✓</div>
+    <h1>Connected to Lantern</h1>
+    <p>Logged in as ${email}</p>
+    <p class="close-note">You can close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>
+`
+}
+
+function createErrorHtml(message) {
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Lantern - Error</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: #0a0a0a;
+      color: #fafafa;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+    }
+    .icon {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+    }
+    h1 {
+      font-size: 1.5rem;
+      margin-bottom: 0.5rem;
+      color: #ef4444;
+    }
+    p {
+      color: #a1a1aa;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="icon">✗</div>
+    <h1>Connection Failed</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>
+`
+}
+
+export async function authenticate(options = {}) {
+  const lanternUrl = options.lanternUrl || DEFAULT_LANTERN_URL
+  const mcpUrlOverride = options.mcpUrl || DEFAULT_MCP_URL
+
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`)
+
+      if (url.pathname === '/callback') {
+        const token = url.searchParams.get('token')
+        const mcpUrl = url.searchParams.get('mcp_url') || mcpUrlOverride
+        const email = url.searchParams.get('email')
+        const error = url.searchParams.get('error')
+
+        if (error) {
+          res.writeHead(200, { 'Content-Type': 'text/html' })
+          res.end(createErrorHtml(error))
+          server.close()
+          reject(new Error(error))
+          return
+        }
+
+        if (!token) {
+          res.writeHead(200, { 'Content-Type': 'text/html' })
+          res.end(createErrorHtml('Missing token'))
+          server.close()
+          reject(new Error('Missing token in callback'))
+          return
+        }
+
+        res.writeHead(200, { 'Content-Type': 'text/html' })
+        res.end(createSuccessHtml(email || 'unknown'))
+
+        server.close()
+        resolve({ token, mcpUrl, email })
+      } else {
+        res.writeHead(404)
+        res.end('Not found')
+      }
+    })
+
+    server.listen(CALLBACK_PORT, '127.0.0.1', () => {
+      const authUrl = new URL(`${lanternUrl}/auth/cli`)
+      authUrl.searchParams.set('callback_port', CALLBACK_PORT)
+      authUrl.searchParams.set('mcp_url', mcpUrlOverride)
+      console.log(`   Opening browser...`)
+      open(authUrl.toString())
+    })
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        reject(new Error(`Port ${CALLBACK_PORT} is already in use. Please close any other lantern-connect instances.`))
+      } else {
+        reject(err)
+      }
+    })
+
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      server.close()
+      reject(new Error('Authentication timed out. Please try again.'))
+    }, 5 * 60 * 1000)
+  })
+}

package/src/configure/claude-code.js

@@ -0,0 +1,17 @@
+import { execSync } from 'child_process'
+
+export function configureClaudeCode(mcpUrl) {
+  // First, try to remove existing lantern config (ignore errors if it doesn't exist)
+  try {
+    execSync('claude mcp remove lantern', { stdio: 'ignore' })
+  } catch {
+    // Ignore - server might not exist yet
+  }
+
+  // Add the new MCP server
+  execSync(`claude mcp add --transport http lantern ${mcpUrl}`, {
+    stdio: 'inherit',
+  })
+
+  return 'claude mcp'
+}

package/src/configure/claude-desktop.js

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { dirname } from 'path'
+import { tools } from '../detect.js'
+
+export function configureClaudeDesktop(mcpUrl) {
+  const configPath = tools.claudeDesktop.configPath()
+
+  // Ensure directory exists
+  const configDir = dirname(configPath)
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true })
+  }
+
+  // Read existing config or create new one
+  let config = {}
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, 'utf-8')
+      config = JSON.parse(content)
+    } catch {
+      // If file exists but is invalid JSON, start fresh
+      config = {}
+    }
+  }
+
+  // Add/update Lantern MCP server using mcp-remote to bridge HTTP
+  config.mcpServers = config.mcpServers || {}
+  config.mcpServers.lantern = {
+    command: 'npx',
+    args: ['mcp-remote', mcpUrl],
+  }
+
+  // Write config
+  writeFileSync(configPath, JSON.stringify(config, null, 2))
+
+  return configPath
+}

package/src/configure/cursor.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { dirname } from 'path'
+import { tools } from '../detect.js'
+
+export function configureCursor(mcpUrl) {
+  const configPath = tools.cursor.configPath()
+
+  // Ensure directory exists
+  const configDir = dirname(configPath)
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true })
+  }
+
+  // Read existing config or create new one
+  let config = {}
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, 'utf-8')
+      config = JSON.parse(content)
+    } catch {
+      // If file exists but is invalid JSON, start fresh
+      config = {}
+    }
+  }
+
+  // Add/update Lantern MCP server
+  config.mcpServers = config.mcpServers || {}
+  config.mcpServers.lantern = {
+    url: mcpUrl,
+  }
+
+  // Write config
+  writeFileSync(configPath, JSON.stringify(config, null, 2))
+
+  return configPath
+}

package/src/configure/gemini-cli.js

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { dirname } from 'path'
+import { tools } from '../detect.js'
+
+export function configureGeminiCli(mcpUrl) {
+  const configPath = tools.geminiCli.configPath()
+
+  // Ensure directory exists
+  const configDir = dirname(configPath)
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true })
+  }
+
+  // Read existing config or create new one
+  let config = {}
+  if (existsSync(configPath)) {
+    try {
+      const content = readFileSync(configPath, 'utf-8')
+      config = JSON.parse(content)
+    } catch {
+      // If file exists but is invalid JSON, start fresh
+      config = {}
+    }
+  }
+
+  // Add/update Lantern MCP server
+  config.mcpServers = config.mcpServers || {}
+  config.mcpServers.lantern = {
+    httpUrl: mcpUrl,
+    timeout: 30000,
+  }
+
+  // Write config
+  writeFileSync(configPath, JSON.stringify(config, null, 2))
+
+  return configPath
+}

package/src/detect.js

@@ -0,0 +1,89 @@
+import { existsSync } from 'fs'
+import { homedir, platform } from 'os'
+import { join } from 'path'
+import { execSync } from 'child_process'
+
+function expandHome(path) {
+  if (path.startsWith('~')) {
+    return join(homedir(), path.slice(1))
+  }
+  return path
+}
+
+function commandExists(command) {
+  try {
+    execSync(`which ${command}`, { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function getClaudeDesktopPath() {
+  const os = platform()
+  if (os === 'darwin') {
+    return expandHome('~/Library/Application Support/Claude')
+  } else if (os === 'win32') {
+    return join(process.env.APPDATA || '', 'Claude')
+  } else {
+    // Linux
+    return expandHome('~/.config/Claude')
+  }
+}
+
+function getClaudeDesktopConfigPath() {
+  return join(getClaudeDesktopPath(), 'claude_desktop_config.json')
+}
+
+function getCursorPath() {
+  // Cursor uses ~/.cursor for MCP config on all platforms
+  return expandHome('~/.cursor')
+}
+
+function getCursorConfigPath() {
+  return join(getCursorPath(), 'mcp.json')
+}
+
+function getGeminiConfigPath() {
+  return expandHome('~/.gemini/settings.json')
+}
+
+export const tools = {
+  claudeDesktop: {
+    name: 'Claude Desktop',
+    detect: () => existsSync(getClaudeDesktopPath()),
+    configPath: getClaudeDesktopConfigPath,
+  },
+  claudeCode: {
+    name: 'Claude Code',
+    detect: () => commandExists('claude'),
+    configPath: null, // Uses CLI command instead
+  },
+  geminiCli: {
+    name: 'Gemini CLI',
+    detect: () => commandExists('gemini'),
+    configPath: getGeminiConfigPath,
+  },
+  cursor: {
+    name: 'Cursor',
+    detect: () => existsSync(getCursorPath()),
+    configPath: getCursorConfigPath,
+  },
+}
+
+export function detectTools() {
+  const detected = {}
+
+  for (const [key, tool] of Object.entries(tools)) {
+    detected[key] = {
+      ...tool,
+      found: tool.detect(),
+    }
+  }
+
+  return detected
+}
+
+export function hasAnyTools(detected) {
+  return Object.values(detected).some((tool) => tool.found)
+}

package/src/index.js

@@ -0,0 +1,147 @@
+import { detectTools, hasAnyTools } from './detect.js'
+import { authenticate } from './auth.js'
+import { configureClaudeDesktop } from './configure/claude-desktop.js'
+import { configureClaudeCode } from './configure/claude-code.js'
+import { configureGeminiCli } from './configure/gemini-cli.js'
+import { configureCursor } from './configure/cursor.js'
+
+const configurators = {
+  claudeDesktop: configureClaudeDesktop,
+  claudeCode: configureClaudeCode,
+  geminiCli: configureGeminiCli,
+  cursor: configureCursor,
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2)
+  const options = {
+    mcpUrl: null,
+    lanternUrl: null,
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--mcp-url' && args[i + 1]) {
+      options.mcpUrl = args[i + 1]
+      i++
+    } else if (args[i] === '--lantern-url' && args[i + 1]) {
+      options.lanternUrl = args[i + 1]
+      i++
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      console.log(`
+  Usage: lantern-connect [options]
+
+  Options:
+    --mcp-url <url>      MCP server URL (default: https://api.onlantern.com/mcp)
+    --lantern-url <url>  Lantern web URL (default: https://onlantern.com)
+    --help, -h           Show this help message
+`)
+      process.exit(0)
+    }
+  }
+
+  return options
+}
+
+export async function main() {
+  const options = parseArgs()
+  console.log('')
+  console.log('  🔥 Lantern Connect')
+  console.log('  ─────────────────')
+  console.log('')
+
+  // Step 1: Detect installed tools
+  console.log('  🔍 Detecting AI tools...')
+  console.log('')
+
+  const detected = detectTools()
+
+  for (const [key, tool] of Object.entries(detected)) {
+    const icon = tool.found ? '✓' : '✗'
+    const color = tool.found ? '\x1b[32m' : '\x1b[90m'
+    const reset = '\x1b[0m'
+    console.log(`     ${color}${icon} ${tool.name}${reset}`)
+  }
+
+  console.log('')
+
+  if (!hasAnyTools(detected)) {
+    console.log('  ⚠️  No supported AI tools found.')
+    console.log('')
+    console.log('  Supported tools:')
+    console.log('    • Claude Desktop')
+    console.log('    • Claude Code (claude CLI)')
+    console.log('    • Gemini CLI')
+    console.log('    • Cursor')
+    console.log('')
+    process.exit(1)
+  }
+
+  // Step 2: Authenticate
+  console.log('  🔐 Authenticating with Lantern...')
+
+  let authResult
+  try {
+    authResult = await authenticate({
+      lanternUrl: options.lanternUrl,
+      mcpUrl: options.mcpUrl,
+    })
+  } catch (err) {
+    console.log('')
+    console.log(`  ❌ Authentication failed: ${err.message}`)
+    console.log('')
+    process.exit(1)
+  }
+
+  console.log(`     ✓ Logged in as ${authResult.email}`)
+  console.log('')
+
+  // Step 3: Configure each detected tool
+  console.log('  📝 Configuring...')
+  console.log('')
+
+  const configured = []
+  const failed = []
+
+  for (const [key, tool] of Object.entries(detected)) {
+    if (!tool.found) continue
+
+    const configurator = configurators[key]
+    if (!configurator) continue
+
+    try {
+      const result = configurator(authResult.mcpUrl)
+      configured.push({ name: tool.name, path: result })
+      console.log(`     ✓ ${tool.name}`)
+    } catch (err) {
+      failed.push({ name: tool.name, error: err.message })
+      console.log(`     ✗ ${tool.name}: ${err.message}`)
+    }
+  }
+
+  console.log('')
+
+  // Step 4: Summary
+  if (configured.length > 0) {
+    console.log('  🎉 Done!')
+    console.log('')
+    console.log('  Next steps:')
+    console.log('    1. Fully quit and reopen your AI tools (Cmd+Q on macOS)')
+
+    // Check if Claude Desktop was configured
+    if (detected.claudeDesktop?.found) {
+      console.log('    2. In Claude Desktop: Settings → Connectors → click "lantern" to authenticate')
+      console.log('    3. Say "save to lantern" to export a conversation')
+    } else {
+      console.log('    2. Say "save to lantern" to export a conversation')
+    }
+    console.log('')
+  }
+
+  if (failed.length > 0) {
+    console.log('  ⚠️  Some tools could not be configured:')
+    for (const f of failed) {
+      console.log(`     • ${f.name}: ${f.error}`)
+    }
+    console.log('')
+  }
+}