@spacelr/mcp 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1986 @@
+#!/usr/bin/env node
+
+// libs/mcp-server/src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// libs/mcp-server/src/config.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var REFRESH_TIMEOUT_MS = 1e4;
+function getCredentialsFile() {
+  const home = os.homedir();
+  return path.join(home, ".spacelr", "credentials.json");
+}
+function readStoredCredentials() {
+  try {
+    const file = getCredentialsFile();
+    if (!fs.existsSync(file)) return null;
+    const content = fs.readFileSync(file, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.accessToken !== "string" || !Number.isFinite(parsed.expiresAt) || typeof parsed.apiUrl !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function storeCredentials(credentials) {
+  const file = getCredentialsFile();
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 448 });
+  fs.writeFileSync(file, JSON.stringify(credentials, null, 2), {
+    mode: 384
+  });
+}
+async function refreshToken(credentials) {
+  if (!credentials.refreshToken || !credentials.apiUrl) return null;
+  const apiUrl = credentials.apiUrl.replace(/\/+$/, "");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REFRESH_TIMEOUT_MS);
+  try {
+    console.error("Refreshing access token...");
+    const response = await fetch(`${apiUrl}/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      console.error(`Token refresh failed (HTTP ${response.status})`);
+      return null;
+    }
+    const data = await response.json();
+    if (typeof data.access_token !== "string") {
+      console.error("Token refresh returned unexpected response shape");
+      return null;
+    }
+    const updated = {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token ?? credentials.refreshToken,
+      expiresAt: Date.now() + (data.expires_in ?? 3600) * 1e3,
+      apiUrl: credentials.apiUrl
+    };
+    storeCredentials(updated);
+    console.error("Token refreshed successfully");
+    return data.access_token;
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      console.error("Token refresh timed out");
+    } else {
+      console.error("Token refresh error");
+    }
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function resolveAuthToken() {
+  const envToken = process.env["SPACELR_AUTH_TOKEN"];
+  if (envToken) return envToken;
+  const credentials = readStoredCredentials();
+  if (!credentials) return null;
+  const isExpired = Date.now() >= credentials.expiresAt - 6e4;
+  if (!isExpired) return credentials.accessToken;
+  return refreshToken(credentials);
+}
+function warnIfInsecureUrl(url) {
+  if (url.startsWith("http://") && !url.includes("localhost") && !/^http:\/\/(127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|0\.0\.0\.0|(\[::1\]))(\/|:|$)/.test(url)) {
+    console.error(`Warning: API URL uses plain HTTP (${url}). Credentials will be transmitted unencrypted.`);
+  }
+}
+function resolveApiUrl(credentials) {
+  const envUrl = process.env["SPACELR_API_URL"];
+  if (envUrl) {
+    try {
+      const parsed = new URL(envUrl);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Unsupported protocol: ${parsed.protocol}`);
+      }
+    } catch (err) {
+      throw new Error(`Invalid SPACELR_API_URL: ${envUrl} \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const resolved = envUrl.replace(/\/+$/, "");
+    warnIfInsecureUrl(resolved);
+    return resolved;
+  }
+  if (credentials?.apiUrl) {
+    const base = credentials.apiUrl.replace(/\/+$/, "");
+    if (base.includes("/api/v1/admin")) return base;
+    if (base.includes("localhost") || base.includes("127.0.0.1") || base.includes("[::1]")) {
+      return "http://localhost:3003/api/v1/admin";
+    }
+    throw new Error(
+      `SPACELR_API_URL is required for production. The CLI credentials point to ${base} (public gateway), but the admin gateway runs on a separate host. Set SPACELR_API_URL to the admin gateway URL (e.g. https://api-console.spacelr.com/api/v1/admin).`
+    );
+  }
+  const defaultUrl = "http://localhost:3003/api/v1/admin";
+  console.error(`Warning: No API URL configured, using default: ${defaultUrl}`);
+  return defaultUrl;
+}
+async function loadConfig() {
+  const credentials = readStoredCredentials();
+  const authToken = await resolveAuthToken();
+  if (!authToken) {
+    throw new Error(
+      'No auth token found. Either set SPACELR_AUTH_TOKEN or run "spacelr login" first.'
+    );
+  }
+  return {
+    apiBaseUrl: resolveApiUrl(credentials),
+    authToken,
+    clientId: process.env["SPACELR_CLIENT_ID"],
+    projectId: process.env["SPACELR_PROJECT_ID"]
+  };
+}
+
+// libs/mcp-server/src/api-client.ts
+var REQUEST_TIMEOUT_MS = 3e4;
+var ApiError = class extends Error {
+  constructor(status, statusText, responseBody) {
+    const truncated = responseBody.length > 500 ? responseBody.slice(0, 500) + "..." : responseBody;
+    super(`HTTP ${status} ${statusText}: ${truncated}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.name = "ApiError";
+  }
+};
+var ApiClient = class {
+  constructor(config) {
+    this.refreshPromise = null;
+    this.baseUrl = config.apiBaseUrl;
+    this.headers = {
+      Authorization: `Bearer ${config.authToken}`
+    };
+    if (config.clientId) {
+      this.headers["x-client-id"] = config.clientId;
+    }
+    if (config.projectId) {
+      this.headers["x-project-id"] = config.projectId;
+    }
+  }
+  async get(path2, opts) {
+    return this.requestWithRetry("GET", path2, opts);
+  }
+  async post(path2, opts) {
+    return this.requestWithRetry("POST", path2, opts);
+  }
+  async patch(path2, opts) {
+    return this.requestWithRetry("PATCH", path2, opts);
+  }
+  async put(path2, opts) {
+    return this.requestWithRetry("PUT", path2, opts);
+  }
+  async delete(path2, opts) {
+    return this.requestWithRetry("DELETE", path2, opts);
+  }
+  async refreshAuthToken() {
+    if (!this.refreshPromise) {
+      this.refreshPromise = resolveAuthToken().finally(() => {
+        this.refreshPromise = null;
+      });
+    }
+    return this.refreshPromise;
+  }
+  async requestWithRetry(method, path2, opts) {
+    try {
+      return await this.request(method, path2, opts);
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 401) {
+        const currentToken = this.headers["Authorization"];
+        const newToken = await this.refreshAuthToken();
+        if (newToken && `Bearer ${newToken}` !== currentToken) {
+          this.headers["Authorization"] = `Bearer ${newToken}`;
+          return this.request(method, path2, opts);
+        }
+      }
+      throw error;
+    }
+  }
+  async request(method, path2, opts) {
+    let url = `${this.baseUrl}${path2}`;
+    if (opts?.params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(opts.params)) {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      }
+      const qs = searchParams.toString();
+      if (qs) {
+        url += `?${qs}`;
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      const headers = { ...this.headers };
+      if (opts?.body !== void 0) {
+        headers["Content-Type"] = "application/json";
+      }
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+        signal: controller.signal
+      });
+      const text = await response.text();
+      if (!response.ok) {
+        throw new ApiError(response.status, response.statusText, text);
+      }
+      if (!text) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// libs/mcp-server/src/tools/auth.ts
+import { z } from "zod";
+
+// libs/mcp-server/src/utils.ts
+var TOKEN_KEYS = /* @__PURE__ */ new Set([
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "accessToken",
+  "refreshToken",
+  "idToken"
+]);
+function redactTokens(data) {
+  if (typeof data !== "object" || data === null) return data;
+  if (Array.isArray(data)) return data.map(redactTokens);
+  const record = data;
+  const redacted = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (TOKEN_KEYS.has(key)) {
+      redacted[key] = "[REDACTED]";
+    } else {
+      redacted[key] = redactTokens(value);
+    }
+  }
+  return redacted;
+}
+function redactSecrets(data) {
+  if (typeof data !== "object" || data === null) return data;
+  if (Array.isArray(data)) return data.map(redactSecrets);
+  const record = data;
+  const redacted = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "clientSecret" || key === "secret") {
+      redacted[key] = "[REDACTED]";
+    } else {
+      redacted[key] = redactSecrets(value);
+    }
+  }
+  return redacted;
+}
+
+// libs/mcp-server/src/tools/auth.ts
+function registerAuthTools(server, api) {
+  server.registerTool(
+    "auth_login",
+    {
+      description: "Authenticate with email and password. WARNING: The password will be visible in the conversation context. Token values are redacted in the response.",
+      inputSchema: {
+        email: z.string().email(),
+        password: z.string().min(1)
+      }
+    },
+    async ({ email, password }) => {
+      try {
+        const result = await api.post("/auth/login", {
+          body: { email, password }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactTokens(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Login failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "auth_me",
+    {
+      description: "Get the currently authenticated user profile"
+    },
+    async () => {
+      try {
+        const result = await api.get("/auth/me");
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactTokens(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get profile: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "auth_update_profile",
+    {
+      description: "Update the currently authenticated user profile",
+      inputSchema: {
+        firstName: z.string().optional(),
+        lastName: z.string().optional(),
+        displayName: z.string().optional()
+      }
+    },
+    async ({ firstName, lastName, displayName }) => {
+      try {
+        const body = {};
+        if (firstName !== void 0) body.firstName = firstName;
+        if (lastName !== void 0) body.lastName = lastName;
+        if (displayName !== void 0) body.displayName = displayName;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch("/auth/me", { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactTokens(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Profile update failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/projects.ts
+import { z as z2 } from "zod";
+function registerProjectTools(server, api) {
+  server.registerTool(
+    "projects_list",
+    {
+      description: "List all projects, optionally filtered by role",
+      inputSchema: {
+        role: z2.string().optional()
+      }
+    },
+    async ({ role }) => {
+      try {
+        const result = await api.get("/projects", {
+          params: { role }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list projects: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_get",
+    {
+      description: "Get a project by its ID",
+      inputSchema: {
+        projectId: z2.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get project: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_get_by_slug",
+    {
+      description: "Get a project by its slug",
+      inputSchema: {
+        slug: z2.string()
+      }
+    },
+    async ({ slug }) => {
+      try {
+        const result = await api.get(`/projects/slug/${encodeURIComponent(slug)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get project by slug: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_create",
+    {
+      description: "Create a new project",
+      inputSchema: {
+        name: z2.string(),
+        slug: z2.string(),
+        description: z2.string().optional(),
+        logoUrl: z2.string().url().optional(),
+        websiteUrl: z2.string().url().optional()
+      }
+    },
+    async ({ name, slug, description, logoUrl, websiteUrl }) => {
+      try {
+        const body = { name, slug };
+        if (description !== void 0) body.description = description;
+        if (logoUrl !== void 0) body.logoUrl = logoUrl;
+        if (websiteUrl !== void 0) body.websiteUrl = websiteUrl;
+        const result = await api.post("/projects", { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create project: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_update",
+    {
+      description: "Update an existing project",
+      inputSchema: {
+        projectId: z2.string(),
+        name: z2.string().optional(),
+        description: z2.string().optional(),
+        logoUrl: z2.string().url().optional(),
+        websiteUrl: z2.string().url().optional()
+      }
+    },
+    async ({ projectId, name, description, logoUrl, websiteUrl }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (description !== void 0) body.description = description;
+        if (logoUrl !== void 0) body.logoUrl = logoUrl;
+        if (websiteUrl !== void 0) body.websiteUrl = websiteUrl;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/projects/${encodeURIComponent(projectId)}`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update project: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_delete",
+    {
+      description: "Delete a project by its ID",
+      inputSchema: {
+        projectId: z2.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.delete(`/projects/${encodeURIComponent(projectId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Project deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete project: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_members_list",
+    {
+      description: "List members of a project with optional pagination",
+      inputSchema: {
+        projectId: z2.string(),
+        limit: z2.number().int().min(1).max(100).optional(),
+        offset: z2.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, limit, offset }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/members`, {
+          params: { limit, offset }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list members: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_members_add",
+    {
+      description: "Add a member to a project by email with a specified role",
+      inputSchema: {
+        projectId: z2.string(),
+        email: z2.string().email(),
+        role: z2.enum(["owner", "admin", "developer", "member", "viewer"]),
+        permissions: z2.array(z2.string()).optional()
+      }
+    },
+    async ({ projectId, email, role, permissions }) => {
+      try {
+        const body = { email, role };
+        if (permissions !== void 0) body.permissions = permissions;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/members`, {
+          body
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to add member: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_members_update",
+    {
+      description: "Update a project member's role, permissions, or console access",
+      inputSchema: {
+        projectId: z2.string(),
+        memberId: z2.string(),
+        role: z2.enum(["owner", "admin", "developer", "member", "viewer"]).optional(),
+        permissions: z2.array(z2.string()).optional(),
+        grantConsoleAccess: z2.boolean().optional()
+      }
+    },
+    async ({ projectId, memberId, role, permissions, grantConsoleAccess }) => {
+      try {
+        const body = {};
+        if (role !== void 0) body.role = role;
+        if (permissions !== void 0) body.permissions = permissions;
+        if (grantConsoleAccess !== void 0) body.grantConsoleAccess = grantConsoleAccess;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/projects/${encodeURIComponent(projectId)}/members/${encodeURIComponent(memberId)}`, {
+          body
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update member: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_members_remove",
+    {
+      description: "Remove a member from a project",
+      inputSchema: {
+        projectId: z2.string(),
+        memberId: z2.string()
+      }
+    },
+    async ({ projectId, memberId }) => {
+      try {
+        const result = await api.delete(`/projects/${encodeURIComponent(projectId)}/members/${encodeURIComponent(memberId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Member removed", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to remove member: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_users_create",
+    {
+      description: "Create a new user within a project. WARNING: The password will be visible in the conversation context.",
+      inputSchema: {
+        projectId: z2.string(),
+        username: z2.string(),
+        email: z2.string().email(),
+        password: z2.string().min(1),
+        role: z2.enum(["owner", "admin", "developer", "member", "viewer"]),
+        firstName: z2.string().optional(),
+        lastName: z2.string().optional(),
+        displayName: z2.string().optional(),
+        permissions: z2.array(z2.string()).optional(),
+        grantConsoleAccess: z2.boolean().optional()
+      }
+    },
+    async ({ projectId, username, email, password, role, firstName, lastName, displayName, permissions, grantConsoleAccess }) => {
+      try {
+        const body = { username, email, password, role };
+        if (firstName !== void 0) body.firstName = firstName;
+        if (lastName !== void 0) body.lastName = lastName;
+        if (displayName !== void 0) body.displayName = displayName;
+        if (permissions !== void 0) body.permissions = permissions;
+        if (grantConsoleAccess !== void 0) body.grantConsoleAccess = grantConsoleAccess;
+        const result = await api.post(`/projects/${encodeURIComponent(projectId)}/users`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create user: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "projects_role",
+    {
+      description: "Get the current user's role in a project",
+      inputSchema: {
+        projectId: z2.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/projects/${encodeURIComponent(projectId)}/role`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get role: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/clients.ts
+import { z as z3 } from "zod";
+function registerClientTools(server, api) {
+  server.registerTool(
+    "clients_list",
+    {
+      description: "List all OAuth clients for a project",
+      inputSchema: {
+        projectId: z3.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/clients/project/${encodeURIComponent(projectId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactSecrets(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list clients: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "clients_get",
+    {
+      description: "Get details of a specific OAuth client",
+      inputSchema: {
+        clientId: z3.string()
+      }
+    },
+    async ({ clientId }) => {
+      try {
+        const result = await api.get(`/clients/${encodeURIComponent(clientId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactSecrets(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get client: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "clients_create",
+    {
+      description: "Create a new OAuth client for a project",
+      inputSchema: {
+        projectId: z3.string(),
+        name: z3.string(),
+        grantTypes: z3.array(z3.string()),
+        redirectUris: z3.array(z3.string().url()).optional(),
+        scopes: z3.array(z3.string()).optional(),
+        isConfidential: z3.boolean().optional(),
+        corsOrigins: z3.array(z3.string()).optional(),
+        accessTokenTtl: z3.number().optional()
+      }
+    },
+    async ({ projectId, name, grantTypes, redirectUris, scopes, isConfidential, corsOrigins, accessTokenTtl }) => {
+      try {
+        const body = { projectId, name, grantTypes };
+        if (redirectUris !== void 0) body.redirectUris = redirectUris;
+        if (scopes !== void 0) body.scopes = scopes;
+        if (isConfidential !== void 0) body.isConfidential = isConfidential;
+        if (corsOrigins !== void 0) body.corsOrigins = corsOrigins;
+        if (accessTokenTtl !== void 0) body.accessTokenTtl = accessTokenTtl;
+        const result = await api.post("/clients", { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactSecrets(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create client: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "clients_update",
+    {
+      description: "Update an existing OAuth client",
+      inputSchema: {
+        clientId: z3.string(),
+        name: z3.string().optional(),
+        redirectUris: z3.array(z3.string().url()).optional(),
+        scopes: z3.array(z3.string()).optional(),
+        grantTypes: z3.array(z3.string()).optional(),
+        isActive: z3.boolean().optional(),
+        corsOrigins: z3.array(z3.string()).optional(),
+        accessTokenTtl: z3.number().optional()
+      }
+    },
+    async ({ clientId, name, redirectUris, scopes, grantTypes, isActive, corsOrigins, accessTokenTtl }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (redirectUris !== void 0) body.redirectUris = redirectUris;
+        if (scopes !== void 0) body.scopes = scopes;
+        if (grantTypes !== void 0) body.grantTypes = grantTypes;
+        if (isActive !== void 0) body.isActive = isActive;
+        if (corsOrigins !== void 0) body.corsOrigins = corsOrigins;
+        if (accessTokenTtl !== void 0) body.accessTokenTtl = accessTokenTtl;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/clients/${encodeURIComponent(clientId)}`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(redactSecrets(result), null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update client: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "clients_delete",
+    {
+      description: "Delete an OAuth client",
+      inputSchema: {
+        clientId: z3.string()
+      }
+    },
+    async ({ clientId }) => {
+      try {
+        const result = await api.delete(`/clients/${encodeURIComponent(clientId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Client deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete client: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "clients_regenerate_secret",
+    {
+      description: "Regenerate the secret for an OAuth client. WARNING: The new secret will be visible in the conversation context. This is the only time the secret can be retrieved.",
+      inputSchema: {
+        clientId: z3.string()
+      }
+    },
+    async ({ clientId }) => {
+      try {
+        const result = await api.post(`/clients/${encodeURIComponent(clientId)}/regenerate-secret`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to regenerate client secret: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/database.ts
+import { z as z4 } from "zod";
+function registerDatabaseTools(server, api) {
+  server.registerTool(
+    "database_collections_list",
+    {
+      description: "List all collections in a project database",
+      inputSchema: {
+        projectId: z4.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/databases/${encodeURIComponent(projectId)}/collections`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list collections: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_collections_create",
+    {
+      description: "Create a new collection in a project database",
+      inputSchema: {
+        projectId: z4.string(),
+        name: z4.string(),
+        description: z4.string().optional()
+      }
+    },
+    async ({ projectId, name, description }) => {
+      try {
+        const body = { name };
+        if (description !== void 0) body.description = description;
+        const result = await api.post(`/databases/${encodeURIComponent(projectId)}/collections`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create collection: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_collections_delete",
+    {
+      description: "Delete a collection from a project database",
+      inputSchema: {
+        projectId: z4.string(),
+        name: z4.string()
+      }
+    },
+    async ({ projectId, name }) => {
+      try {
+        const result = await api.delete(`/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(name)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Collection deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete collection: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_rules_get",
+    {
+      description: "Get the security rules for a project database",
+      inputSchema: {
+        projectId: z4.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/databases/${encodeURIComponent(projectId)}/rules`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get rules: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_rules_set",
+    {
+      description: "Set security rules for a project database",
+      inputSchema: {
+        projectId: z4.string(),
+        rules: z4.record(z4.string(), z4.unknown()),
+        expectedVersion: z4.number().optional()
+      }
+    },
+    async ({ projectId, rules, expectedVersion }) => {
+      try {
+        const body = { rules };
+        if (expectedVersion !== void 0) body.expectedVersion = expectedVersion;
+        const result = await api.put(`/databases/${encodeURIComponent(projectId)}/rules`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to set rules: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_rules_validate",
+    {
+      description: "Validate security rules without applying them",
+      inputSchema: {
+        projectId: z4.string(),
+        rules: z4.record(z4.string(), z4.unknown())
+      }
+    },
+    async ({ projectId, rules }) => {
+      try {
+        const result = await api.post(`/databases/${encodeURIComponent(projectId)}/rules/validate`, {
+          body: { rules }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to validate rules: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_index_rules_get",
+    {
+      description: "Get the index rules for a project database",
+      inputSchema: {
+        projectId: z4.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/databases/${encodeURIComponent(projectId)}/index-rules`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get index rules: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_index_rules_sync",
+    {
+      description: "Sync index rules for a project database",
+      inputSchema: {
+        projectId: z4.string(),
+        indexRules: z4.record(z4.string(), z4.unknown())
+      }
+    },
+    async ({ projectId, indexRules }) => {
+      try {
+        const result = await api.put(`/databases/${encodeURIComponent(projectId)}/index-rules`, {
+          body: { indexRules }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to sync index rules: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_indexes_list",
+    {
+      description: "List all indexes for a collection",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string()
+      }
+    },
+    async ({ projectId, collectionName }) => {
+      try {
+        const result = await api.get(`/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/indexes`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list indexes: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_indexes_create",
+    {
+      description: "Create a new index on a collection",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string(),
+        fields: z4.record(z4.string(), z4.union([z4.literal(1), z4.literal(-1), z4.literal("text")])),
+        unique: z4.boolean().optional(),
+        sparse: z4.boolean().optional(),
+        ttlSeconds: z4.number().optional()
+      }
+    },
+    async ({ projectId, collectionName, fields, unique, sparse, ttlSeconds }) => {
+      try {
+        const body = { fields };
+        if (unique !== void 0) body.unique = unique;
+        if (sparse !== void 0) body.sparse = sparse;
+        if (ttlSeconds !== void 0) body.ttlSeconds = ttlSeconds;
+        const result = await api.post(`/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/indexes`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create index: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_indexes_delete",
+    {
+      description: "Delete an index from a collection",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string(),
+        indexName: z4.string()
+      }
+    },
+    async ({ projectId, collectionName, indexName }) => {
+      try {
+        const result = await api.delete(
+          `/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/indexes/${encodeURIComponent(indexName)}`
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Index deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete index: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_documents_find",
+    {
+      description: "Query documents in a collection with optional filter, sort, field projection, limit (max 100), and offset",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string(),
+        filter: z4.record(z4.string(), z4.unknown()).optional(),
+        sort: z4.record(z4.string(), z4.union([z4.literal(1), z4.literal(-1)])).optional(),
+        fields: z4.array(z4.string()).optional(),
+        limit: z4.number().int().min(1).max(100).optional(),
+        offset: z4.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, collectionName, filter, sort, fields, limit, offset }) => {
+      try {
+        const params = {};
+        if (filter !== void 0) params.filter = JSON.stringify(filter);
+        if (sort !== void 0) params.sort = JSON.stringify(sort);
+        if (fields !== void 0) params.fields = JSON.stringify(fields);
+        if (limit !== void 0) params.limit = limit;
+        if (offset !== void 0) params.offset = offset;
+        const result = await api.get(
+          `/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/documents`,
+          { params }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to find documents: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_documents_insert",
+    {
+      description: "Insert one or more documents into a collection",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string(),
+        documents: z4.array(z4.record(z4.string(), z4.unknown())).min(1).max(500)
+      }
+    },
+    async ({ projectId, collectionName, documents }) => {
+      try {
+        const result = await api.post(
+          `/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/documents`,
+          { body: { documents } }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to insert documents: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_documents_update",
+    {
+      description: "Update a specific document in a collection",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string(),
+        docId: z4.string(),
+        update: z4.record(z4.string(), z4.unknown())
+      }
+    },
+    async ({ projectId, collectionName, docId, update }) => {
+      try {
+        const result = await api.patch(
+          `/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/documents/${encodeURIComponent(docId)}`,
+          { body: { update } }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update document: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_documents_delete",
+    {
+      description: "Delete a specific document from a collection",
+      inputSchema: {
+        projectId: z4.string(),
+        collectionName: z4.string(),
+        docId: z4.string()
+      }
+    },
+    async ({ projectId, collectionName, docId }) => {
+      try {
+        const result = await api.delete(
+          `/databases/${encodeURIComponent(projectId)}/collections/${encodeURIComponent(collectionName)}/documents/${encodeURIComponent(docId)}`
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Document deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete document: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "database_stats",
+    {
+      description: "Get database statistics for a project",
+      inputSchema: {
+        projectId: z4.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/databases/${encodeURIComponent(projectId)}/stats`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get database stats: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/hosting.ts
+import { z as z5 } from "zod";
+function registerHostingTools(server, api) {
+  server.registerTool(
+    "hosting_deployments_list",
+    {
+      description: "List deployments for a hosting project",
+      inputSchema: {
+        projectId: z5.string(),
+        limit: z5.number().int().min(1).max(100).optional(),
+        offset: z5.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, limit, offset }) => {
+      try {
+        const result = await api.get(`/hosting/projects/${encodeURIComponent(projectId)}/deployments`, {
+          params: { limit, offset }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list deployments: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_deployments_get",
+    {
+      description: "Get details of a specific deployment",
+      inputSchema: {
+        projectId: z5.string(),
+        deploymentId: z5.string()
+      }
+    },
+    async ({ projectId, deploymentId }) => {
+      try {
+        const result = await api.get(`/hosting/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get deployment: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_deployments_create",
+    {
+      description: "Create a new deployment for a hosting project",
+      inputSchema: {
+        projectId: z5.string(),
+        description: z5.string().optional(),
+        framework: z5.string().optional()
+      }
+    },
+    async ({ projectId, description, framework }) => {
+      try {
+        const body = { projectId };
+        if (description !== void 0) body.description = description;
+        if (framework !== void 0) body.framework = framework;
+        const result = await api.post("/hosting/deployments", { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to create deployment: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_deployments_activate",
+    {
+      description: "Activate a specific deployment",
+      inputSchema: {
+        projectId: z5.string(),
+        deploymentId: z5.string()
+      }
+    },
+    async ({ projectId, deploymentId }) => {
+      try {
+        const result = await api.post(`/hosting/deployments/${encodeURIComponent(deploymentId)}/activate`, {
+          body: { projectId }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to activate deployment: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_deployments_delete",
+    {
+      description: "Delete a specific deployment",
+      inputSchema: {
+        projectId: z5.string(),
+        deploymentId: z5.string()
+      }
+    },
+    async ({ projectId, deploymentId }) => {
+      try {
+        const result = await api.delete(`/hosting/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Deployment deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete deployment: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_deployments_status",
+    {
+      description: "Get the status of a specific deployment",
+      inputSchema: {
+        projectId: z5.string(),
+        deploymentId: z5.string()
+      }
+    },
+    async ({ projectId, deploymentId }) => {
+      try {
+        const result = await api.get(`/hosting/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}/status`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get deployment status: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_config_get",
+    {
+      description: "Get hosting configuration for a project",
+      inputSchema: {
+        projectId: z5.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/hosting/projects/${encodeURIComponent(projectId)}/config`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get hosting config: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_config_update",
+    {
+      description: "Update hosting configuration for a project",
+      inputSchema: {
+        projectId: z5.string(),
+        spaMode: z5.boolean().optional(),
+        defaultFile: z5.string().optional(),
+        headers: z5.record(z5.string(), z5.string()).optional(),
+        enabled: z5.boolean().optional()
+      }
+    },
+    async ({ projectId, spaMode, defaultFile, headers, enabled }) => {
+      try {
+        const body = {};
+        if (spaMode !== void 0) body.spaMode = spaMode;
+        if (defaultFile !== void 0) body.defaultFile = defaultFile;
+        if (headers !== void 0) body.headers = headers;
+        if (enabled !== void 0) body.enabled = enabled;
+        if (Object.keys(body).length === 0) {
+          return {
+            content: [{ type: "text", text: "At least one config field must be provided" }],
+            isError: true
+          };
+        }
+        const result = await api.patch(`/hosting/projects/${encodeURIComponent(projectId)}/config`, {
+          body
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update hosting config: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_domains_list",
+    {
+      description: "List custom domains for a hosting project",
+      inputSchema: {
+        projectId: z5.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get(`/hosting/projects/${encodeURIComponent(projectId)}/domains`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list domains: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_domains_get",
+    {
+      description: "Get details of a specific custom domain",
+      inputSchema: {
+        projectId: z5.string(),
+        domain: z5.string()
+      }
+    },
+    async ({ projectId, domain }) => {
+      try {
+        const result = await api.get(`/hosting/projects/${encodeURIComponent(projectId)}/domains/${encodeURIComponent(domain)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get domain: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_domains_add",
+    {
+      description: "Add a custom domain to a hosting project",
+      inputSchema: {
+        projectId: z5.string(),
+        domain: z5.string(),
+        projectSlug: z5.string(),
+        verificationMethod: z5.enum(["cname", "txt"]).optional()
+      }
+    },
+    async ({ projectId, domain, projectSlug, verificationMethod }) => {
+      try {
+        const body = { domain, projectSlug };
+        if (verificationMethod !== void 0) body.verificationMethod = verificationMethod;
+        const result = await api.post(`/hosting/projects/${encodeURIComponent(projectId)}/domains`, { body });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to add domain: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_domains_verify",
+    {
+      description: "Verify a custom domain for a hosting project",
+      inputSchema: {
+        projectId: z5.string(),
+        domain: z5.string()
+      }
+    },
+    async ({ projectId, domain }) => {
+      try {
+        const result = await api.post(`/hosting/projects/${encodeURIComponent(projectId)}/domains/${encodeURIComponent(domain)}/verify`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to verify domain: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_domains_remove",
+    {
+      description: "Remove a custom domain from a hosting project",
+      inputSchema: {
+        projectId: z5.string(),
+        domain: z5.string()
+      }
+    },
+    async ({ projectId, domain }) => {
+      try {
+        const result = await api.delete(`/hosting/projects/${encodeURIComponent(projectId)}/domains/${encodeURIComponent(domain)}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "Domain removed", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to remove domain: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "hosting_domains_set_primary",
+    {
+      description: "Set a custom domain as the primary domain for a hosting project",
+      inputSchema: {
+        projectId: z5.string(),
+        domain: z5.string()
+      }
+    },
+    async ({ projectId, domain }) => {
+      try {
+        const result = await api.patch(`/hosting/projects/${encodeURIComponent(projectId)}/domains/${encodeURIComponent(domain)}/primary`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to set primary domain: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/storage.ts
+import { z as z6 } from "zod";
+function registerStorageTools(server, api) {
+  server.registerTool(
+    "storage_files_list",
+    {
+      description: "List files in storage for a project and user",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string(),
+        limit: z6.number().int().min(1).max(100).optional(),
+        offset: z6.number().int().min(0).optional()
+      }
+    },
+    async ({ projectId, userId, limit, offset }) => {
+      try {
+        const result = await api.get("/storage/files", {
+          params: { projectId, userId, limit, offset }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to list files: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_files_get",
+    {
+      description: "Get details of a specific file in storage",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string(),
+        fileId: z6.string()
+      }
+    },
+    async ({ projectId, userId, fileId }) => {
+      try {
+        const result = await api.get(`/storage/files/${encodeURIComponent(fileId)}`, {
+          params: { projectId, userId }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get file: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_files_delete",
+    {
+      description: "Delete a specific file from storage",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string(),
+        fileId: z6.string()
+      }
+    },
+    async ({ projectId, userId, fileId }) => {
+      try {
+        const result = await api.delete(`/storage/files/${encodeURIComponent(fileId)}`, {
+          params: { projectId, userId }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result ?? "File deleted", null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to delete file: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_files_visibility",
+    {
+      description: "Update the visibility of a specific file",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string(),
+        fileId: z6.string(),
+        visibility: z6.enum(["public", "private"])
+      }
+    },
+    async ({ projectId, userId, fileId, visibility }) => {
+      try {
+        const result = await api.patch(`/storage/files/${encodeURIComponent(fileId)}/visibility`, {
+          params: { projectId, userId },
+          body: { visibility }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to update file visibility: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_files_share",
+    {
+      description: "Share a file with other users",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string(),
+        fileId: z6.string(),
+        userIds: z6.array(z6.string()),
+        permission: z6.enum(["read", "write"]).optional()
+      }
+    },
+    async ({ projectId, userId, fileId, userIds, permission }) => {
+      try {
+        const result = await api.post(`/storage/files/${encodeURIComponent(fileId)}/share`, {
+          params: { projectId, userId },
+          body: { userIds, permission }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to share file: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_files_unshare",
+    {
+      description: "Remove file sharing for specific users",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string(),
+        fileId: z6.string(),
+        userIds: z6.array(z6.string())
+      }
+    },
+    async ({ projectId, userId, fileId, userIds }) => {
+      try {
+        const result = await api.post(`/storage/files/${encodeURIComponent(fileId)}/unshare`, {
+          params: { projectId, userId },
+          body: { userIds }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to unshare file: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_quota_get",
+    {
+      description: "Get storage quota information for a user in a project",
+      inputSchema: {
+        projectId: z6.string(),
+        userId: z6.string()
+      }
+    },
+    async ({ projectId, userId }) => {
+      try {
+        const result = await api.get("/storage/quota", {
+          params: { projectId, userId }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get quota: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_quota_set",
+    {
+      description: "Set storage quota for a user in a project",
+      inputSchema: {
+        projectId: z6.string(),
+        targetUserId: z6.string(),
+        quotaBytes: z6.number().int().min(0)
+      }
+    },
+    async ({ projectId, targetUserId, quotaBytes }) => {
+      try {
+        const result = await api.put("/storage/quota", {
+          body: { projectId, targetUserId, quotaBytes }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to set quota: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.registerTool(
+    "storage_project_stats",
+    {
+      description: "Get storage statistics for a project",
+      inputSchema: {
+        projectId: z6.string()
+      }
+    },
+    async ({ projectId }) => {
+      try {
+        const result = await api.get("/storage/project-stats", {
+          params: { projectId }
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to get project stats: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// libs/mcp-server/src/tools/index.ts
+function registerAllTools(server, api) {
+  registerAuthTools(server, api);
+  registerProjectTools(server, api);
+  registerClientTools(server, api);
+  registerDatabaseTools(server, api);
+  registerHostingTools(server, api);
+  registerStorageTools(server, api);
+}
+
+// libs/mcp-server/src/index.ts
+async function main() {
+  const config = await loadConfig();
+  const api = new ApiClient(config);
+  const server = new McpServer({
+    name: "spacelr",
+    version: "0.1.0"
+  });
+  registerAllTools(server, api);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = async () => {
+    console.error("Shutting down MCP server...");
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGPIPE", shutdown);
+  console.error("Spacelr MCP server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.mjs.map