FuseBase MCP Server

An enterprise-grade Model Context Protocol (MCP) server enabling autonomous AI coding agents and developers to programmatically manage FuseBase (formerly Nimbus Note) workspaces - collaborative Y.js documents, relational tables, ActivePieces automations, client portals, hosted web apps, and multi-agent swarm boards with 100% deep data validation.

Official Web Dashboard

Production Status & Interactive Architecture Dashboard: fusebase-mcp.thefusebase.app
Real-time engineering status, interactive searchable directory of all 175 MCP tools with schema parameters, 15 test suite validation metrics, system architecture, and milestone chronology.

Capabilities

• 175 tools across content, tasks, members, files, databases, org admin, portals, guides, vibe coding, automations, CLI lifecycle, AI assistants & agent threads, FuseBase Work (Firecrawl & n8n), direct Gate & Dashboards MCP tokens, billing, user preferences, multi-agent profiles, and swarm orchestration

• Direct Gate & Dashboards MCP Token Mode: Connect zero-browser directly to FuseBase Gate (https://gate-mcp.thefusebase.com/mcp) and Dashboards (https://dashboards-mcp.thefusebase.com/mcp) with auto-discovered tenant identity, scopes, and default workspace.

• Advanced Markdown Ingestion: Automatic parsing of GFM tables into interactive TableBlock objects, markdown images (![alt](url)), GitHub callouts (> [!NOTE], > [!WARNING], etc.), HTML underline/highlight, and <details><summary> toggles

• FuseBase Work, Firecrawl & n8n: Native tools to invoke any of 32 organization AI agents, crawl/parse web pages via hosted Firecrawl, and trigger n8n automation flows

• Two-tier system — 34 core tools load by default (complete CRUD suite); 141 extended tools on demand

• Token Economics & Markdown Conversion — retrieve page content as clean Markdown (get_page_content(format: "markdown")) for ~50% token reduction via built-in htmlToMarkdown converter

• Binary Payload Safety & Native Images — download_attachment renders images as native MCP image blocks and streams large files directly to local disk (data/downloads/)

• Safety Annotations ([DESTRUCTIVE]) — permanent deletion tools are explicitly tagged so AI clients and human supervisors can prompt for confirmation

• Native MCP Resources (8) — fusebase://status, fusebase://workspaces, fusebase://guides/index, fusebase://work/connectors, fusebase://workspaces/{workspaceId}/pages/{pageId}, fusebase://databases/{databaseId}, fusebase://portals/{portalId}/clients

• Native MCP Prompts (17) — pre-engineered workflow templates (create-sop, summarize-page, build-kanban-project, design-automation-workflow, build-hosted-app, build-event-bridge, orchestrate-multi-agent-swarm, launch-client-portal, workspace-activity-digest, audit-page-governance, build-relational-database, import-knowledge-base, configure-ai-persona, crm-seed-demo-data, portal-embedded-app, fullstack-app-architecture, token-waste-audit)

• Official FuseBase CLI & Hosted Apps — inspect CLI status (fusebase_cli_status), initialize products (fusebase_cli_init), list apps (fusebase_cli_list_apps), deploy Vite/React SPA apps to FuseBase Cloud (fusebase_cli_deploy), configure Docker sidecars (fusebase_cli_sidecar_add, fusebase_cli_sidecar_list, fusebase_cli_sidecar_remove), manage platform secrets (fusebase_cli_secret_create, fusebase_cli_secret_list), inspect remote logs (fusebase_cli_logs), and update app view permissions (fusebase_cli_app_update)

• Granular block mutations — non-destructive page block appending (append_page_content) via real-time Y.js WebSockets

• Vibe Coding & Web Apps — generate interactive web app pages (create_interactive_app_page) with responsive full-width embeds (allowOverWidth)

• ActivePieces Workflow Automation — flow inspection, creation, updating, deletion, trigger test runs (trigger_automation_flow), and connector piece catalog with auto-managed JWT authentication

• Client Portal "Hub" Platform — inspect availability (check_portal_availability), create portals (create_portal), retrieve full branding/settings (get_portal), inspect themes (get_portal_theme), portal sidebar navigation trees (get_portal_navigation_menu), resolve workspace portals (get_workspace_portal), publish workspace pages to client portals (publish_page_to_portal), manage client permissions (list_portal_clients, invite_portal_client), and generate 24h passwordless magic links (create_portal_magic_link)

• Multi-Agent Swarm Orchestrator — initialize shared state machine boards (fusebase_swarm_init) and transition tasks across roles with audit history (fusebase_swarm_task_transition)

• Multi-Agent Profile Management — list and switch between encrypted credentials seamlessly (list_agent_profiles, switch_active_profile)

• Database CRUD & View Templates — full kanban/table management: rows, columns, views, relations, managed templates (get_dashboard_templates), CSV import/export

• Auto auth retry — detects 401/403 and refreshes session automatically

• Encrypted secrets — cookies stored encrypted at rest (AES-256-GCM)

• Version checking — built-in update detection from GitHub

• Live Cloud Status Dashboard — real-time engineering and validation status dashboard hosted directly on FuseBase Cloud at fusebase-mcp.thefusebase.app

• API logging — all requests logged for debugging

Related MCP server: Finizi B4B MCP Server

🚀 Quick Start

Prerequisites

• Node.js 18+

• A Fusebase account

1. Install

Option A — Install from GitHub (recommended):

npm install -g github:ryan-haver/fusebase-mcp

This automatically installs dependencies, compiles TypeScript, and downloads Chromium for auth.

Option B — Clone and build manually:

git clone https://github.com/ryan-haver/fusebase-mcp.git
cd fusebase-mcp
npm install

npm install automatically builds the project and installs Playwright's Chromium via the prepare and postinstall scripts.

2. Configure & Authenticate

FuseBase MCP provides three production authentication modes:

┌──────────────────────────────────────────────────────────────────────────────────┐
│                             Authentication Modes                                 │
├───────────────────────┬──────────────────────────┬───────────────────────────────┤
│ Mode 1: Pure Token    │ Mode 2: Session Cookie   │ Mode 3: Hybrid (Recommended)  │
│ (Zero-Browser / Gate) │ (Interactive / Headless) │ (Full-Spectrum Dual Engine)   │
├───────────────────────┼──────────────────────────┼───────────────────────────────┤
│ • Official Gate MCP   │ • Browser session cookie │ • Both Token & Cookie loaded  │
│ • Official Dashboards │ • Interactive Chromium   │ • Pure Token for Gate/DB ops  │
│ • No browser needed   │ • Y.js collaborative WS  │ • Cookie for real-time Y.js   │
│ • Auto whoami config  │ • ActivePieces automations│• 100% full platform coverage │
└───────────────────────┴──────────────────────────┴───────────────────────────────┘

Mode 1: Pure Token Mode (Direct Remote MCP Gateways — Zero-Browser)

Connect directly via official FuseBase Gate & Dashboards MCP gateways as specified in the official guides:

• Connect AI Agents to Fusebase Dashboards with MCP

• Connect external AI Agents to Fusebase with MCP

Copy .env.example to .env:

cp .env.example .env

# Direct Token Authentication (No cookies or browser needed)
FUSEBASE_GATE_TOKEN=your_gate_mcp_token
FUSEBASE_DASHBOARDS_TOKEN=your_dashboards_mcp_token
# or unified platform token:
# FUSEBASE_TOKEN=your_api_token

Zero Configuration: When tokens are provided, the server automatically connects to upstream Gate (https://gate-mcp.thefusebase.com/mcp) and Dashboards (https://dashboards-mcp.thefusebase.com/mcp), auto-discovering your tenant organization ID (orgId), custom domain (FUSEBASE_HOST), and default workspace via upstream whoami.

You can also save tokens securely encrypted at rest (AES-256-GCM):

npx tsx scripts/auth.ts --token <your_token>
# or for named multi-agent profiles:
npx tsx scripts/auth.ts --profile agent-architect --token <token>

Mode 2: Browser Session Cookie Mode (Interactive / Headless)

For direct Y.js CRDT WebSocket live synchronization and internal ActivePieces engine integration:

npx tsx scripts/auth.ts

This opens a browser window → log into Fusebase → cookies are automatically captured and saved encrypted (AES-256-GCM) to data/cookie.enc.

Headless mode: After initial login, you can re-authenticate without a browser window:

npx tsx scripts/auth.ts --headless

Multi-Agent Profiles: Authenticate a specific named profile:

npx tsx scripts/auth.ts --profile agent-architect

Mode 3: Hybrid Mode (Recommended for Full-Spectrum Agents)

Supply both tokens (FUSEBASE_GATE_TOKEN, FUSEBASE_DASHBOARDS_TOKEN) and a session cookie (FUSEBASE_COOKIE or data/cookie.enc). The server intelligently routes:

• Gate & Dashboards MCP: Uses high-speed Bearer tokens for tenant discovery, isolated PostgreSQL stores, databases, and token management.

• Notes Engine Fallback: Automatically serves note/page/folder CRUD via Gate when session cookie is absent, and leverages real-time Y.js CRDT WebSocket sync when cookies are present.

• Automation Engine: Exchanges session cookie for ActivePieces project JWTs while allowing external webhook triggers via FuseBase Work.

3. Authentication Modes Feature Parity & Empirical Comparison

The table below reflects 100% empirical validation results obtained by running npm run test:parity (scripts/test-token-parity.ts) against live FuseBase production infrastructure:

Architectural Notes on Cookie-Dependent Services

1. Real-time Y.js CRDT Collaborative WebSocket Sync (wss://text.nimbusweb.me):
   The real-time collaborative editing service uses Y.js binary sync protocols over WebSockets. The WebSocket handshake endpoint validates the eversessionid cookie header during HTTP upgrade and rejects unauthenticated or bearer-token-only connections with HTTP 401. In Pure Token Mode, the client automatically routes page content reads and appends through Gate MCP (getWorkspaceNote and appendWorkspaceNoteContent), allowing complete page manipulation without opening a WebSocket connection.

2. Internal ActivePieces Workflow Engine (/automation/api/v1/...):
   FuseBase's embedded ActivePieces automation platform relies on an authentication bridge (/automation/api/v1/authentication/fusebase-auth) that requires an active eversessionid cookie to mint a temporary project JWT and resolve the tenant's automation projectId. In Pure Token Mode, external automations can be triggered via FuseBase Work connectors (fusebase_work_trigger_n8n or webhook endpoints) without invoking the internal ActivePieces session bridge.

3. Legacy Web Editor Multi-Part File Uploads (/v3/api/web-editor/file/v2-upload):
   The legacy web editor attachment route specifically checks for browser session cookies in multi-part form submissions. File downloads, asset links, and URL-based attachments operate without restrictions across all modes, while raw binary uploads through the legacy editor form route require a session cookie.

4. Web UI State & Session Preferences:
   Preferences like set_sidebar_collapsed and last-opened workspace lists exist only in the web client's session state variables (/v2/api/users/vars/...). Because headless AI agents interact programmatically via MCP tools rather than a visual UI layout, this restriction does not affect automation workflows.

Operational Recommendation: Which Mode Should You Use?

• Use Pure Token Mode (FUSEBASE_GATE_TOKEN + FUSEBASE_DASHBOARDS_TOKEN):
  Best for CI/CD pipelines, autonomous Docker containers, headless cloud workers, and multi-tenant AI agents where browser login is impossible or undesirable. Provides 100% of workspace, page CRUD, folder, database, and isolated store capabilities with zero maintenance.

• Use Hybrid Mode (Tokens + Cached Cookie):
  Best for local developer environments, rich interactive pair programming, and full-spectrum swarm orchestration where live Y.js WebSocket document collaboration and ActivePieces workflow creation are utilized alongside Gate MCP's PostgreSQL stores.

4. Connect to Your AI Assistant (Claude, Cursor, Antigravity, Codex, OpenCode)

Single-System Credential Architecture

FuseBase MCP is built for multi-agent environments sharing a single machine. Once you configure credentials on your machine (via .env, npx tsx scripts/auth.ts --token <token>, or browser login):

1. Zero-Config Agent Discovery: Any coding agent installed on the same system running node c:/scripts/fusebase-mcp/dist/index.js automatically reads the local encrypted credentials and connects immediately without needing tokens or cookies hardcoded in the agent's JSON config.

2. Multi-Agent Profile Isolation: When running multi-agent swarms (e.g. PM, Architect, Developer, QA), each agent can use its own distinct encrypted identity simply by setting "FUSEBASE_PROFILE": "agent-architect".

3. Explicit Token Pass-Through: For remote runners or Docker containers, you can pass FUSEBASE_GATE_TOKEN and FUSEBASE_DASHBOARDS_TOKEN directly in the agent's env block.

Client Configuration Templates

Claude Desktop (%APPDATA%\Claude\claude_desktop_config.json on Windows or ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "fusebase": {
      "command": "node",
      "args": ["c:/scripts/fusebase-mcp/dist/index.js"],
      "env": {
        "FUSEBASE_TOOLS": "all"
      }
    }
  }
}

Claude Code CLI:

# Add as a local plugin using native .claude-plugin/plugin.json
claude plugin add c:/scripts/fusebase-mcp

Or run directly via stdio:

claude mcp add fusebase -- node c:/scripts/fusebase-mcp/dist/index.js

In your workspace root, create or edit .cursor/mcp.json (or add via Cursor Settings > Features > MCP):

{
  "mcpServers": {
    "fusebase": {
      "command": "node",
      "args": ["c:/scripts/fusebase-mcp/dist/index.js"],
      "env": {
        "FUSEBASE_TOOLS": "all"
      }
    }
  }
}

Add to your global Antigravity MCP configuration (~/.gemini/antigravity-ide/mcp_config.json) or workspace .agent/mcp_config.json:

{
  "mcpServers": {
    "fusebase": {
      "command": "node",
      "args": ["c:/scripts/fusebase-mcp/dist/index.js"],
      "env": {
        "FUSEBASE_TOOLS": "all"
      }
    }
  }
}

This repository includes native .codex-plugin/plugin.json for OpenAI Codex agent ecosystems.

Add via Codex CLI:

codex mcp add fusebase --command node --args c:/scripts/fusebase-mcp/dist/index.js

Or in your Codex configuration:

{
  "mcp": {
    "fusebase": {
      "command": "node",
      "args": ["c:/scripts/fusebase-mcp/dist/index.js"],
      "env": {
        "FUSEBASE_TOOLS": "all"
      }
    }
  }
}

OpenCode supports both local stdio execution and direct upstream HTTP Gate connection. Place opencode.json in your project root:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "fusebase": {
      "type": "stdio",
      "command": "node",
      "args": ["c:/scripts/fusebase-mcp/dist/index.js"],
      "env": {
        "FUSEBASE_TOOLS": "all"
      }
    }
  }
}

