@symbo.ls/mcp-server 3.7.0 → 3.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/mcp-server",
-  "version": "3.7.0",
+  "version": "3.7.4",
   "description": "HTTP proxy for the Symbols MCP server — runs as a Cloudflare Worker",
   "type": "module",
   "main": "index.js",

package/src/mcp-handler.js

@@ -212,6 +212,104 @@ const TOOLS = [
       required: ['component_code'],
     },
   },
+  {
+    name: 'login',
+    description:
+      'Log in to the Symbols platform with email and password. Returns a JWT token for use with publish and push tools.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: {
+          type: 'string',
+          description: 'Symbols account email address',
+        },
+        password: {
+          type: 'string',
+          description: 'Symbols account password',
+        },
+      },
+      required: ['email', 'password'],
+    },
+  },
+  {
+    name: 'publish',
+    description:
+      'Publish a version of a Symbols project to the platform. Requires authentication via token or api_key.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: {
+          type: 'string',
+          description: 'Project ID (MongoDB ObjectId) or project key (pr_xxxx)',
+        },
+        token: {
+          type: 'string',
+          description: 'JWT access token from login or ~/.smblsrc',
+        },
+        api_key: {
+          type: 'string',
+          description:
+            'API key (sk_live_...) from project integration settings. Alternative to token.',
+        },
+        version: {
+          type: 'string',
+          description: 'Version string or version ID to publish. Leave empty for latest.',
+          default: '',
+        },
+        branch: {
+          type: 'string',
+          description: 'Branch to publish from',
+          default: 'main',
+        },
+      },
+      required: ['project'],
+    },
+  },
+  {
+    name: 'push',
+    description:
+      'Push/deploy a Symbols project to a specific environment. Requires authentication via token or api_key.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: {
+          type: 'string',
+          description: 'Project ID (MongoDB ObjectId) or project key (pr_xxxx)',
+        },
+        token: {
+          type: 'string',
+          description: 'JWT access token from login or ~/.smblsrc',
+        },
+        api_key: {
+          type: 'string',
+          description:
+            'API key (sk_live_...) from project integration settings. Alternative to token.',
+        },
+        environment: {
+          type: 'string',
+          description: 'Target environment key (e.g. "production", "staging", "dev")',
+          default: 'production',
+        },
+        mode: {
+          type: 'string',
+          description:
+            'Deploy mode — "latest" (newest from branch), "published" (current published version), "version" (specific version), or "branch" (track a branch)',
+          default: 'published',
+        },
+        version: {
+          type: 'string',
+          description: 'Required when mode is "version" — the version string or ID to deploy',
+          default: '',
+        },
+        branch: {
+          type: 'string',
+          description: 'Branch to deploy from when mode is "latest" or "branch"',
+          default: 'main',
+        },
+      },
+      required: ['project'],
+    },
+  },
   {
     name: 'detect_environment',
     description:
@@ -259,7 +357,42 @@ const TOOLS = [
   },
 ];
 
