@rebasepro/mcp-server 0.0.1-canary.0

package/src/api-client.ts

@@ -0,0 +1,146 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
+import { getValidTokens } from "./auth.js";
+
+const API_URL = "https://api.rebase.pro";
+
+/**
+ * Typed HTTP client for the Rebase Cloud backend REST API.
+ * Uses the same tokens as the Rebase CLI (from ~/.rebase/tokens.json).
+ */
+export class RebaseApiClient {
+    private client: AxiosInstance;
+
+    constructor() {
+        this.client = axios.create({
+            baseURL: API_URL,
+            timeout: 60_000,
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+
+    private async authHeaders(): Promise<Record<string, string>> {
+        const tokens = await getValidTokens();
+        if (!tokens) {
+            throw new Error("Not logged in. Use the rebase_login tool first.");
+        }
+        return {
+            Authorization: `Bearer ${tokens.id_token}`,
+            "x-admin-authorization": `Bearer ${tokens.access_token}`,
+        };
+    }
+
+    private async request<T>(config: AxiosRequestConfig): Promise<T> {
+        const headers = await this.authHeaders();
+        const response = await this.client.request<T>({
+            ...config,
+            headers: { ...config.headers, ...headers },
+        });
+        return response.data;
+    }
+
+    // ─── Projects ──────────────────────────────────────────
+
+    async listProjects(): Promise<any> {
+        return this.request({ method: "GET", url: "/projects" });
+    }
+
+    async getRootCollections(projectId: string): Promise<any> {
+        return this.request({
+            method: "GET",
+            url: `/projects/${projectId}/firestore_root_collections`,
+        });
+    }
+
+    // ─── Users ─────────────────────────────────────────────
+
+    async listUsers(projectId: string): Promise<any> {
+        return this.request({ method: "GET", url: `/projects/${projectId}/users` });
+    }
+
+    async createUser(projectId: string, email: string, roles: string[]): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/users`,
+            data: { email, roles },
+        });
+    }
+
+    async updateUser(projectId: string, userId: string, roles: string[]): Promise<any> {
+        return this.request({
+            method: "PATCH",
+            url: `/projects/${projectId}/users/${userId}`,
+            data: { roles },
+        });
+    }
+
+    async deleteUser(projectId: string, userId: string): Promise<any> {
+        return this.request({ method: "DELETE", url: `/projects/${projectId}/users/${userId}` });
+    }
+
+    // ─── Collections ───────────────────────────────────────
+
+    async generateCollection(prompt: string, existingCollections: any[] = [], existingCollection?: any): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: "/collections/generate",
+            data: { prompt, existingCollections, existingCollection },
+        });
+    }
+
+    // ─── Documents (Firestore CRUD via backend) ─────────────
+
+    async listDocuments(projectId: string, body: {
+        path: string;
+        limit?: number;
+        orderBy?: string;
+        orderDirection?: string;
+        filters?: Array<{ field: string; op: string; value: any }>;
+        databaseId?: string;
+    }): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/documents/list`,
+            data: body,
+        });
+    }
+
+    async getDocument(projectId: string, path: string, documentId: string, databaseId?: string): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/documents/get`,
+            data: { path, documentId, databaseId },
+        });
+    }
+
+    async createDocument(projectId: string, path: string, data: Record<string, any>, documentId?: string, databaseId?: string): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/documents/create`,
+            data: { path, data, documentId, databaseId },
+        });
+    }
+
+    async updateDocument(projectId: string, path: string, documentId: string, data: Record<string, any>, databaseId?: string): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/documents/update`,
+            data: { path, documentId, data, databaseId },
+        });
+    }
+
+    async deleteDocument(projectId: string, path: string, documentId: string, databaseId?: string): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/documents/delete`,
+            data: { path, documentId, databaseId },
+        });
+    }
+
+    async countDocuments(projectId: string, path: string, databaseId?: string): Promise<any> {
+        return this.request({
+            method: "POST",
+            url: `/projects/${projectId}/documents/count`,
+            data: { path, databaseId },
+        });
+    }
+}

package/src/auth.ts

