@proplandev/mcp 1.0.0

package/adapters/BackendApiAdapter.js

@@ -0,0 +1,75 @@
+// mcp-server/adapters/BackendApiAdapter.js
+import { randomUUID } from 'crypto';
+
+export class BackendApiAdapter {
+  constructor(token, apiUrl) {
+    this._token = token;
+    this._apiUrl = apiUrl;
+  }
+
+  getUserId() {
+    return 'cloud';
+  }
+
+  _headers() {
+    return {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${this._token}`,
+    };
+  }
+
+  async _request(method, path, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30_000);
+
+    try {
+      const res = await fetch(`${this._apiUrl}${path}`, {
+        method,
+        headers: this._headers(),
+        body: body ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+
+      if (!res.ok) {
+        if (res.status === 404) return null;
+        const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+        throw new Error(err.error || `Request failed: ${res.status}`);
+      }
+
+      return res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async listProjects() {
+    return (await this._request('GET', '/api/mcp/projects')) ?? [];
+  }
+
+  async getProject(projectId) {
+    return this._request('GET', `/api/mcp/projects/${projectId}`);
+  }
+
+  async saveProject(projectId, title, content, _updatedAt) {
+    await this._request('PUT', `/api/mcp/projects/${projectId}`, { title, content });
+  }
+
+  async insertProject(title, content) {
+    const id = randomUUID();
+    const result = await this._request('POST', '/api/mcp/projects', { id, title, content });
+    // Use the id we sent so local and cloud UUIDs stay in sync
+    return { id: result?.id ?? id };
+  }
+
+  async deleteProject(projectId) {
+    await this._request('DELETE', `/api/mcp/projects/${projectId}`);
+  }
+
+  async renameProject(projectId, newTitle, _updatedAt) {
+    await this._request('PUT', `/api/mcp/projects/${projectId}`, { title: newTitle });
+  }
+
+  // These are local-only operations — no-ops in cloud mode
+  getProjectsSyncStatus() { return []; }
+  markSynced(_projectId, _syncedAt) {}
+}

package/adapters/SqliteAdapter.js

@@ -0,0 +1,82 @@
+// mcp-server/adapters/SqliteAdapter.js
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { randomUUID } from 'crypto';
+
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL DEFAULT 'local',
+    title TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+`;
+
+export class SqliteAdapter {
+  constructor(dbPath) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this._db = new Database(dbPath);
+    this._db.exec(SCHEMA);
+  }
+
+  _applyMigrations() {
+    const cols = this._db.pragma('table_info(projects)');
+    if (!cols.some(c => c.name === 'last_synced_at')) {
+      this._db.exec('ALTER TABLE projects ADD COLUMN last_synced_at TEXT');
+    }
+  }
+
+  getUserId() {
+    return 'local';
+  }
+
+  listProjects() {
+    return this._db.prepare('SELECT id, title, content FROM projects').all();
+  }
+
+  getProject(projectId) {
+    return this._db
+      .prepare('SELECT id, title, content FROM projects WHERE id = ?')
+      .get(projectId) ?? null;
+  }
+
+  saveProject(projectId, title, content, updatedAt) {
+    this._db
+      .prepare('UPDATE projects SET title = ?, content = ?, updated_at = ? WHERE id = ?')
+      .run(title, content, updatedAt, projectId);
+  }
+
+  insertProject(title, content) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    this._db
+      .prepare('INSERT INTO projects (id, user_id, title, content, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)')
+      .run(id, 'local', title, content, now, now);
+    return { id };
+  }
+
+  deleteProject(projectId) {
+    this._db.prepare('DELETE FROM projects WHERE id = ?').run(projectId);
+  }
+
+  renameProject(projectId, newTitle, updatedAt) {
+    this._db
+      .prepare('UPDATE projects SET title = ?, updated_at = ? WHERE id = ?')
+      .run(newTitle, updatedAt, projectId);
+  }
+
+  getProjectsSyncStatus() {
+    return this._db
+      .prepare('SELECT id, title, content, created_at, updated_at, last_synced_at FROM projects')
+      .all();
+  }
+
+  markSynced(projectId, syncedAt) {
+    this._db
+      .prepare('UPDATE projects SET last_synced_at = ? WHERE id = ?')
+      .run(syncedAt, projectId);
+  }
+}

package/adapters/SupabaseAdapter.js

@@ -0,0 +1,76 @@
+// mcp-server/adapters/SupabaseAdapter.js
+
+export class SupabaseAdapter {
+  constructor(supabase, userId) {
+    this._supabase = supabase;
+    this._userId = userId;
+  }
+
+  getUserId() {
+    return this._userId;
+  }
+
+  async listProjects() {
+    const { data, error } = await this._supabase
+      .from('roadmap')
+      .select('id, title, content')
+      .eq('user_id', this._userId);
+    if (error) throw new Error(`Failed to fetch projects: ${error.message}`);
+    return data || [];
+  }
+
+  async getProject(projectId) {
+    const { data, error } = await this._supabase
+      .from('roadmap')
+      .select('id, title, content')
+      .eq('user_id', this._userId)
+      .eq('id', projectId)
+      .single();
+    if (error || !data) return null;
+    return data;
+  }
+
+  async saveProject(projectId, title, content, updatedAt) {
+    const { error } = await this._supabase
+      .from('roadmap')
+      .update({ title, content, updated_at: updatedAt })
+      .eq('user_id', this._userId)
+      .eq('id', projectId);
+    if (error) throw new Error(`Failed to save: ${error.message}`);
+  }
+
+  async insertProject(title, content) {
+    const now = new Date().toISOString();
+    const { data, error } = await this._supabase
+      .from('roadmap')
+      .insert({
+        user_id: this._userId,
+        title,
+        content,
+        created_at: now,
+        updated_at: now,
+      })
+      .select('id')
+      .single();
+    if (error || !data) throw new Error(`Failed to insert: ${error?.message ?? 'unknown'}`);
+    return { id: data.id };
+  }
+
+  async deleteProject(projectId) {
+    const { error } = await this._supabase
+      .from('roadmap')
+      .delete()
+      .eq('user_id', this._userId)
+      .eq('id', projectId);
+    if (error) throw new Error(`Failed to delete project: ${error.message}`);
+  }
+
+  async renameProject(projectId, newTitle, updatedAt) {
+    const { error } = await this._supabase
+      .from('roadmap')
+      .update({ title: newTitle, updated_at: updatedAt })
+      .eq('user_id', this._userId)
+      .eq('id', projectId);
+    if (error) throw new Error(`Failed to rename project: ${error.message}`);
+  }
+}

package/auth.js

@@ -0,0 +1,22 @@
+// mcp-server/auth.js
+
+/**
+ * Validates a Personal Access Token against the mcp_tokens table.
+ * @param {object} supabase - Supabase client
+ * @param {string} token - The MCP_TOKEN value from env
+ * @returns {Promise<string>} userId
+ * @throws if token not found
+ */
+export async function validatePat(supabase, token) {
+  const { data, error } = await supabase
+    .from('mcp_tokens')
+    .select('user_id')
+    .eq('token', token)
+    .single();
+
+  if (error || !data) {
+    throw new Error('Invalid MCP_TOKEN. Generate a new one in Project Planner Settings.');
+  }
+
+  return data.user_id;
+}

package/bin/init.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// mcp-server/bin/init.js
+//
+// ProPlan MCP init — writes .mcp.json for Claude Code (and compatible editors)
+// so developers don't have to hand-edit JSON.
+//
+// Usage:  node bin/init.js
+// No dependencies beyond Node built-ins.
+
+// ─── Node version guard ───────────────────────────────────────────────────────
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 18) {
+  process.stderr.write(
+    `\n  ProPlan init requires Node.js 18 or later.\n` +
+    `  You are running Node ${process.versions.node}.\n` +
+    `  Please upgrade: https://nodejs.org\n\n`
+  );
+  process.exit(1);
+}
+
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const RESET  = '\x1b[0m';
+const BOLD   = '\x1b[1m';
+const GREEN  = '\x1b[32m';
+const CYAN   = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const DIM    = '\x1b[2m';
+
+function print(msg = '') { process.stdout.write(msg + '\n'); }
+function bold(s)  { return BOLD + s + RESET; }
+function green(s) { return GREEN + s + RESET; }
+function cyan(s)  { return CYAN + s + RESET; }
+function dim(s)   { return DIM + s + RESET; }
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function readMcpJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+
+function writeMcpJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+function buildEntry(mode, mcpToken) {
+  const entry = {
+    command: 'npx',
+    args: ['-y', '@proplandev/mcp'],
+  };
+  if (mode === 'cloud' && mcpToken) {
+    entry.env = { MCP_TOKEN: mcpToken };
+  }
+  return entry;
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+print();
+print(bold('  ProPlan MCP — Setup'));
+print(dim('  Configures .mcp.json so Claude Code can find the server'));
+print();
+
+// 1. Mode
+print(cyan('  Storage mode'));
+print('  1. Local  — SQLite file in your project (.project-planner/db.sqlite)');
+print('  2. Cloud  — Supabase + MCP token (required for web dashboard sync)');
+print();
+const modeChoice = (await ask('  Your choice [1/2, default 1]: ')).trim() || '1';
+const mode = modeChoice === '2' ? 'cloud' : 'local';
+print();
+
+let mcpToken = '';
+if (mode === 'cloud') {
+  print(cyan('  Cloud credentials'));
+  print(dim('  Generate your token at: https://project-planner-7zw4.onrender.com/settings'));
+  print();
+  mcpToken = (await ask('  MCP_TOKEN: ')).trim();
+  if (!mcpToken) {
+    print();
+    print('  ' + YELLOW + '⚠  No token entered — switching to local mode.' + RESET);
+  }
+  print();
+}
+
+// 2. Location
+print(cyan('  Where to write .mcp.json'));
+const projectLocal = path.join(process.cwd(), '.mcp.json');
+const userLevel    = path.join(os.homedir(), '.mcp.json');
+print(`  1. Project-local  ${dim(projectLocal)}`);
+print(`  2. User-level     ${dim(userLevel)}  ${dim('(applies to all your projects)')}`);
+print();
+const locChoice = (await ask('  Your choice [1/2, default 1]: ')).trim() || '1';
+const mcpPath = locChoice === '2' ? userLevel : projectLocal;
+print();
+
+// 3. Write
+const existing = readMcpJson(mcpPath);
+existing.mcpServers = existing.mcpServers || {};
+
+const alreadyHas = existing.mcpServers['project-planner'];
+if (alreadyHas) {
+  const overwrite = (await ask(`  ${YELLOW}project-planner entry already exists. Overwrite? [y/N]: ${RESET}`)).trim().toLowerCase();
+  if (overwrite !== 'y') {
+    print();
+    print('  Aborted — existing entry preserved.');
+    rl.close();
+    process.exit(0);
+  }
+  print();
+}
+
+existing.mcpServers['project-planner'] = buildEntry(mode, mcpToken);
+writeMcpJson(mcpPath, existing);
+
+// 4. Success
+print(green('  ✓ .mcp.json written') + '  ' + dim(mcpPath));
+print();
+print(bold('  Next steps'));
+print(`  1. Restart Claude Code (or reload the MCP server)`);
+print(`  2. Open a project directory and start a new session`);
+print(`  3. Claude will call get_project_status automatically on session start`);
+print();
+
+if (mode === 'local') {
+  print(dim('  Local mode: data stored in .project-planner/db.sqlite'));
+  print(dim('  Run export_to_cloud later to push your projects to the dashboard.'));
+} else {
+  print(dim('  Cloud mode: projects sync automatically to your dashboard.'));
+  print(dim('  View them at https://project-planner-7zw4.onrender.com/dashboard'));
+}
+print();
+
+// 5. allowedTools tip
+print(bold('  Tip — skip approval prompts for read-only tools'));
+print(dim('  Add this to ~/.claude/settings.json:'));
+print();
+print(dim('  {'));
+print(dim('    "allowedTools": ['));
+print(dim('      "mcp__project-planner__get_project_status",'));
+print(dim('      "mcp__project-planner__get_next_tasks",'));
+print(dim('      "mcp__project-planner__get_project_roadmap",'));
+print(dim('      "mcp__project-planner__get_tasks",'));
+print(dim('      "mcp__project-planner__add_session_summary",'));
+print(dim('      "mcp__project-planner__update_task_status",'));
+print(dim('      "mcp__project-planner__add_note_to_task"'));
+print(dim('    ]'));
+print(dim('  }'));
+print();
+
+rl.close();