-function callTool(name, args = {}) {
+const API_BASE = 'https://api.symbols.app';
+
+const AUTH_HELP = `To authenticate, provide one of:
+- **token**: JWT from \`smbls login\` (stored in ~/.smblsrc) or env var SYMBOLS_TOKEN
+- **api_key**: API key (sk_live_...) from your project's integration settings
+
+To get a token:
+1. Run \`smbls login\` in your terminal, or
+2. Use the \`login\` tool with your email and password
+
+Your project can be identified by either:
+- **project**: MongoDB ObjectId (from project settings or symbols.json)
+- **project**: Project key (pr_xxxx, found in symbols.json or project URL)`;
+
+function authHeader(token, apiKey) {
+  if (apiKey) return { 'Authorization': `ApiKey ${apiKey}`, 'Content-Type': 'application/json' };
+  if (token) return { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
+  return null;
+}
+
+async function apiRequest(method, path, { token, api_key, body } = {}) {
+  const headers = authHeader(token, api_key);
+  if (!headers) return { success: false, error: 'No credentials provided', message: AUTH_HELP };
+  const resp = await fetch(`${API_BASE}${path}`, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  try {
+    return await resp.json();
+  } catch {
+    return { success: false, error: `HTTP ${resp.status}`, message: await resp.text() };
+  }
+}
+
+async function callTool(name, args = {}) {
   if (name === 'get_project_rules') {
     return readSkill('RULES.md');
   }
@@ -376,6 +509,70 @@ function callTool(name, args = {}) {
     return output;
   }
 
+  if (name === 'login') {
+    const { email, password } = args;
+    if (!email || !password) return 'Error: email and password are required.';
+    const resp = await fetch(`${API_BASE}/core/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+    let result;
+    try {
+      result = await resp.json();
+    } catch {
+      return `Login failed: HTTP ${resp.status}`;
+    }
+    if (result.success) {
+      const data = result.data || {};
+      const tokens = data.tokens || {};
+      const user = data.user || {};
+      return `Logged in as ${user.name || user.email || 'unknown'}.\nToken: ${tokens.accessToken || ''}\nExpires: ${(tokens.accessTokenExp || {}).expiresAt || 'unknown'}\n\nUse this token with the \`publish\` and \`push\` tools.`;
+    }
+    return `Login failed: ${result.error || result.message || 'Unknown error'}`;
+  }
+
+  if (name === 'publish') {
+    const { project, token, api_key, version, branch = 'main' } = args;
+    if (!project) return 'Error: project (ID or key) is required.';
+    if (!token && !api_key) return `Authentication required.\n\n${AUTH_HELP}`;
+    const body = { branch };
+    if (version) body.version = version;
+    const result = await apiRequest('POST', `/${project}/publish`, { token, api_key, body });
+    if (result.success) {
+      const data = result.data || {};
+      return `Published successfully.\nVersion: ${data.value || data.id || 'unknown'}`;
+    }
+    return `Publish failed: ${result.error || 'Unknown error'}\n${result.message || ''}`;
+  }
+
+  if (name === 'push') {
+    const {
+      project,
+      token,
+      api_key,
+      environment = 'production',
+      mode = 'published',
+      version,
+      branch = 'main',
+    } = args;
+    if (!project) return 'Error: project (ID or key) is required.';
+    if (!token && !api_key) return `Authentication required.\n\n${AUTH_HELP}`;
+    const body = { mode, branch };
+    if (version) body.version = version;
+    const result = await apiRequest('POST', `/${project}/environments/${environment}/publish`, {
+      token,
+      api_key,
+      body,
+    });
+    if (result.success) {
+      const data = result.data || {};
+      const config = data.config || {};
+      return `Pushed to ${data.key || environment} successfully.\nMode: ${config.mode || mode}\nVersion: ${config.version || 'latest'}\nBranch: ${config.branch || branch}`;
+    }
+    return `Push failed: ${result.error || 'Unknown error'}\n${result.message || ''}`;
+  }
+
   if (name === 'detect_environment') {
     const {
       has_symbols_json,
@@ -590,7 +787,7 @@ const PROMPTS = [
 
 const SERVER_INFO = { name: 'Symbols MCP', version: '1.1.1' };
 
-export function handleJsonRpc(req) {
+export async function handleJsonRpc(req) {
   const { method, params, id } = req;
 
   if (method === 'initialize') {
@@ -615,7 +812,7 @@ export function handleJsonRpc(req) {
   if (method === 'tools/call') {
     const { name, arguments: args = {} } = params || {};
     try {
-      const text = callTool(name, args);
+      const text = await callTool(name, args);
       return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text }] } };
     } catch (e) {
       return {

package/src/worker-handler.js

@@ -66,14 +66,14 @@ function isNotificationOrResponse(msg) {
   return false;
 }
 
-function handleMcpPost(request, body) {
+async function handleMcpPost(request, body) {
   // Notifications and responses get 202 Accepted
   if (isNotificationOrResponse(body)) {
     return new Response(null, { status: 202, headers: CORS_HEADERS });
   }
 
   // Handle JSON-RPC request
-  const result = handleJsonRpc(body);
+  const result = await handleJsonRpc(body);
   if (result === null) {
     return new Response(null, { status: 202, headers: CORS_HEADERS });
   }
@@ -166,7 +166,7 @@ export async function handleRequest(request) {
       return json({ error: 'Invalid JSON body' }, 400);
     }
     try {
-      const result = callTool(toolName, args);
+      const result = await callTool(toolName, args);
       return json({ content: [{ type: 'text', text: result }] });
     } catch (e) {
       return json({ error: e.message }, 404);