@@ -0,0 +1,75 @@
+/**
+ * Authentication module for the Rebase MCP server.
+ *
+ * Delegates to the CLI package (@rebasepro/cli) — same OAuth flow,
+ * same token storage at ~/.rebase/tokens.json.
+ */
+import {
+    login,
+    logout,
+    getTokens,
+    refreshCredentials,
+    parseJwt,
+} from "@rebasepro/cli";
+
+const ENV = "prod" as const;
+const DEBUG = false;
+
+export interface StoredTokens {
+    access_token: string;
+    refresh_token: string;
+    id_token: string;
+    expiry_date: number;
+    scope: string;
+    token_type: string;
+    env?: string;
+}
+
+// ─── Token access ──────────────────────────────────────────
+
+export async function getStoredTokens(): Promise<StoredTokens | null> {
+    const tokens = await getTokens(ENV, DEBUG);
+    return tokens as StoredTokens | null;
+}
+
+export async function getValidTokens(): Promise<StoredTokens | null> {
+    const tokens = await getStoredTokens();
+    if (!tokens) return null;
+
+    const refreshed = await refreshCredentials(ENV, tokens);
+    return refreshed as StoredTokens | null;
+}
+
+// ─── Convenience helpers ───────────────────────────────────
+
+export function getCurrentUserEmail(): string | null {
+    // getTokens is async, but for a quick sync check we read the file directly.
+    // The CLI stores tokens at ~/.rebase/tokens.json.
+    try {
+        const fs = require("fs");
+        const path = require("path");
+        const os = require("os");
+        const filePath = path.join(os.homedir(), ".rebase", "tokens.json");
+        if (!fs.existsSync(filePath)) return null;
+        const tokens = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!tokens?.id_token) return null;
+        const payload = parseJwt(tokens.id_token);
+        return (payload as any)["email"] ?? null;
+    } catch {
+        return null;
+    }
+}
+
+export function isLoggedIn(): boolean {
+    return getCurrentUserEmail() !== null;
+}
+
+// ─── Login / Logout ────────────────────────────────────────
+
+export async function loginFlow(): Promise<void> {
+    await login(ENV, DEBUG);
+}
+
+export async function logoutFlow(): Promise<void> {
+    await logout(ENV, DEBUG);
+}

package/src/cli.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createRebaseMcpServer } from "./server.js";
+import { getCurrentUserEmail } from "./auth.js";
+
+/**
+ * Rebase MCP Server CLI
+ *
+ * Usage:
+ *   rebase-mcp
+ *
+ * Auth is handled interactively via the rebase_login tool (browser OAuth),
+ * same flow as `rebase login` in the CLI. Tokens are stored at ~/.rebase/tokens.json.
+ *
+ * Claude Desktop config (claude_desktop_config.json):
+ *   {
+ *     "mcpServers": {
+ *       "rebase": {
+ *         "command": "node",
+ *         "args": ["/path/to/packages/mcp_server/dist/cli.js"]
+ *       }
+ *     }
+ *   }
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Rebase MCP Server — Model Context Protocol server for Rebase Cloud
+
+Usage:
+  rebase-mcp
+
+No configuration needed. Authentication is handled interactively
+via the rebase_login tool, which opens a browser for Google OAuth.
+Tokens are stored at ~/.rebase/tokens.json (shared with the Rebase CLI).
+
+Claude Desktop config (claude_desktop_config.json):
+  {
+    "mcpServers": {
+      "rebase": {
+        "command": "npx",
+        "args": ["@rebasepro/mcp-server"]
+      }
+    }
+  }
+`);
+    process.exit(0);
+  }
+
+  const server = createRebaseMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // Log to stderr (stdout is reserved for MCP protocol)
+  const email = getCurrentUserEmail();
+  console.error("Rebase MCP server started");
+  if (email) {
+    console.error(`  Logged in as: ${email}`);
+  } else {
+    console.error("  Not logged in — use the rebase_login tool to sign in");
+  }
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createRebaseMcpServer } from "./server.js";
+export { RebaseApiClient } from "./api-client.js";

package/src/resources/project.ts

@@ -0,0 +1,68 @@
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { RebaseApiClient } from "../api-client.js";
+
+/**
+ * Register MCP resources — read-only contextual data about Rebase projects.
+ */
+export function registerProjectResources(server: McpServer, api: RebaseApiClient) {
+
+    server.registerResource(
+        "project-collections",
+        new ResourceTemplate("rebase://projects/{projectId}/collections", { list: undefined }),
+        {
+            description: "Firestore root-level collections for a Rebase project",
+            mimeType: "application/json",
+        },
+        async (uri, variables) => {
+            const projectId = variables.projectId as string;
+            try {
+                const collections = await api.getRootCollections(projectId);
+                return {
+                    contents: [{
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify(collections, null, 2),
+                    }],
+                };
+            } catch (error: any) {
+                return {
+                    contents: [{
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: error.message }),
+                    }],
+                };
+            }
+        }
+    );
+
+    server.registerResource(
+        "project-users",
+        new ResourceTemplate("rebase://projects/{projectId}/users", { list: undefined }),
+        {
+            description: "Users with access to a Rebase project",
+            mimeType: "application/json",
+        },
+        async (uri, variables) => {
+            const projectId = variables.projectId as string;
+            try {
+                const users = await api.listUsers(projectId);
+                return {
+                    contents: [{
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify(users, null, 2),
+                    }],
+                };
+            } catch (error: any) {
+                return {
+                    contents: [{
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: error.message }),
+                    }],
+                };
+            }
+        }
+    );
+}

package/src/server.ts

