shipscreens 0.1.2 → 0.1.3

package/cli/mcpServer.js

@@ -0,0 +1,573 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getPackageRoot } from './packageRoot.js';
+
+const SUPPORTED_PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+const DEFAULT_PROTOCOL_VERSION = '2024-11-05';
+
+const TOOL_DEFINITIONS = [
+  {
+    name: 'shipscreens_devices',
+    title: 'List supported devices',
+    description: 'Returns canonical device IDs and metadata for shipscreens.config.yml.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: () => ['devices'],
+  },
+  {
+    name: 'shipscreens_templates',
+    title: 'List shipped templates',
+    description: 'Returns available template IDs for init/wizard/agent-run.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: () => ['templates'],
+  },
+  {
+    name: 'shipscreens_validate',
+    title: 'Validate config',
+    description: 'Validates shipscreens.config.yml (schema + asset paths).',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        configPath: { type: 'string' },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => withConfigArg(['validate'], args),
+  },
+  {
+    name: 'shipscreens_build',
+    title: 'Build outputs',
+    description: 'Builds Fastlane-ready outputs (dir/zip) from shipscreens.config.yml.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        configPath: { type: 'string' },
+        outDir: { type: 'string' },
+        mode: { type: 'string', enum: ['shipscreens', 'rendered', 'raw', 'frameit'] },
+        format: { type: 'string', enum: ['dir', 'zip'] },
+        zip: { type: 'boolean' },
+        zipOut: { type: 'string' },
+        clean: { type: 'boolean' },
+        requirePro: { type: 'boolean' },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => {
+      const commandArgs = withConfigArg(['build'], args);
+      pushOption(commandArgs, '--out', args.outDir);
+      pushOption(commandArgs, '--mode', args.mode);
+      pushOption(commandArgs, '--format', args.format);
+      pushOption(commandArgs, '--zip-out', args.zipOut);
+      pushFlag(commandArgs, '--zip', args.zip);
+      pushFlag(commandArgs, '--clean', args.clean);
+      pushFlag(commandArgs, '--require-pro', args.requirePro);
+      return commandArgs;
+    },
+  },
+  {
+    name: 'shipscreens_verify',
+    title: 'Verify outputs',
+    description: 'Verifies generated outputs for appstore/playstore/any profile rules.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        configPath: { type: 'string' },
+        outDir: { type: 'string' },
+        zip: { type: 'boolean' },
+        zipOut: { type: 'string' },
+        profile: { type: 'string', enum: ['appstore', 'playstore', 'any'] },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => {
+      const commandArgs = withConfigArg(['verify'], args);
+      pushOption(commandArgs, '--out', args.outDir);
+      pushOption(commandArgs, '--zip-out', args.zipOut);
+      pushOption(commandArgs, '--profile', args.profile);
+      pushFlag(commandArgs, '--zip', args.zip);
+      return commandArgs;
+    },
+  },
+  {
+    name: 'shipscreens_stage',
+    title: 'Stage upload root',
+    description: 'Copies upload-ready files into a clean staging directory.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['outDir'],
+      properties: {
+        workingDirectory: { type: 'string' },
+        configPath: { type: 'string' },
+        fromDir: { type: 'string' },
+        outDir: { type: 'string' },
+        profile: { type: 'string', enum: ['appstore', 'playstore', 'any'] },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => {
+      const commandArgs = withConfigArg(['stage'], args);
+      pushOption(commandArgs, '--from', args.fromDir);
+      pushOption(commandArgs, '--out', args.outDir);
+      pushOption(commandArgs, '--profile', args.profile);
+      return commandArgs;
+    },
+  },
+  {
+    name: 'shipscreens_plan',
+    title: 'Get deterministic plan',
+    description: 'Returns deterministic build/stage plan JSON for the current config.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        configPath: { type: 'string' },
+        outDir: { type: 'string' },
+        zipOut: { type: 'string' },
+        profile: { type: 'string', enum: ['appstore', 'playstore', 'any'] },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => {
+      const commandArgs = withConfigArg(['plan'], args);
+      pushOption(commandArgs, '--out', args.outDir);
+      pushOption(commandArgs, '--zip-out', args.zipOut);
+      pushOption(commandArgs, '--profile', args.profile);
+      return commandArgs;
+    },
+  },
+  {
+    name: 'shipscreens_agent_run',
+    title: 'Run non-interactive pipeline',
+    description: 'Runs init (if needed) -> validate -> build -> verify in one command.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        dir: { type: 'string' },
+        slides: { type: 'integer', minimum: 1, maximum: 10 },
+        locales: { type: 'string' },
+        devices: { type: 'string' },
+        template: { type: 'string' },
+        mode: { type: 'string', enum: ['raw', 'rendered'] },
+        outDir: { type: 'string' },
+        zip: { type: 'boolean' },
+        profile: { type: 'string', enum: ['appstore', 'playstore', 'any'] },
+        requirePro: { type: 'boolean' },
+        force: { type: 'boolean' },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => {
+      const commandArgs = ['agent-run'];
+      pushOption(commandArgs, '--dir', args.dir);
+      pushOption(commandArgs, '--slides', args.slides);
+      pushOption(commandArgs, '--locales', args.locales);
+      pushOption(commandArgs, '--devices', args.devices);
+      pushOption(commandArgs, '--template', args.template);
+      pushOption(commandArgs, '--mode', args.mode);
+      pushOption(commandArgs, '--out', args.outDir);
+      pushOption(commandArgs, '--profile', args.profile);
+      pushFlag(commandArgs, '--zip', args.zip);
+      pushFlag(commandArgs, '--require-pro', args.requirePro);
+      pushFlag(commandArgs, '--force', args.force);
+      return commandArgs;
+    },
+  },
+  {
+    name: 'shipscreens_demo',
+    title: 'Run demo export',
+    description: 'Creates a demo project and runs validate/lock/build/verify/stage.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        workingDirectory: { type: 'string' },
+        outDir: { type: 'string' },
+        slides: { type: 'integer', minimum: 1, maximum: 10 },
+        locales: { type: 'string' },
+        devices: { type: 'string' },
+        template: { type: 'string' },
+        mode: { type: 'string', enum: ['raw', 'rendered'] },
+        profile: { type: 'string', enum: ['appstore', 'playstore', 'any'] },
+        force: { type: 'boolean' },
+        timeoutMs: { type: 'integer', minimum: 1000, maximum: 1800000 },
+      },
+    },
+    buildArgs: (args) => {
+      const commandArgs = ['demo'];
+      pushOption(commandArgs, '--out', args.outDir);
+      pushOption(commandArgs, '--slides', args.slides);
+      pushOption(commandArgs, '--locales', args.locales);
+      pushOption(commandArgs, '--devices', args.devices);
+      pushOption(commandArgs, '--template', args.template);
+      pushOption(commandArgs, '--mode', args.mode);
+      pushOption(commandArgs, '--profile', args.profile);
+      pushFlag(commandArgs, '--force', args.force);
+      return commandArgs;
+    },
+  },
+];
+
+const TOOL_MAP = new Map(TOOL_DEFINITIONS.map((tool) => [tool.name, tool]));
+
+const SERVER_INFO = {
+  name: 'shipscreens-mcp',
+  title: 'ShipScreens MCP Server',
+  version: '0.1.0',
+};
+
+function withConfigArg(baseArgs, args) {
+  const commandArgs = [...baseArgs];
+  pushOption(commandArgs, '--config', args.configPath);
+  return commandArgs;
+}
+
+function pushOption(target, flag, value) {
+  if (value === undefined || value === null || value === '') return;
+  target.push(flag, String(value));
+}
+
+function pushFlag(target, flag, enabled) {
+  if (enabled) target.push(flag);
+}
+
+function toJsonRpcError({ code, message, data }) {
+  const err = { code, message };
+  if (data !== undefined) err.data = data;
+  return err;
+}
+
+function createToolResultText({ toolName, commandArgs, payload, stderr }) {
+  const command = ['shipscreens', ...commandArgs].join(' ');
+  const summary = [`tool=${toolName}`, `command=${command}`];
+  if (stderr) summary.push(`stderr=${stderr.trim()}`);
+  const json = JSON.stringify(payload, null, 2);
+  return `${summary.join('\n')}\n\n${json}`;
+}
+
+function parseClientMessage(raw) {
+  if (!raw || typeof raw !== 'object') {
+    throw new Error('Expected JSON-RPC object.');
+  }
+  return raw;
+}
+
+function createStdioMessageParser(onMessage, onError) {
+  let buffer = Buffer.alloc(0);
+  return (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      const headerEnd = buffer.indexOf('\r\n\r\n');
+      if (headerEnd < 0) return;
+
+      const headerBlock = buffer.subarray(0, headerEnd).toString('utf8');
+      const headers = headerBlock.split('\r\n');
+      let contentLength = -1;
+      for (const line of headers) {
+        const idx = line.indexOf(':');
+        if (idx < 0) continue;
+        const key = line.slice(0, idx).trim().toLowerCase();
+        const value = line.slice(idx + 1).trim();
+        if (key === 'content-length') {
+          contentLength = Number(value);
+          break;
+        }
+      }
+      if (!Number.isFinite(contentLength) || contentLength < 0) {
+        onError(new Error('Invalid MCP framing: missing Content-Length header.'));
+        buffer = Buffer.alloc(0);
+        return;
+      }
+
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + contentLength;
+      if (buffer.length < messageEnd) return;
+
+      const body = buffer.subarray(messageStart, messageEnd).toString('utf8');
+      buffer = buffer.subarray(messageEnd);
+      try {
+        const parsed = JSON.parse(body);
+        onMessage(parseClientMessage(parsed));
+      } catch (err) {
+        onError(new Error(`Invalid MCP JSON payload: ${err?.message || String(err)}`));
+        return;
+      }
+    }
+  };
+}
+
+function createStdioWriter(stream) {
+  return (message) => {
+    const json = JSON.stringify(message);
+    const body = Buffer.from(json, 'utf8');
+    stream.write(`Content-Length: ${body.length}\r\n\r\n`);
+    stream.write(body);
+  };
+}
+
+async function runShipScreensCommand({
+  packageRoot,
+  commandArgs,
+  workingDirectory,
+  timeoutMs = 10 * 60 * 1000,
+}) {
+  const cliPath = path.join(packageRoot, 'bin', 'shipscreens.js');
+  const resolvedCwd = workingDirectory
+    ? path.resolve(process.cwd(), workingDirectory)
+    : process.cwd();
+  await fs.stat(resolvedCwd);
+
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [cliPath, ...commandArgs, '--json'], {
+      cwd: resolvedCwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill('SIGTERM');
+      resolve({
+        ok: false,
+        code: -1,
+        stdout,
+        stderr: `${stderr}\nMCP tool timeout after ${timeoutMs}ms`.trim(),
+      });
+    }, timeoutMs);
+
+    child.stdout.on('data', (buf) => {
+      stdout += buf.toString('utf8');
+    });
+    child.stderr.on('data', (buf) => {
+      stderr += buf.toString('utf8');
+    });
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({
+        ok: code === 0,
+        code,
+        stdout,
+        stderr,
+      });
+    });
+  });
+}
+
+function parseToolPayload(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return null;
+  return JSON.parse(text);
+}
+
+function sanitizeTimeout(value) {
+  if (value === undefined || value === null) return 10 * 60 * 1000;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1000 || n > 1800000) {
+    throw new Error('timeoutMs must be an integer between 1000 and 1800000.');
+  }
+  return n;
+}
+
+function ensureObject(value, label) {
+  if (value === undefined || value === null) return {};
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  return value;
+}
+
+function pickProtocolVersion(requested) {
+  if (typeof requested === 'string' && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)) {
+    return requested;
+  }
+  return DEFAULT_PROTOCOL_VERSION;
+}
+
+function buildToolListResponse() {
+  return {
+    tools: TOOL_DEFINITIONS.map((tool) => ({
+      name: tool.name,
+      title: tool.title,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    })),
+  };
+}
+
+export async function runMcpServer() {
+  const packageRoot = getPackageRoot();
+  const write = createStdioWriter(process.stdout);
+  let isInitialized = false;
+
+  const handleRequest = async (request) => {
+    const { id, method, params } = request;
+
+    const sendResult = (result) => write({ jsonrpc: '2.0', id, result });
+    const sendError = (error) => write({ jsonrpc: '2.0', id, error });
+
+    try {
+      if (method === 'initialize') {
+        const requestedVersion = params?.protocolVersion;
+        isInitialized = true;
+        sendResult({
+          protocolVersion: pickProtocolVersion(requestedVersion),
+          capabilities: {
+            tools: {
+              listChanged: false,
+            },
+          },
+          serverInfo: SERVER_INFO,
+          instructions:
+            'Use tools to run deterministic ShipScreens CLI workflows (validate/build/verify/stage/plan) in local or CI contexts.',
+        });
+        return;
+      }
+
+      if (method === 'ping') {
+        sendResult({});
+        return;
+      }
+
+      if (!isInitialized) {
+        sendError(toJsonRpcError({ code: -32002, message: 'Server not initialized.' }));
+        return;
+      }
+
+      if (method === 'tools/list') {
+        sendResult(buildToolListResponse());
+        return;
+      }
+
+      if (method === 'tools/call') {
+        const callParams = ensureObject(params, 'tools/call params');
+        const toolName = String(callParams.name || '').trim();
+        const toolArgs = ensureObject(callParams.arguments, 'tools/call arguments');
+        if (!toolName) {
+          sendError(toJsonRpcError({ code: -32602, message: 'tools/call requires name.' }));
+          return;
+        }
+        const tool = TOOL_MAP.get(toolName);
+        if (!tool) {
+          sendError(toJsonRpcError({ code: -32602, message: `Unknown tool: ${toolName}` }));
+          return;
+        }
+
+        const timeoutMs = sanitizeTimeout(toolArgs.timeoutMs);
+        const commandArgs = tool.buildArgs(toolArgs);
+        const result = await runShipScreensCommand({
+          packageRoot,
+          commandArgs,
+          workingDirectory: toolArgs.workingDirectory,
+          timeoutMs,
+        });
+
+        if (!result.ok) {
+          sendResult({
+            content: [
+              {
+                type: 'text',
+                text:
+                  `ShipScreens command failed: shipscreens ${commandArgs.join(' ')}\n` +
+                  `exitCode=${result.code}\n` +
+                  `${result.stderr || '(no stderr output)'}`,
+              },
+            ],
+            isError: true,
+          });
+          return;
+        }
+
+        let payload = null;
+        try {
+          payload = parseToolPayload(result.stdout);
+        } catch (err) {
+          sendResult({
+            content: [
+              {
+                type: 'text',
+                text:
+                  `ShipScreens command output was not valid JSON.\n` +
+                  `error=${err?.message || String(err)}\n` +
+                  `${result.stdout || '(empty stdout)'}`,
+              },
+            ],
+            isError: true,
+          });
+          return;
+        }
+
+        sendResult({
+          content: [
+            {
+              type: 'text',
+              text: createToolResultText({
+                toolName,
+                commandArgs,
+                payload,
+                stderr: result.stderr,
+              }),
+            },
+          ],
+          isError: false,
+        });
+        return;
+      }
+
+      sendError(toJsonRpcError({ code: -32601, message: `Method not found: ${method}` }));
+    } catch (err) {
+      sendError(
+        toJsonRpcError({
+          code: -32603,
+          message: err?.message || String(err),
+        })
+      );
+    }
+  };
+
+  const onMessage = (message) => {
+    if (Object.prototype.hasOwnProperty.call(message, 'id')) {
+      void handleRequest(message);
+      return;
+    }
+    // notifications/initialized and other notifications are no-op for this server.
+  };
+
+  const onError = (err) => {
+    process.stderr.write(`mcp-server: ${err?.message || String(err)}\n`);
+  };
+
+  const parseChunk = createStdioMessageParser(onMessage, onError);
+  process.stdin.on('data', parseChunk);
+  process.stdin.on('error', onError);
+  process.stdin.on('end', () => {
+    process.exit(0);
+  });
+}