@rebasepro/mcp 0.0.1-canary.4829d6e

package/dist/index.js

@@ -0,0 +1,1211 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { spawn } from "node:child_process";
+import { config as loadDotenv } from "dotenv";
+import { resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+/**
+ * Detect the project's package manager by checking for lock files.
+ * Falls back to pnpm (Rebase's default) if no lock file is found.
+ */
+export function detectPackageManager(projectDir) {
+    const candidates = [
+        ["pnpm-lock.yaml", "pnpm"],
+        ["pnpm-workspace.yaml", "pnpm"],
+        ["yarn.lock", "yarn"],
+        ["package-lock.json", "npm"]
+    ];
+    for (const [lockFile, pm] of candidates) {
+        if (existsSync(resolve(projectDir, lockFile)))
+            return pm;
+    }
+    // Also check in app/ subdirectory for scaffolded projects
+    for (const [lockFile, pm] of candidates) {
+        if (existsSync(resolve(projectDir, "app", lockFile)))
+            return pm;
+    }
+    return "pnpm"; // Rebase default
+}
+/** Return the exec command and its arguments prefix for running a package binary. */
+export function getExecCommand(pm) {
+    switch (pm) {
+        case "pnpm":
+            return { command: "pnpm", args: ["exec"] };
+        case "yarn":
+            return { command: "yarn", args: ["exec"] };
+        case "npm":
+            return { command: "npx", args: [] };
+    }
+}
+/** Return the run command for executing package.json scripts. */
+export function getRunCommand(pm) {
+    switch (pm) {
+        case "pnpm":
+            return { command: "pnpm", args: ["run"] };
+        case "yarn":
+            return { command: "yarn", args: ["run"] };
+        case "npm":
+            return { command: "npm", args: ["run"] };
+    }
+}
+// We dynamically load @rebasepro/client to avoid transitive type issues.
+// The client SDK ships compiled .d.ts that reference @rebasepro/types (which
+// drags in React peer-deps).  By importing at runtime only we keep the MCP
+// server build clean.
+const CLIENT_PKG = "@rebasepro/client";
+async function loadClientSdk() {
+    const mod = await import(/* webpackIgnore: true */ CLIENT_PKG);
+    return mod.createRebaseClient;
+}
+/** Path to the project registry file. */
+const REGISTRY_PATH = resolve(homedir(), ".rebase", "projects.json");
+/** In-memory project registry. */
+let registry = { projects: {}, activeProject: null };
+/**
+ * Load the project registry from disk. Creates the file if it doesn't exist.
+ */
+function loadRegistry() {
+    try {
+        if (existsSync(REGISTRY_PATH)) {
+            const raw = readFileSync(REGISTRY_PATH, "utf-8");
+            const parsed = JSON.parse(raw);
+            return {
+                projects: parsed.projects || {},
+                activeProject: parsed.activeProject || null
+            };
+        }
+    }
+    catch {
+        // Corrupted file — start fresh
+    }
+    return { projects: {}, activeProject: null };
+}
+/**
+ * Save the project registry to disk.
+ */
+function saveRegistry() {
+    try {
+        const dir = resolve(homedir(), ".rebase");
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
+    }
+    catch {
+        // Non-fatal — registry won't persist across restarts
+    }
+}
+/**
+ * Read `.rebase/state.json` from a project directory to auto-discover
+ * a running dev server's URL and service key.
+ */
+function readDevState(projectDir) {
+    try {
+        const statePath = resolve(projectDir, ".rebase", "state.json");
+        if (!existsSync(statePath))
+            return null;
+        const raw = readFileSync(statePath, "utf-8");
+        const state = JSON.parse(raw);
+        if (!state.baseUrl)
+            return null;
+        // Verify the process is still running (liveness check)
+        if (state.pid) {
+            try {
+                process.kill(state.pid, 0); // signal 0 = check existence
+            }
+            catch {
+                return null; // process is dead — stale state file
+            }
+        }
+        return {
+            baseUrl: state.baseUrl,
+            serviceKey: state.serviceKey,
+            pid: state.pid
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Try to auto-discover the backend from `.rebase/state.json` in the project dir.
+ * Updates the project config in the registry if a running server is found.
+ */
+function autoDiscoverLocal(project) {
+    if (!project.projectDir)
+        return project;
+    const devState = readDevState(project.projectDir);
+    if (devState) {
+        return {
+            ...project,
+            baseUrl: devState.baseUrl,
+            token: devState.serviceKey || project.token
+        };
+    }
+    return project;
+}
+/**
+ * Read `.env` from a project directory and extract REBASE_SERVICE_KEY.
+ */
+function readServiceKeyFromEnv(projectDir) {
+    for (const envPath of [
+        resolve(projectDir, ".env"),
+        resolve(projectDir, "app", ".env")
+    ]) {
+        try {
+            if (!existsSync(envPath))
+                continue;
+            const content = readFileSync(envPath, "utf-8");
+            const match = content.match(/^REBASE_SERVICE_KEY\s*=\s*["']?([^"'\n\r]+)["']?/m);
+            if (match?.[1] && match[1].trim().length >= 32) {
+                return match[1].trim();
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return undefined;
+}
+// ── Environment & Initialization ────────────────────────────────────────────
+const ENV_PROJECT_DIR = process.env.REBASE_PROJECT_DIR || process.cwd();
+// Try to load .env from the project directory
+for (const envPath of [
+    resolve(ENV_PROJECT_DIR, ".env"),
+    resolve(ENV_PROJECT_DIR, "app", ".env")
+]) {
+    if (existsSync(envPath)) {
+        loadDotenv({ path: envPath });
+        break;
+    }
+}
+const ENV_BASE_URL = process.env.REBASE_BASE_URL || "";
+const ENV_API_TOKEN = process.env.REBASE_API_TOKEN || process.env.REBASE_TOKEN || "";
+/**
+ * Initialize the project registry.
+ *
+ * Priority:
+ * 1. REBASE_PROJECT_DIR env → single-project mode (backward-compatible)
+ * 2. Load ~/.rebase/projects.json
+ * 3. Auto-discover from .rebase/state.json in the project dir
+ */
+function initializeRegistry() {
+    registry = loadRegistry();
+    // Ensure a "default" project exists from env vars or CWD
+    if (!registry.projects["default"]) {
+        const devState = readDevState(ENV_PROJECT_DIR);
+        const envServiceKey = readServiceKeyFromEnv(ENV_PROJECT_DIR);
+        registry.projects["default"] = {
+            name: "default",
+            projectDir: ENV_PROJECT_DIR,
+            baseUrl: ENV_BASE_URL || devState?.baseUrl || "http://localhost:3001",
+            token: ENV_API_TOKEN || devState?.serviceKey || envServiceKey || "",
+            addedAt: new Date().toISOString()
+        };
+    }
+    if (!registry.activeProject || !registry.projects[registry.activeProject]) {
+        registry.activeProject = "default";
+    }
+}
+initializeRegistry();
+/** Client instances keyed by project name. */
+const clientCache = new Map();
+/** Get the active project config, with auto-discovery applied. */
+function getActiveProject() {
+    const name = registry.activeProject || "default";
+    const project = registry.projects[name];
+    if (!project) {
+        throw new Error(`No active project configured. Use rebase_project_add to register one.`);
+    }
+    return autoDiscoverLocal(project);
+}
+/** Get the project directory for the active project. */
+function getProjectDir() {
+    const project = getActiveProject();
+    return project.projectDir || ENV_PROJECT_DIR;
+}
+async function getClient() {
+    const project = getActiveProject();
+    const cacheKey = `${project.name}::${project.baseUrl}::${project.token}`;
+    const cached = clientCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const createRebaseClient = await loadClientSdk();
+    const client = createRebaseClient({
+        baseUrl: project.baseUrl,
+        token: project.token || undefined
+    });
+    clientCache.set(cacheKey, client);
+    return client;
+}
+/** Clear cached clients (used when switching projects). */
+function clearClientCache() {
+    clientCache.clear();
+}
+async function ensureAdmin() {
+    const client = await getClient();
+    try {
+        const user = await client.auth.getUser();
+        if (!user.roles?.includes("admin")) {
+            throw new Error("Access denied: User does not have the 'admin' role.");
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Admin authorization failed: ${msg}`);
+    }
+}
+// ── MCP Server ──────────────────────────────────────────────────────────────
+export const server = new Server({ name: "rebase-mcp-server",
+    version: "0.1.0" }, { capabilities: { tools: {},
+        resources: {} } });
+const CLI_TOOLS = [
+    {
+        name: "rebase_schema_generate",
+        description: "Generate Drizzle schema from Rebase TypeScript collection definitions. Run this after adding or modifying collection files.",
+        inputSchema: { type: "object",
+            properties: {} },
+        cmd: ["schema", "generate"]
+    },
+    {
+        name: "rebase_db_push",
+        description: "Apply the current Drizzle schema directly to the database (development shortcut, skips migration files).",
+        inputSchema: { type: "object",
+            properties: {} },
+        cmd: ["db", "push"]
+    },
+    {
+        name: "rebase_schema_introspect",
+        description: "Introspect the live database and generate Rebase collection definitions from existing tables.",
+        inputSchema: { type: "object",
+            properties: {} },
+        cmd: ["schema", "introspect"]
+    },
+    {
+        name: "rebase_db_generate",
+        description: "Generate SQL migration files from schema changes (compares current Drizzle schema against the last entity).",
+        inputSchema: { type: "object",
+            properties: {} },
+        cmd: ["db", "generate"]
+    },
+    {
+        name: "rebase_db_migrate",
+        description: "Run all pending SQL migrations against the database.",
+        inputSchema: { type: "object",
+            properties: {} },
+        cmd: ["db", "migrate"]
+    },
+    {
+        name: "rebase_generate_sdk",
+        description: "Generate a fully-typed JavaScript/TypeScript SDK from collection definitions.",
+        inputSchema: { type: "object",
+            properties: {} },
+        cmd: ["generate-sdk"]
+    },
+    {
+        name: "rebase_doctor",
+        description: "Detect schema drift between collection definitions, generated Drizzle schema, and the live PostgreSQL database.",
+        inputSchema: { type: "object", properties: {} },
+        cmd: ["doctor"]
+    },
+    {
+        name: "rebase_db_branch_create",
+        description: "Create a new database branch (Admins only).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the new database branch" },
+                from: { type: "string", description: "Parent branch to clone from (optional)" }
+            },
+            required: ["name"]
+        },
+        cmd: ["db", "branch", "create"]
+    },
+    {
+        name: "rebase_db_branch_list",
+        description: "List all database branches (Admins only).",
+        inputSchema: { type: "object", properties: {} },
+        cmd: ["db", "branch", "list"]
+    },
+    {
+        name: "rebase_db_branch_delete",
+        description: "Delete an existing database branch (Admins only).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the branch to delete" }
+            },
+            required: ["name"]
+        },
+        cmd: ["db", "branch", "delete"]
+    },
+    {
+        name: "rebase_db_branch_info",
+        description: "Show information and status for a database branch (Admins only).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the branch to inspect" }
+            },
+            required: ["name"]
+        },
+        cmd: ["db", "branch", "info"]
+    }
+];
+const DATA_TOOLS = [
+    {
+        name: "list_documents",
+        description: "List documents from a Rebase collection with optional filtering, sorting, and pagination.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                collection: { type: "string",
+                    description: "Collection slug" },
+                limit: { type: "number",
+                    description: "Max results (default 25)" },
+                offset: { type: "number",
+                    description: "Skip N results" },
+                orderBy: { type: "string",
+                    description: "Sort field, optionally with :asc or :desc suffix" },
+                where: {
+                    type: "object",
+                    description: "Filter object, e.g. { \"status\": \"eq.active\", \"price\": \"gte.100\" }",
+                    additionalProperties: true
+                }
+            },
+            required: ["collection"]
+        }
+    },
+    {
+        name: "get_document",
+        description: "Get a single document by ID from a Rebase collection.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                collection: { type: "string",
+                    description: "Collection slug" },
+                id: { type: "string",
+                    description: "Document ID" }
+            },
+            required: ["collection", "id"]
+        }
+    },
+    {
+        name: "create_document",
+        description: "Create a new document in a Rebase collection.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                collection: { type: "string",
+                    description: "Collection slug" },
+                data: { type: "object",
+                    description: "Document data",
+                    additionalProperties: true }
+            },
+            required: ["collection", "data"]
+        }
+    },
+    {
+        name: "update_document",
+        description: "Update an existing document in a Rebase collection.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                collection: { type: "string",
+                    description: "Collection slug" },
+                id: { type: "string",
+                    description: "Document ID" },
+                data: { type: "object",
+                    description: "Fields to update",
+                    additionalProperties: true }
+            },
+            required: ["collection", "id", "data"]
+        }
+    },
+    {
+        name: "delete_document",
+        description: "Delete a document from a Rebase collection.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                collection: { type: "string",
+                    description: "Collection slug" },
+                id: { type: "string",
+                    description: "Document ID" }
+            },
+            required: ["collection", "id"]
+        }
+    }
+];
+const ADMIN_TOOLS = [
+    {
+        name: "list_users",
+        description: "List all users registered in the Rebase backend, including their roles.",
+        inputSchema: { type: "object",
+            properties: {} }
+    },
+    {
+        name: "create_user",
+        description: "Create a new user in the Rebase backend.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                email: { type: "string",
+                    description: "User email" },
+                displayName: { type: "string",
+                    description: "Display name" },
+                password: { type: "string",
+                    description: "Initial password" },
+                roles: { type: "array",
+                    items: { type: "string" },
+                    description: "Role IDs to assign" }
+            },
+            required: ["email"]
+        }
+    },
+    {
+        name: "update_user",
+        description: "Update an existing user (email, display name, roles).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                userId: { type: "string",
+                    description: "User UID" },
+                email: { type: "string" },
+                displayName: { type: "string" },
+                roles: { type: "array",
+                    items: { type: "string" } }
+            },
+            required: ["userId"]
+        }
+    },
+    {
+        name: "delete_user",
+        description: "Delete a user from the Rebase backend.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                userId: { type: "string",
+                    description: "User UID" }
+            },
+            required: ["userId"]
+        }
+    },
+    {
+        name: "list_roles",
+        description: "List all roles defined in the Rebase backend.",
+        inputSchema: { type: "object",
+            properties: {} }
+    },
+    {
+        name: "rebase_auth_reset_password",
+        description: "Reset a user's password via the admin API. Looks up the user by email, then resets their password. Returns a temporary password if email is not configured, or sends a reset email.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                email: { type: "string", description: "Email of the user to reset" },
+                password: { type: "string", description: "New password to set (optional — if omitted, a secure temporary password is generated)" }
+            },
+            required: ["email"]
+        }
+    }
+];
+const DEV_TOOLS = [
+    {
+        name: "rebase_dev_start",
+        description: "Start the Rebase development server (frontend + backend). Returns immediately — use rebase_dev_logs to check output.",
+        inputSchema: { type: "object",
+            properties: {} }
+    },
+    {
+        name: "rebase_dev_logs",
+        description: "Read recent output from the running Rebase dev server.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lines: { type: "number",
+                    description: "Number of recent lines to return (default 50)" }
+            }
+        }
+    },
+    {
+        name: "rebase_dev_stop",
+        description: "Stop the running Rebase development server.",
+        inputSchema: { type: "object",
+            properties: {} }
+    }
+];
+const STORAGE_TOOLS = [
+    {
+        name: "storage_list_objects",
+        description: "List files/objects stored in Rebase storage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prefix: { type: "string", description: "Filter objects by prefix (e.g. 'images/')" },
+                bucket: { type: "string", description: "Filter by storage bucket name" },
+                maxResults: { type: "number", description: "Maximum number of results to return (default 50)" },
+                pageToken: { type: "string", description: "Pagination token" }
+            }
+        }
+    },
+    {
+        name: "storage_delete_object",
+        description: "Delete an object/file from Rebase storage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Key/path of the file to delete (e.g., 'images/profile.png')" },
+                bucket: { type: "string", description: "Storage bucket name" }
+            },
+            required: ["key"]
+        }
+    },
+    {
+        name: "storage_get_metadata",
+        description: "Get metadata and a temporary signed download URL for a file in Rebase storage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Key/path/url of the file to download" },
+                bucket: { type: "string", description: "Storage bucket name" }
+            },
+            required: ["key"]
+        }
+    }
+];
+const CRON_TOOLS = [
+    {
+        name: "cron_list_jobs",
+        description: "List all scheduled cron jobs and their configuration status.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "cron_get_job",
+        description: "Get status and details of a specific scheduled cron job.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string", description: "Unique identifier of the cron job" }
+            },
+            required: ["jobId"]
+        }
+    },
+    {
+        name: "cron_trigger_job",
+        description: "Manually trigger a cron job run immediately.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string", description: "Unique identifier of the cron job to run" }
+            },
+            required: ["jobId"]
+        }
+    },
+    {
+        name: "cron_get_job_logs",
+        description: "Read execution logs for a specific cron job.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string", description: "Unique identifier of the cron job" },
+                limit: { type: "number", description: "Number of log lines to return (default 50)" }
+            },
+            required: ["jobId"]
+        }
+    },
+    {
+        name: "cron_toggle_job",
+        description: "Enable or disable a scheduled cron job.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                jobId: { type: "string", description: "Unique identifier of the cron job" },
+                enabled: { type: "boolean", description: "Set to true to enable, false to disable" }
+            },
+            required: ["jobId", "enabled"]
+        }
+    }
+];
+const FUNCTION_TOOLS = [
+    {
+        name: "invoke_function",
+        description: "Invoke a custom backend Hono function (located in api/functions/:name).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Function name (filename without extension, e.g. 'send-welcome-email')" },
+                payload: { type: "object", description: "Optional JSON payload body for POST/PUT/PATCH requests", additionalProperties: true },
+                method: { type: "string", enum: ["GET", "POST", "PUT", "PATCH", "DELETE"], description: "HTTP Method (defaults to POST)" },
+                path: { type: "string", description: "Optional sub-path to append after the function name (e.g. 'status/123')" }
+            },
+            required: ["name"]
+        }
+    }
+];
+const PROJECT_TOOLS = [
+    {
+        name: "rebase_project_list",
+        description: "List all registered Rebase projects and show which one is active.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "rebase_project_switch",
+        description: "Switch the active Rebase project by name. All subsequent API calls will target this project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the project to switch to" }
+            },
+            required: ["name"]
+        }
+    },
+    {
+        name: "rebase_project_add",
+        description: "Register a new Rebase project. For local projects, provide projectDir (auto-discovers URL and service key). For remote projects, provide baseUrl and token.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Unique name for this project (e.g. 'my-app', 'staging')" },
+                projectDir: { type: "string", description: "Absolute path to the project directory (for local projects)" },
+                baseUrl: { type: "string", description: "Backend URL (e.g. https://staging.myapp.com)" },
+                token: { type: "string", description: "Auth token — service key or API key (for remote projects)" }
+            },
+            required: ["name"]
+        }
+    },
+    {
+        name: "rebase_project_remove",
+        description: "Remove a registered project from the project registry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the project to remove" }
+            },
+            required: ["name"]
+        }
+    },
+    {
+        name: "rebase_project_current",
+        description: "Show details about the currently active Rebase project, including resolved URL and auth status.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "rebase_project_status",
+        description: "Health-check the active project's backend by calling GET /health.",
+        inputSchema: { type: "object", properties: {} }
+    }
+];
+export const ALL_TOOLS = [
+    ...CLI_TOOLS.map(({ cmd: _c, ...rest }) => rest),
+    ...DATA_TOOLS,
+    ...ADMIN_TOOLS,
+    ...DEV_TOOLS,
+    ...STORAGE_TOOLS,
+    ...CRON_TOOLS,
+    ...FUNCTION_TOOLS,
+    ...PROJECT_TOOLS
+];
+// ── Tool Handlers ───────────────────────────────────────────────────────────
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: ALL_TOOLS
+}));
+/** Spawn the rebase CLI using the project's detected package manager. */
+function runRebaseCmd(commandArgs) {
+    const projectDir = getProjectDir();
+    const pm = detectPackageManager(projectDir);
+    const { command, args: execArgs } = getExecCommand(pm);
+    return new Promise((resolve) => {
+        const child = spawn(command, [...execArgs, "rebase", ...commandArgs], {
+            cwd: projectDir,
+            shell: true,
+            env: {
+                ...process.env,
+                PNPM_CONFIG_VERIFY_DEPS_BEFORE_RUN: "false"
+            }
+        });
+        const chunks = [];
+        child.stdout?.on("data", (d) => chunks.push(d.toString()));
+        child.stderr?.on("data", (d) => chunks.push(d.toString()));
+        child.on("error", (err) => resolve(`Error spawning command: ${err.message}`));
+        child.on("close", (code) => {
+            const output = chunks.join("").trim();
+            resolve(code !== 0 ? `Command exited with code ${code}\n\n${output}` : output || "(no output)");
+        });
+    });
+}
+// Dev server management
+let devProcess = null;
+const devLogs = [];
+const MAX_DEV_LOG_LINES = 500;
+function appendDevLog(line) {
+    devLogs.push(line);
+    if (devLogs.length > MAX_DEV_LOG_LINES) {
+        devLogs.splice(0, devLogs.length - MAX_DEV_LOG_LINES);
+    }
+}
+function textResult(text) {
+    return { content: [{ type: "text",
+                text }] };
+}
+function jsonResult(data) {
+    return textResult(JSON.stringify(data, null, 2));
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name, arguments: args } = request.params;
+        // ── CLI tools ───────────────────────────────────────────────────────
+        const cliTool = CLI_TOOLS.find((t) => t.name === name);
+        if (cliTool) {
+            if (name.startsWith("rebase_db_branch_")) {
+                await ensureAdmin();
+            }
+            const cmdArgs = [...cliTool.cmd];
+            if (name === "rebase_db_branch_create") {
+                const argsObj = args;
+                cmdArgs.push(argsObj.name);
+                if (argsObj.from) {
+                    cmdArgs.push("--from", argsObj.from);
+                }
+            }
+            else if (name === "rebase_db_branch_delete" || name === "rebase_db_branch_info") {
+                const argsObj = args;
+                cmdArgs.push(argsObj.name);
+            }
+            const result = await runRebaseCmd(cmdArgs);
+            return textResult(result);
+        }
+        // ── Project management tools ────────────────────────────────────────
+        switch (name) {
+            case "rebase_project_list": {
+                const projects = Object.values(registry.projects).map((p) => ({
+                    name: p.name,
+                    projectDir: p.projectDir || null,
+                    baseUrl: p.baseUrl,
+                    hasToken: !!p.token,
+                    active: p.name === registry.activeProject,
+                    addedAt: p.addedAt
+                }));
+                return jsonResult({ projects, activeProject: registry.activeProject });
+            }
+            case "rebase_project_switch": {
+                const argsObj = args;
+                if (!registry.projects[argsObj.name]) {
+                    return textResult(`Project "${argsObj.name}" not found. Available: ${Object.keys(registry.projects).join(", ")}`);
+                }
+                registry.activeProject = argsObj.name;
+                clearClientCache();
+                saveRegistry();
+                const project = getActiveProject();
+                return jsonResult({
+                    message: `Switched to project "${argsObj.name}"`,
+                    project: {
+                        name: project.name,
+                        baseUrl: project.baseUrl,
+                        hasToken: !!project.token,
+                        projectDir: project.projectDir || null
+                    }
+                });
+            }
+            case "rebase_project_add": {
+                const argsObj = args;
+                const { name: projectName } = argsObj;
+                let baseUrl = argsObj.baseUrl || "";
+                let token = argsObj.token || "";
+                // Auto-discover from project dir if provided
+                if (argsObj.projectDir) {
+                    const devState = readDevState(argsObj.projectDir);
+                    if (devState) {
+                        baseUrl = baseUrl || devState.baseUrl;
+                        token = token || devState.serviceKey || "";
+                    }
+                    if (!token) {
+                        const envKey = readServiceKeyFromEnv(argsObj.projectDir);
+                        if (envKey)
+                            token = envKey;
+                    }
+                }
+                if (!baseUrl) {
+                    return textResult("Error: Could not determine baseUrl. Provide --baseUrl or ensure the dev server is running in the project directory.");
+                }
+                registry.projects[projectName] = {
+                    name: projectName,
+                    projectDir: argsObj.projectDir,
+                    baseUrl,
+                    token,
+                    addedAt: new Date().toISOString()
+                };
+                saveRegistry();
+                return jsonResult({
+                    message: `Project "${projectName}" registered`,
+                    project: {
+                        name: projectName,
+                        baseUrl,
+                        hasToken: !!token,
+                        projectDir: argsObj.projectDir || null
+                    }
+                });
+            }
+            case "rebase_project_remove": {
+                const argsObj = args;
+                if (argsObj.name === "default") {
+                    return textResult("Cannot remove the default project.");
+                }
+                if (!registry.projects[argsObj.name]) {
+                    return textResult(`Project "${argsObj.name}" not found.`);
+                }
+                delete registry.projects[argsObj.name];
+                if (registry.activeProject === argsObj.name) {
+                    registry.activeProject = "default";
+                    clearClientCache();
+                }
+                saveRegistry();
+                return textResult(`Project "${argsObj.name}" removed.`);
+            }
+            case "rebase_project_current": {
+                const project = getActiveProject();
+                return jsonResult({
+                    name: project.name,
+                    projectDir: project.projectDir || null,
+                    baseUrl: project.baseUrl,
+                    hasToken: !!project.token,
+                    tokenPrefix: project.token ? project.token.substring(0, 8) + "..." : null,
+                    addedAt: project.addedAt
+                });
+            }
+            case "rebase_project_status": {
+                const project = getActiveProject();
+                try {
+                    // Try `/health` first (standard Rebase backend), fall back to `/api/health` if it 404s
+                    let res = await fetch(`${project.baseUrl}/health`);
+                    if (res.status === 404) {
+                        const fallbackRes = await fetch(`${project.baseUrl}/api/health`);
+                        if (fallbackRes.status !== 404) {
+                            res = fallbackRes;
+                        }
+                    }
+                    let body = {};
+                    const contentType = res.headers.get("content-type");
+                    if (contentType && contentType.includes("application/json")) {
+                        try {
+                            body = await res.json();
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    else {
+                        body = { responseText: await res.text().catch(() => "") };
+                    }
+                    return jsonResult({
+                        project: project.name,
+                        baseUrl: project.baseUrl,
+                        status: res.ok ? "healthy" : "unhealthy",
+                        httpStatus: res.status,
+                        ...body
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return jsonResult({
+                        project: project.name,
+                        baseUrl: project.baseUrl,
+                        status: "unreachable",
+                        error: msg
+                    });
+                }
+            }
+        }
+        // ── Data & admin tools (via @rebasepro/client) ──────────────────────
+        const client = await getClient();
+        switch (name) {
+            case "list_documents": {
+                const argsObj = args;
+                const { collection: slug, limit, offset, orderBy, where } = argsObj;
+                const result = await client.data.collection(slug).find({
+                    limit,
+                    offset,
+                    orderBy,
+                    where
+                });
+                return jsonResult(result);
+            }
+            case "get_document": {
+                const argsObj = args;
+                const { collection: slug, id } = argsObj;
+                const entity = await client.data.collection(slug).findById(id);
+                if (!entity)
+                    return textResult(`Document ${id} not found in ${slug}`);
+                return jsonResult(entity);
+            }
+            case "create_document": {
+                const argsObj = args;
+                const { collection: slug, data } = argsObj;
+                const entity = await client.data.collection(slug).create(data);
+                return jsonResult(entity);
+            }
+            case "update_document": {
+                const argsObj = args;
+                const { collection: slug, id, data } = argsObj;
+                const entity = await client.data.collection(slug).update(id, data);
+                return jsonResult(entity);
+            }
+            case "delete_document": {
+                const argsObj = args;
+                const { collection: slug, id } = argsObj;
+                await client.data.collection(slug).delete(id);
+                return textResult(`Deleted document ${id} from ${slug}`);
+            }
+            // ── Admin tools ────────────────────────────────────────────────────
+            case "list_users": {
+                const result = await client.admin.listUsers();
+                return jsonResult(result);
+            }
+            case "create_user": {
+                const argsObj = args;
+                const { email, displayName, password, roles } = argsObj;
+                const result = await client.admin.createUser({ email,
+                    displayName,
+                    password,
+                    roles });
+                return jsonResult(result);
+            }
+            case "update_user": {
+                const argsObj = args;
+                const { userId, email, displayName, roles } = argsObj;
+                const result = await client.admin.updateUser(userId, { email,
+                    displayName,
+                    roles });
+                return jsonResult(result);
+            }
+            case "delete_user": {
+                const argsObj = args;
+                const { userId } = argsObj;
+                const result = await client.admin.deleteUser(userId);
+                return jsonResult(result);
+            }
+            case "list_roles": {
+                const result = await client.admin.listRoles();
+                return jsonResult(result);
+            }
+            case "rebase_auth_reset_password": {
+                const argsObj = args;
+                const { email, password } = argsObj;
+                // Step 1: Find user by email
+                const usersResult = await client.admin.listUsersPaginated({ search: email, limit: 1 });
+                const user = usersResult.users.find((u) => u.email === email);
+                if (!user) {
+                    return textResult(`User with email "${email}" not found.`);
+                }
+                const userId = user.uid || user.id;
+                if (!userId) {
+                    return textResult(`Could not determine user ID for "${email}".`);
+                }
+                // Step 2: Reset password via admin API
+                const resetResult = await client.admin.resetPassword(userId, password ? { password } : undefined);
+                return jsonResult({
+                    message: `Password reset for ${email}`,
+                    user: resetResult.user,
+                    temporaryPassword: resetResult.temporaryPassword,
+                    invitationSent: resetResult.invitationSent
+                });
+            }
+            // ── Storage Tools ──────────────────────────────────────────────────
+            case "storage_list_objects": {
+                const argsObj = args;
+                const { prefix = "", bucket, maxResults, pageToken } = argsObj;
+                const result = await client.storage.listObjects(prefix, { bucket, maxResults, pageToken });
+                return jsonResult(result);
+            }
+            case "storage_delete_object": {
+                const argsObj = args;
+                const { key, bucket } = argsObj;
+                await client.storage.deleteObject(key, bucket);
+                return textResult(`Deleted object "${key}" successfully.`);
+            }
+            case "storage_get_metadata": {
+                const argsObj = args;
+                const { key, bucket } = argsObj;
+                const result = await client.storage.getSignedUrl(key, bucket);
+                return jsonResult(result);
+            }
+            // ── Cron Tools ─────────────────────────────────────────────────────
+            case "cron_list_jobs": {
+                const result = await client.cron.listJobs();
+                return jsonResult(result);
+            }
+            case "cron_get_job": {
+                const argsObj = args;
+                const result = await client.cron.getJob(argsObj.jobId);
+                return jsonResult(result);
+            }
+            case "cron_trigger_job": {
+                const argsObj = args;
+                const result = await client.cron.triggerJob(argsObj.jobId);
+                return jsonResult(result);
+            }
+            case "cron_get_job_logs": {
+                const argsObj = args;
+                const result = await client.cron.getJobLogs(argsObj.jobId, { limit: argsObj.limit });
+                return jsonResult(result);
+            }
+            case "cron_toggle_job": {
+                const argsObj = args;
+                const result = await client.cron.toggleJob(argsObj.jobId, argsObj.enabled);
+                return jsonResult(result);
+            }
+            // ── Function Tools ─────────────────────────────────────────────────
+            case "invoke_function": {
+                const argsObj = args;
+                const { name: funcName, payload, method, path: funcPath } = argsObj;
+                const result = await client.functions.invoke(funcName, payload, { method, path: funcPath });
+                return jsonResult(result);
+            }
+            // ── Dev server management ──────────────────────────────────────────
+            case "rebase_dev_start": {
+                if (devProcess && !devProcess.killed) {
+                    return textResult("Dev server is already running (PID " + devProcess.pid + ")");
+                }
+                devLogs.length = 0;
+                const projectDir = getProjectDir();
+                const pm = detectPackageManager(projectDir);
+                const { command: runCmd, args: runArgs } = getRunCommand(pm);
+                devProcess = spawn(runCmd, [...runArgs, "dev"], {
+                    cwd: resolve(projectDir, "app"),
+                    shell: true,
+                    env: { ...process.env }
+                });
+                devProcess.stdout?.on("data", (d) => appendDevLog(d.toString()));
+                devProcess.stderr?.on("data", (d) => appendDevLog(d.toString()));
+                devProcess.on("close", (code) => {
+                    appendDevLog(`\n[dev server exited with code ${code}]`);
+                    devProcess = null;
+                });
+                // Wait a moment for initial output
+                await new Promise((r) => setTimeout(r, 2000));
+                return textResult(`Dev server started (PID ${devProcess?.pid})\n\n${devLogs.join("")}`);
+            }
+            case "rebase_dev_logs": {
+                const argsObj = args;
+                const lineCount = argsObj?.lines ?? 50;
+                const recent = devLogs.slice(-lineCount);
+                if (recent.length === 0) {
+                    return textResult(devProcess ? "No output captured yet." : "Dev server is not running.");
+                }
+                return textResult(recent.join(""));
+            }
+            case "rebase_dev_stop": {
+                if (!devProcess || devProcess.killed) {
+                    return textResult("Dev server is not running.");
+                }
+                devProcess.kill("SIGTERM");
+                return textResult("Dev server stopped.");
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error: ${msg}`
+                }],
+            isError: true
+        };
+    }
+});
+// ── Resources ───────────────────────────────────────────────────────────────
+function findCollectionsDir() {
+    const projectDir = getProjectDir();
+    const candidates = [
+        resolve(projectDir, "app", "config", "collections"),
+        resolve(projectDir, "config", "collections"),
+        resolve(projectDir, "collections")
+    ];
+    for (const dir of candidates) {
+        if (existsSync(dir))
+            return dir;
+    }
+    return null;
+}
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const resources = [];
+    // Collection files
+    const collectionsDir = findCollectionsDir();
+    if (collectionsDir) {
+        const files = readdirSync(collectionsDir).filter((f) => f.endsWith(".ts") && f !== "index.ts");
+        for (const file of files) {
+            const name = file.replace(/\.ts$/, "");
+            resources.push({
+                uri: `rebase://collections/${name}`,
+                name: `Collection: ${name}`,
+                description: `TypeScript collection definition for "${name}"`,
+                mimeType: "text/typescript"
+            });
+        }
+    }
+    // Generated schema
+    const projectDir = getProjectDir();
+    const schemaPath = resolve(projectDir, "app", "backend", "src", "schema.generated.ts");
+    if (existsSync(schemaPath)) {
+        resources.push({
+            uri: "rebase://schema",
+            name: "Generated Drizzle Schema",
+            description: "Auto-generated Drizzle ORM schema from collection definitions",
+            mimeType: "text/typescript"
+        });
+    }
+    return { resources };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const projectDir = getProjectDir();
+    if (uri === "rebase://schema") {
+        const schemaPath = resolve(projectDir, "app", "backend", "src", "schema.generated.ts");
+        if (!existsSync(schemaPath)) {
+            throw new Error("Generated schema not found. Run `rebase schema generate` first.");
+        }
+        return {
+            contents: [{
+                    uri,
+                    mimeType: "text/typescript",
+                    text: readFileSync(schemaPath, "utf-8")
+                }]
+        };
+    }
+    const collectionMatch = uri.match(/^rebase:\/\/collections\/(.+)$/);
+    if (collectionMatch) {
+        const name = collectionMatch[1];
+        const collectionsDir = findCollectionsDir();
+        if (!collectionsDir)
+            throw new Error("Collections directory not found.");
+        const absoluteCollectionsDir = resolve(collectionsDir);
+        const filePath = resolve(absoluteCollectionsDir, `${name}.ts`);
+        if (!filePath.startsWith(absoluteCollectionsDir)) {
+            throw new Error("Access denied: path traversal detected");
+        }
+        if (!existsSync(filePath))
+            throw new Error(`Collection "${name}" not found.`);
+        return {
+            contents: [{
+                    uri,
+                    mimeType: "text/typescript",
+                    text: readFileSync(filePath, "utf-8")
+                }]
+        };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+});
+// ── Start ───────────────────────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+if (process.env.NODE_ENV !== "test") {
+    main().catch(console.error);
+}
+//# sourceMappingURL=index.js.map