@@ -0,0 +1,42 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { RebaseApiClient } from "./api-client.js";
+import { registerAuthTools } from "./tools/auth.js";
+import { registerProjectTools } from "./tools/projects.js";
+import { registerUserTools } from "./tools/users.js";
+import { registerCollectionTools } from "./tools/collections.js";
+import { registerDocumentTools } from "./tools/documents.js";
+import { registerExportTools } from "./tools/export.js";
+import { registerProjectResources } from "./resources/project.js";
+
+/**
+ * Create and configure the Rebase MCP server with all tools and resources.
+ */
+export function createRebaseMcpServer(): McpServer {
+    const server = new McpServer({
+        name: "Rebase Cloud",
+        version: "0.1.0",
+    });
+
+    const api = new RebaseApiClient();
+
+    // Auth tools (login/logout)
+    registerAuthTools(server);
+
+    // Project & user management (via backend API)
+    registerProjectTools(server, api);
+    registerUserTools(server, api);
+
+    // Collection schema AI tools (via backend API)
+    registerCollectionTools(server, api);
+
+    // Firestore document CRUD (via backend API proxy)
+    registerDocumentTools(server, api);
+
+    // Data export (via backend API)
+    registerExportTools(server, api);
+
+    // Resources
+    registerProjectResources(server, api);
+
+    return server;
+}

package/src/tools/auth.ts

@@ -0,0 +1,110 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+    isLoggedIn,
+    getCurrentUserEmail,
+    loginFlow,
+    logoutFlow,
+} from "../auth.js";
+
+/**
+ * Register login/logout tools — same flow as `rebase login` CLI.
+ */
+export function registerAuthTools(server: McpServer) {
+
+    server.registerTool(
+        "rebase_login",
+        {
+            description: "Sign in to Rebase Cloud. Opens a browser window for Google OAuth authentication. Required before using any other tools.",
+        },
+        async () => {
+            const existingEmail = getCurrentUserEmail();
+            if (existingEmail) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Already logged in as ${existingEmail}. Use rebase_logout to sign out first.`,
+                    }],
+                };
+            }
+
+            try {
+                await loginFlow();
+                const email = getCurrentUserEmail();
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Successfully logged in as ${email ?? "unknown"}`,
+                    }],
+                };
+            } catch (error: any) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Login failed: ${error.message}`,
+                    }],
+                    isError: true,
+                };
+            }
+        }
+    );
+
+    server.registerTool(
+        "rebase_logout",
+        {
+            description: "Sign out of Rebase Cloud. Revokes the current session.",
+        },
+        async () => {
+            if (!isLoggedIn()) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: "Not currently logged in.",
+                    }],
+                };
+            }
+
+            const email = getCurrentUserEmail();
+            try {
+                await logoutFlow();
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Successfully logged out ${email ?? ""}`.trim(),
+                    }],
+                };
+            } catch (error: any) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: `Logout failed: ${error.message}`,
+                    }],
+                    isError: true,
+                };
+            }
+        }
+    );
+
+    server.registerTool(
+        "rebase_get_current_user",
+        {
+            description: "Get the currently authenticated Rebase user",
+        },
+        async () => {
+            const email = getCurrentUserEmail();
+            if (!email) {
+                return {
+                    content: [{
+                        type: "text" as const,
+                        text: "Not logged in. Use rebase_login to sign in.",
+                    }],
+                };
+            }
+            return {
+                content: [{
+                    type: "text" as const,
+                    text: `Logged in as: ${email}`,
+                }],
+            };
+        }
+    );
+}

package/src/tools/collections.ts

@@ -0,0 +1,52 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { RebaseApiClient } from "../api-client.js";
+
+/**
+ * Register collection schema tools.
+ */
+export function registerCollectionTools(server: McpServer, api: RebaseApiClient) {
+
+    server.registerTool(
+        "generate_collection",
+        {
+            description: `Generate a new Rebase collection schema using AI. Provide a natural language description 
+of the collection you want (e.g., "A blog with posts that have title, body, author, tags, 
+and a featured image"). Returns a complete Rebase collection configuration.`,
+            inputSchema: {
+                prompt: z.string().describe("Natural language description of the collection to generate"),
+                existingCollections: z.array(z.any()).optional().describe("Optional existing collection schemas for context"),
+            },
+        },
+        async ({ prompt, existingCollections }) => {
+            try {
+                const result = await api.generateCollection(prompt, existingCollections ?? []);
+                return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+            } catch (error: any) {
+                return { content: [{ type: "text" as const, text: `Error: ${error.message}` }], isError: true };
+            }
+        }
+    );
+
+    server.registerTool(
+        "modify_collection",
+        {
+            description: `Modify an existing Rebase collection schema using AI. Describe the changes you want 
+(e.g., "Add a priority enum with low/medium/high" or "Make title required with max 100 chars").
+Returns the updated schema and a list of operations performed.`,
+            inputSchema: {
+                prompt: z.string().describe("Description of the modifications"),
+                existingCollection: z.any().describe("The current collection schema to modify"),
+                existingCollections: z.array(z.any()).optional().describe("Optional list of all collection schemas for context"),
+            },
+        },
+        async ({ prompt, existingCollection, existingCollections }) => {
+            try {
+                const result = await api.generateCollection(prompt, existingCollections ?? [], existingCollection);
+                return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+            } catch (error: any) {
+                return { content: [{ type: "text" as const, text: `Error: ${error.message}` }], isError: true };
+            }
+        }
+    );
+}