@rebasepro/mcp-server 0.6.1 → 0.7.0

package/dist/index.js

@@ -4,7 +4,8 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { spawn } from "node:child_process";
 import { config as loadDotenv } from "dotenv";
 import { resolve } from "node:path";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+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.
@@ -58,30 +59,190 @@ async function loadClientSdk() {
     const mod = await import(/* webpackIgnore: true */ CLIENT_PKG);
     return mod.createRebaseClient;
 }
-// ── Environment ─────────────────────────────────────────────────────────────
-const PROJECT_DIR = process.env.REBASE_PROJECT_DIR || process.cwd();
+/** 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(PROJECT_DIR, ".env"),
-    resolve(PROJECT_DIR, "app", ".env")
+    resolve(ENV_PROJECT_DIR, ".env"),
+    resolve(ENV_PROJECT_DIR, "app", ".env")
 ]) {
     if (existsSync(envPath)) {
         loadDotenv({ path: envPath });
         break;
     }
 }
-const BASE_URL = process.env.REBASE_BASE_URL || "http://localhost:3001";
-const API_TOKEN = process.env.REBASE_API_TOKEN || process.env.REBASE_TOKEN || "";
-let _client = null;
-async function getClient() {
-    if (!_client) {
-        const createRebaseClient = await loadClientSdk();
-        _client = createRebaseClient({
-            baseUrl: BASE_URL,
-            token: API_TOKEN || undefined
-        });
+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 _client;
+    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();
@@ -92,12 +253,13 @@ async function ensureAdmin() {
         }
     }
     catch (err) {
-        throw new Error(`Admin authorization failed: ${err.message}`);
+        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.0.1" }, { capabilities: { tools: {},
+    version: "0.1.0" }, { capabilities: { tools: {},
         resources: {} } });
 const CLI_TOOLS = [
     {
@@ -148,19 +310,6 @@ const CLI_TOOLS = [
         inputSchema: { type: "object", properties: {} },
         cmd: ["doctor"]
     },
-    {
-        name: "rebase_auth_reset_password",
-        description: "Reset a user's password in the Rebase project.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                email: { type: "string", description: "Email of the user to reset" },
-                password: { type: "string", description: "New password to set (defaults to 'NewPassword123!')" }
-            },
-            required: ["email"]
-        },
-        cmd: ["auth", "reset-password"]
-    },
     {
         name: "rebase_db_branch_create",
         description: "Create a new database branch (Admins only).",
@@ -223,7 +372,7 @@ const DATA_TOOLS = [
                 where: {
                     type: "object",
                     description: "Filter object, e.g. { \"status\": \"eq.active\", \"price\": \"gte.100\" }",
-                    additionalProperties: { type: "string" }
+                    additionalProperties: true
                 }
             },
             required: ["collection"]
@@ -252,7 +401,7 @@ const DATA_TOOLS = [
                 collection: { type: "string",
                     description: "Collection slug" },
                 data: { type: "object",
-                    description: "Document fields",
+                    description: "Document data",
                     additionalProperties: true }
             },
             required: ["collection", "data"]
@@ -349,6 +498,18 @@ const ADMIN_TOOLS = [
         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 = [
@@ -484,6 +645,59 @@ const FUNCTION_TOOLS = [
         }
     }
 ];
+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,
@@ -491,7 +705,8 @@ export const ALL_TOOLS = [
     ...DEV_TOOLS,
     ...STORAGE_TOOLS,
     ...CRON_TOOLS,
-    ...FUNCTION_TOOLS
+    ...FUNCTION_TOOLS,
+    ...PROJECT_TOOLS
 ];
 // ── Tool Handlers ───────────────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -499,13 +714,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 }));
 /** Spawn the rebase CLI using the project's detected package manager. */
 function runRebaseCmd(commandArgs) {
-    const pm = detectPackageManager(PROJECT_DIR);
+    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: PROJECT_DIR,
+            cwd: projectDir,
             shell: true,
-            env: { ...process.env }
+            env: {
+                ...process.env,
+                PNPM_CONFIG_VERIFY_DEPS_BEFORE_RUN: "false"
+            }
         });
         const chunks = [];
         child.stdout?.on("data", (d) => chunks.push(d.toString()));
@@ -535,207 +754,377 @@ function jsonResult(data) {
     return textResult(JSON.stringify(data, null, 2));
 }
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    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();
-        }
-        let cmdArgs = [...cliTool.cmd];
-        if (name === "rebase_auth_reset_password") {
-            const argsObj = args;
-            cmdArgs.push("--email", argsObj.email);
-            if (argsObj.password) {
-                cmdArgs.push("--password", argsObj.password);
+    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();
             }
-        }
-        else if (name === "rebase_db_branch_create") {
-            const argsObj = args;
-            cmdArgs.push(argsObj.name);
-            if (argsObj.from) {
-                cmdArgs.push("--from", argsObj.from);
+            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);
         }
-        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);
-    }
-    // ── Data 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);
-        }
-        // ── 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 pm = detectPackageManager(PROJECT_DIR);
-            const { command: runCmd, args: runArgs } = getRunCommand(pm);
-            devProcess = spawn(runCmd, [...runArgs, "dev"], {
-                cwd: resolve(PROJECT_DIR, "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.");
+        // ── 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
+                    });
+                }
             }
-            return textResult(recent.join(""));
         }
-        case "rebase_dev_stop": {
-            if (!devProcess || devProcess.killed) {
-                return textResult("Dev server is not running.");
+        // ── 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);
             }
-            devProcess.kill("SIGTERM");
-            return textResult("Dev server stopped.");
+            // ── 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}`);
         }
-        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(PROJECT_DIR, "app", "config", "collections"),
-        resolve(PROJECT_DIR, "config", "collections"),
-        resolve(PROJECT_DIR, "collections")
+        resolve(projectDir, "app", "config", "collections"),
+        resolve(projectDir, "config", "collections"),
+        resolve(projectDir, "collections")
     ];
     for (const dir of candidates) {
         if (existsSync(dir))
@@ -760,7 +1149,8 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
         }
     }
     // Generated schema
-    const schemaPath = resolve(PROJECT_DIR, "app", "backend", "src", "schema.generated.ts");
+    const projectDir = getProjectDir();
+    const schemaPath = resolve(projectDir, "app", "backend", "src", "schema.generated.ts");
     if (existsSync(schemaPath)) {
         resources.push({
             uri: "rebase://schema",
@@ -773,8 +1163,9 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
 });
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const { uri } = request.params;
+    const projectDir = getProjectDir();
     if (uri === "rebase://schema") {
-        const schemaPath = resolve(PROJECT_DIR, "app", "backend", "src", "schema.generated.ts");
+        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.");
         }