{
  "mcp": {
    "servers": {
      "fusebase": {
        "command": "node",
        "args": ["c:/scripts/fusebase-mcp/dist/index.js"],
        "env": {
          "FUSEBASE_TOOLS": "all"
        }
      }
    }
  }
}

Note: On Windows, paths can use forward slashes ("c:/scripts/fusebase-mcp/dist/index.js") or escaped backslashes ("C:\\scripts\\fusebase-mcp\\dist\\index.js"). If credentials are saved in .env or data/tokens.enc, no auth environment variables are required in the client JSON!

5. Verify

Ask your AI assistant:

"List my Fusebase workspaces"

If it works, you're all set! 🎉

You can also run automated verification directly from your terminal:

npm run test:all              # Master 7-stage unified verification pipeline (100% full platform test)
npm run test:database         # 13-Phase end-to-end database & relational validation suite (95 assertions)
npm run test:flow             # ActivePieces workflow automations & FuseBase CLI suite (36 assertions)
npm run test:data-validation  # Full deep data validation across all 165 tools & endpoints (171 assertions)
npm run test:audit            # Validate all 165 tool schemas, parameters, and documentation
npm test                      # Run full 15-stage platform end-to-end test suite
npm run deploy:status         # Build & deploy live status dashboard to fusebase-mcp.thefusebase.app
npm run deploy:page           # Embed the live status dashboard into a FuseBase workspace note

