@werewolf-solutions/dev 0.0.0-stage → 0.1.1

package/werewolf-mcp.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * Werewolf Solutions MCP server. Two kinds of key, two tool sets:
+ *
+ * - WEREWOLF_DEV_TOKEN, a developer's runner token: the website runner tools
+ *   (src/mcpRunner.js). Your harness builds the drafts for the businesses assigned to you.
+ * - WEREWOLF_API_KEY, a business secret key: the site-builder tools below. The client LLM
+ *   generates the website files itself and saves them as revisions; publishing swaps the
+ *   placeholder tokens for a real publishable key server-side.
+ *
+ * WEREWOLF_API_URL is the site or its API, e.g. https://staging.werewolf.solutions
+ * (default https://werewolf.solutions). `werewolf-dev mcp --api <site>` sets it too.
+ *
+ * Register with Claude Code:
+ *   claude mcp add werewolf --env WEREWOLF_DEV_TOKEN=ws_sk_... \
+ *     -- npx -y @werewolf-solutions/dev mcp --api https://staging.werewolf.solutions
+ */
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const require = createRequire(import.meta.url);
+const { apiBase } = require('./src/api.js');
+const { startRunnerMcp } = require('./src/mcpRunner.js');
+
+const API_URL = apiBase(process.env.WEREWOLF_API_URL || 'https://werewolf.solutions');
+const DEV_TOKEN = process.env.WEREWOLF_DEV_TOKEN;
+const PSM_READONLY = process.env.WEREWOLF_MCP_PROFILE === 'psm-readonly';
+
+// A runner token serves the runner tools and stops here. Any other key in WEREWOLF_DEV_TOKEN
+// (the server refuses it at the runner check-in) falls through to the business tools.
+let runnerMode = false;
+if (DEV_TOKEN) {
+  try {
+    runnerMode = await startRunnerMcp({ api: API_URL, token: DEV_TOKEN, McpServer, StdioServerTransport, z });
+  } catch (error) {
+    console.error(`[werewolf-dev mcp] could not sign in to ${API_URL}: ${error.response?.data?.message || error.message}`);
+    process.exit(1);
+  }
+  if (!runnerMode) console.error('[werewolf-dev mcp] WEREWOLF_DEV_TOKEN is not a website runner token; serving the business tools with it');
+}
+const API_KEY = process.env.WEREWOLF_API_KEY || DEV_TOKEN;
+
+if (!runnerMode && (!API_KEY || !API_KEY.startsWith('ws_sk_'))) {
+  console.error('Set WEREWOLF_DEV_TOKEN to your runner token, or WEREWOLF_API_KEY to a business secret key (ws_sk_...)');
+  process.exit(1);
+}
+
+const api = async (method, path, body) => {
+  const res = await fetch(`${API_URL}${path}`, {
+    method,
+    headers: {
+      'X-API-Key': API_KEY,
+      'Content-Type': 'application/json',
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || data.success === false) {
+    throw new Error(data.message || `${method} ${path} failed (${res.status})`);
+  }
+  return data.data ?? data;
+};
+
+// The key is business-scoped; resolve its business once.
+let businessCache = null;
+const getBusiness = async () => {
+  if (!businessCache) {
+    const data = await api('GET', '/businesses/client');
+    businessCache = data.business;
+  }
+  return businessCache;
+};
+
+const text = (value) => ({
+  content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }],
+});
+
+const server = new McpServer({ name: 'werewolf', version: '1.0.0' });
+
+server.tool(
+  'get_psm_service_status',
+  'Read the paid PSM cloud service readiness for the business behind this key: Stripe Connect onboarding, recurring price configuration, object-storage readiness, and aggregate non-PII usage. Use this to validate the integration; it never changes billing or customer data.',
+  {},
+  async () => text(await api('GET', '/apps/psm/service-status'))
+);
+
+if (!PSM_READONLY) {
+server.tool(
+  'get_business',
+  'Get the business this API key belongs to: name, description, branding, services, contact details, brand profile. Use this as the authoritative content source when generating a website.',
+  {},
+  async () => text(await getBusiness())
+);
+
+
+server.tool(
+  'list_projects',
+  'List the website-builder projects for this business, including status and published URL.',
+  {},
+  async () => {
+    const business = await getBusiness();
+    const data = await api('GET', `/businesses/${business._id}/builder/projects`);
+    return text(
+      data.projects.map((p) => ({
+        id: p._id,
+        name: p.name,
+        status: p.status,
+        publishedUrl: p.publishedUrl,
+        sourceUrl: p.sourceUrl,
+        updatedAt: p.updatedAt,
+      }))
+    );
+  }
+);
+
+server.tool(
+  'create_project',
+  'Create a new website project for the business. Optionally pass sourceUrl (an existing website to import content from) and a prompt. The platform generates a first revision server-side; you can replace it with save_revision.',
+  {
+    name: z.string().optional().describe('Project name'),
+    prompt: z.string().optional().describe('Style/content instructions'),
+    sourceUrl: z.string().optional().describe("URL of the business's existing website to import content from"),
+  },
+  async ({ name, prompt, sourceUrl }) => {
+    const business = await getBusiness();
+    const data = await api('POST', `/businesses/${business._id}/builder/projects`, {
+      name,
+      prompt,
+      sourceUrl,
+    });
+    return text({
+      projectId: data.project._id,
+      status: data.project.status,
+      importedContent: data.project.importedContent || null,
+      firstRevisionProvider: data.revision?.provider,
+    });
+  }
+);
+
+server.tool(
+  'get_project',
+  'Get a project with its current files, revision history, and run log. Read the current files before revising them.',
+  { projectId: z.string() },
+  async ({ projectId }) => {
+    const business = await getBusiness();
+    const data = await api('GET', `/businesses/${business._id}/builder/projects/${projectId}`);
+    const active = data.project.activeRevision;
+    return text({
+      project: {
+        id: data.project._id,
+        name: data.project.name,
+        status: data.project.status,
+        publishedUrl: data.project.publishedUrl,
+        sourceUrl: data.project.sourceUrl,
+        importedContent: data.project.importedContent || null,
+      },
+      activeRevision: active
+        ? { id: active._id, provider: active.provider, prompt: active.prompt, files: active.files }
+        : null,
+      revisions: (data.revisions || []).map((r) => ({
+        id: r._id,
+        provider: r.provider,
+        status: r.status,
+        prompt: r.prompt,
+        createdAt: r.createdAt,
+      })),
+    });
+  }
+);
+
+server.tool(
+  'save_revision',
+  [
+    'Save website files you generated as a new revision (becomes the active draft).',
+    'Rules for the files you generate:',
+    '- files must include index.html; static HTML/CSS only, CSS inlined in <style>; max 20 files / 5MB total.',
+    '- The contact section must contain <div id="werewolf-contact"></div> followed by:',
+    '  <script src="__WEREWOLF_PLATFORM_URL__/sdk/v1/widget.js" data-key="__WEREWOLF_PUBLISHABLE_KEY__" data-api="__WEREWOLF_PLATFORM_URL__" data-target="#werewolf-contact"></script>',
+    '- Keep the __WEREWOLF_PUBLISHABLE_KEY__ and __WEREWOLF_PLATFORM_URL__ placeholders verbatim; publishing fills them in.',
+    '- Use only real business data from get_business / importedContent; never fabricate testimonials or credentials.',
+  ].join('\n'),
+  {
+    projectId: z.string(),
+    prompt: z.string().optional().describe('What this revision changes (for the audit log)'),
+    files: z
+      .array(z.object({ path: z.string(), content: z.string() }))
+      .describe('The complete site files, e.g. [{ path: "index.html", content: "<!doctype html>..." }]'),
+  },
+  async ({ projectId, prompt, files }) => {
+    const business = await getBusiness();
+    const data = await api('POST', `/businesses/${business._id}/builder/projects/${projectId}/revisions`, {
+      prompt,
+      files,
+      provider: 'claude-code-mcp',
+    });
+    return text({ revisionId: data.revision._id, status: data.revision.status });
+  }
+);
+
+server.tool(
+  'generate_revision',
+  "Ask the PLATFORM to generate a revision server-side (template or configured AI provider) instead of generating files yourself. Usually you should generate the files and use save_revision; this is the fallback.",
+  { projectId: z.string(), prompt: z.string() },
+  async ({ projectId, prompt }) => {
+    const business = await getBusiness();
+    const data = await api('POST', `/businesses/${business._id}/builder/projects/${projectId}/revisions`, {
+      prompt,
+    });
+    return text({ revisionId: data.revision._id, provider: data.revision.provider });
+  }
+);
+
+server.tool(
+  'publish_project',
+  'Publish the active revision as the live static site. Pass domains for every host the site will be served from (e.g. handymanservices.werewolf.solutions) so the embedded contact-widget key is domain-locked correctly.',
+  {
+    projectId: z.string(),
+    domains: z.array(z.string()).optional().describe('Extra hostnames the site will be served from'),
+  },
+  async ({ projectId, domains }) => {
+    const business = await getBusiness();
+    const data = await api('POST', `/businesses/${business._id}/builder/projects/${projectId}/publish`, {
+      domains,
+    });
+    return text({
+      publishedUrl: data.publishedUrl,
+      keyPreview: data.apiKey?.keyPreview,
+      allowedDomains: data.apiKey?.allowedDomains,
+    });
+  }
+);
+
+}
+if (!runnerMode) await server.connect(new StdioServerTransport());