Target Workspace Selection & Isolation

By default, test suites and workspace deployments prioritize dedicated project workspaces (e.g. named "Agent Projects" or "FuseBase MCP") to isolate test runs and prevent polluting personal or client workspaces.

You can explicitly target any workspace in your FuseBase organization:

• CLI flag:

  npm run test:data-validation -- --workspace="Agent Projects"
  npm run deploy:page -- --workspace="Agent Projects"

• Environment variable: Set FUSEBASE_WORKSPACE_ID in your .env:

  FUSEBASE_WORKSPACE_ID=49b306wxd9oa7hyc

• Automatic Fallback:

  1. CLI --workspace=<id|name>

  2. .env FUSEBASE_WORKSPACE_ID

  3. Auto-detected workspace with "mcp" or "agent" in title

  4. First available organization workspace

📚 Native MCP Resources & Prompts

FuseBase MCP supports first-class MCP protocol primitives for zero-overhead context injection:

Resources (fusebase://)

Clients can attach FuseBase data directly into their context window:

Pre-Engineered Prompts (17)

Quick-start workflow prompts available to AI clients:

• create-sop: Guides the assistant in generating a rigorous Standard Operating Procedure document with scope, prerequisites, step-by-step procedures, and verification checklists.

• summarize-page: Fetches living page content via getPageContent and synthesizes an executive summary, key decisions, prioritized action items, and open questions.

• build-kanban-project: Guides the AI to design a structured project board with customized column flows, custom field recommendations, and starter cards.

• design-automation-workflow: Prompts the design of an ActivePieces automation workflow mapping triggers, action steps, retry policies, and error handling.

• build-hosted-app: Architects a full-stack FuseBase Web App covering frontend UI tokens, backend data, CLI commands, and responsive embedding.

• build-event-bridge: Designs bidirectional webhook bridges connecting external systems (Stripe, GitHub, n8n) into FuseBase and triggering workflows via trigger_automation_flow.

• orchestrate-multi-agent-swarm: Decomposes complex initiatives into coordinated multi-agent swarms tracked through FuseBase Kanban boards (fusebase_swarm_init, fusebase_swarm_task_transition).

• launch-client-portal: Plans and provisions an external branded Client Portal with custom theme, sidebar navigation hierarchy, page publication matrix, and passwordless magic link invitations (invite_portal_client, create_portal_magic_link).

• workspace-activity-digest: Ingests recent workspace activity, updated pages, and task completion metrics to produce an executive velocity pulse and blocker digest.

• audit-page-governance: Fetches page content and audits heading hierarchy (H1-H3), incomplete action items (- [ ]), stale dates, and tags, providing a concrete revision plan.

• build-relational-database: Architects a multi-table relational schema with bidirectional relations (add_relation_column), lookup rollups (add_lookup_column), and specialized Kanban/Grid views.

• import-knowledge-base: Plans structured migrations of Notion workspaces, Confluence spaces, or CSV datasets into FuseBase folders, markdown pages, and databases.

• configure-ai-persona: Designs specialized AI assistant personas with tailored charters, quick-action suggestion chips, and starter conversation threads.

• crm-seed-demo-data: Generates high-fidelity CRM demo records (Companies, Contacts, Deals table/pipeline, Trackers) with relational integrity across parent and child tables.

• portal-embedded-app: Guides scaffolding and deployment of FuseBase client portal embedded applications using dynamic {{CurrentPortal}} view filtering and runtime context authentication.

• fullstack-app-architecture: Architects enterprise full-stack FuseBase Web Applications with Docker sidecar microservices, secret whitelisting, and unified localhost routing.

• token-waste-audit: Audits active agent interactions and tool invocations to identify redundant schema fetching, enforce compact Markdown formats, and recover context bandwidth.

🔧 Tool Tiers

The server uses a core/extended tier system to optimize agent context usage:

Enable extended tools:

• Mid-session: ask your AI to use set_tool_tier with tier: "all"

• Always-on: add FUSEBASE_TOOLS=all to your .env

Core Tools (34)

Core tools load by default and provide complete CRUD and organization operations for day-to-day workspace workflows without requiring extended tier switching:

Extended Tools (134)

Enable with set_tool_tier(tier: "all") or set FUSEBASE_TOOLS=all in .env:

• FuseBase Work (Firecrawl & n8n): fusebase_work_run_agent, fusebase_work_scrape_url, fusebase_work_trigger_n8n

• Client Portal Hub: check_portal_availability, create_portal, get_portal, get_portal_theme, get_portal_navigation_menu, get_workspace_portal, publish_page_to_portal, list_portal_clients, invite_portal_client, create_portal_magic_link, list_portals, get_portal_pages

• Multi-Agent Swarms: fusebase_swarm_init, fusebase_swarm_task_transition

• FuseBase CLI & Hosted Apps: fusebase_cli_status, fusebase_cli_init, fusebase_cli_list_apps, fusebase_cli_deploy, fusebase_cli_sidecar_add, fusebase_cli_sidecar_list, fusebase_cli_sidecar_remove, fusebase_cli_secret_create, fusebase_cli_secret_list, fusebase_cli_logs, fusebase_cli_app_update, create_interactive_app_page

• ActivePieces Workflow Automations: list_automation_flows, get_automation_flow, create_automation_flow, update_automation_flow, delete_automation_flow, trigger_automation_flow, list_flow_runs, list_automation_pieces, get_automation_flags, list_automation_folders, create_automation_folder, delete_automation_folder, get_automation_user

• Tasks (Metrics & Logs): get_tasks_workspace_summary, get_task_time_tracking, get_task_description, get_task_count, get_task_usage

• Labels & Tags: get_labels, get_note_tags

• Comments & Activity Stream: get_activity_stream, get_comment_threads, fusebase_poll_mentions, fusebase_post_comment, fusebase_reply_comment, fusebase_resolve_thread

• Files & Storage: get_file_count

• Organization Administration: get_member_roles, get_workspace_members_v1, get_org_trials, get_org_usage, get_org_limits, get_usage_summary, get_org_permissions, get_org_features, get_ai_usage

• Workspaces & Subscription: get_workspace_premium_status, get_active_import_status, get_workspace_detail, get_workspace_emails, get_workspace_info

• Navigation & AI Assistant: get_agent_public_profile, get_ai_assistant_state, list_ai_agent_threads, get_ai_agent_favorites, get_navigation_menu, get_mention_entities, list_agents, list_ai_agent_categories, get_recently_updated_notes

• Databases & Tables: get_dashboard_templates, get_database_entity_templates, get_database_data, list_databases, get_database_entity, create_database, add_database_row, delete_database_row, move_kanban_card, list_database_relations, create_dashboard_table, delete_relation, list_all_databases, get_database_detail, update_database, delete_database, get_dashboard_detail, delete_dashboard, batch_put_database_data, resolve_database_alias

• Views: update_view, set_view_representation, create_view, delete_view, duplicate_view, set_view_grouping

• Columns: add_database_column, delete_database_column, rename_database_column, reorder_database_columns, set_column_width, add_relation_column, add_lookup_column

• Cells & Rows: update_database_cell, get_database_rows, get_database_schema, reorder_database_rows

• Direct Gate & Dashboards Tokens: fusebase_token_list, fusebase_token_create, fusebase_token_get, fusebase_token_revoke, fusebase_token_permission_catalog, fusebase_gate_whoami, fusebase_direct_tool_call

• Row-Level Relations: link_database_rows, unlink_database_rows, get_relation_rows

• Gate PostgreSQL Isolated SQL Stores: list_isolated_stores, create_isolated_store, query_isolated_sql, execute_isolated_sql, select_isolated_sql_rows, insert_isolated_sql_row, batch_insert_isolated_sql_rows, list_isolated_sql_tables, apply_isolated_sql_migrations

• Billing & User Preferences: get_billing_info, get_user_preferences, set_sidebar_collapsed

• Import/Export: duplicate_database, export_csv, import_csv

🔐 Security

• No plaintext secrets on disk — cookies are encrypted with AES-256-GCM using a machine-scoped key

• Auto-refresh — expired sessions are transparently refreshed via Playwright

• .env is gitignored — credentials never enter version control

• Cookie via env var — optionally pass FUSEBASE_COOKIE in your MCP config for environments where the encrypted store isn't available

🗂️ Project Structure

src/
  index.ts              → MCP server (175 tools, stdio transport, tier system, instructions)
  client.ts             → HTTP client (cookie auth, ActivePieces token exchange, 401 auto-retry, logging)
  gate-bridge.ts        → Streamable HTTP MCP client for official Gate & Dashboards endpoints
  crypto.ts             → AES-256-GCM encryption for multi-profile secrets and API tokens at rest
  types.ts              → TypeScript interfaces for API responses
  resources.ts          → Native MCP resources & RFC 6570 templates
  prompts.ts            → Native MCP pre-engineered workflow prompts
  proxy-relay.ts        → HTTP CONNECT proxy relay for SOCKS5 upstream proxies
  guide-loader.ts       → Guide search index (278 guides, 19 sections)
  tools/
    core-tools.ts       → 34 Core tools (full CRUD and organization for pages, tasks, folders, content, profiles)
    extended-tools.ts   → 141 Extended tools (databases, views, relations, batch mutations, SQL stores, automations, portals, admin, CLI, Gate tokens, FuseBase Work)
    helpers.ts          → HTML-to-markdown converter, MIME detection, error formatting
  yjs-ws-writer.ts      → Y.js WebSocket writer (write + read via WS sync)
  yjs-html-decoder.ts   → Y.js document → HTML decoder (20+ block types)
  content-schema.ts     → Content block IR (25+ block types)
  markdown-parser.ts    → Markdown → ContentBlock[] converter
scripts/
  test-all.ts           → Master 7-stage unified verification runner (`npm run test:all`)
  test-database-e2e.ts  → Dedicated 13-phase e2e database & relational validation suite (`npm run test:database`)
  test-cli-and-flow.ts  → ActivePieces workflow automations & FuseBase CLI test suite (`npm run test:flow`)
  test-data-validation.ts → Deep data validation across all 165 tools (`npm run test:data-validation`)
  test-mcp-e2e.ts       → Full 15-stage platform integration test suite (`npm test`)
  test-regression.ts    → Y.js block type and format regression test (`npm run test:regression`)
  audit-tools.ts        → Tool schema and parameter completeness validator (`npm run test:audit`)
  auth.ts               → Capture/refresh session cookies via Playwright (multi-profile)
  inspect-hub.ts        → Deep inspection of client portal and workspace hubs
  deploy-status-dashboard.ts → Build & deploy live status dashboard SPA (`npm run deploy:status`)
  deploy-workspace-page.ts   → Embed status dashboard into workspace note (`npm run deploy:page`)
docs/
  guides/               → 278 FuseBase guides across 19 sections (auto-scraped)
data/                   → (gitignored) Cookie store, downloads, API logs, workspace cache

🗺️ Roadmap & Implemented Milestones

See ENDPOINT_REFERENCE.md for all discovered and implemented API endpoints.

Completed Milestones

• Core Tier CRUD Completeness — 34 core tools providing full CRUD for pages, folders, content, tasks, and files.

• ActivePieces Workflow Automation — Flow creation, updates, triggers, piece catalog, and JWT exchange.

• Client Portal Hub Lifecycle — Portal creation, domain lookup, theme inspection, client permissions, and magic links.

• Multi-Agent Swarm Orchestration — Collaborative Kanban state machines with role transitions.

• Native AI Assistant & Agent Threads — AI suggestions, threads, and user preferences.

• Token Economics & Binary Safety — HTML-to-Markdown conversion and native image / local disk file staging.

• RFC 6570 Resource Templates & Prompts — Direct URI data mounting and pre-engineered workflows.

• Full-Spectrum 165-Tool Deep Data Validation — 100% live verification with field, type, and lifecycle assertions.

Future Opportunities

• Bidirectional Webhook Listeners — Local webhook listener bridge for real-time external event triggers into FuseBase.

• Offline Working Memory — Local SQLite caching adapter for instant retrieval of high-frequency pages and database schemas.

🧪 Testing & Validation

The server includes automated test suites to ensure zero regressions across tool schemas, parameter types, protocol compliance, and live API synchronization:

# 1. Master 7-Stage Unified Verification Pipeline (Recommended before every push)
npm run test:all

# 2. Dedicated 13-Phase E2E Database Subsystem Test Suite (Dynamic creation, schema, cells, Kanban, cloning, cleanup)
npm run test:database

# 3. ActivePieces Workflow Automations & Hosted Vibe Apps CLI Suite
npm run test:flow

# 4. Full-Spectrum 165-Tool Deep Data Validation Suite (13 suites, 100% data assertions)
npm run test:data-validation

# 5. Full Live Platform End-to-End Suite (15 stages against live API)
npm test

# 6. Tool Schema, Duplicate, & Documentation Coverage Auditor
npm run test:audit

# 7. Y.js Block Schema & Inline Format Regression Suite
npm run test:regression

# 8. Live Status Dashboard Build & Deployment Pipeline (Deploy prior to commit & push)
npm run deploy:status

Pre-Commit & Push Workflow Checklist

Before any commit and push to git:

1. Master Pipeline: npm run test:all (runs all 7 stages: type audit, schema audit, flows, Y.js blocks, MCP protocol, database lifecycle, and deep data validation).

2. Audit & Lint: npm run test:audit (guarantees schema descriptions and 100% README documentation coverage).

3. Deploy Status Dashboard: npm run deploy:status (deploys latest project state & git hash to https://fusebase-mcp.thefusebase.app/).

4. Commit & Push: Commit clean changes and push to origin/master.

🤝 Contributing

1. Fork the repo

2. Create a feature branch

3. Run npm run build to verify TypeScript compiles

4. Submit a PR

📄 License

MIT