@abarcenas/ai-workflow-template 1.45.0 → 1.47.0

package/scripts/mcp/playwright-mcp-launcher.test.js

@@ -0,0 +1,217 @@
+// ═════════════════════════════════════════════════════════════════════════════
+// playwright-mcp-launcher.test.js — Unit tests for the MCP launcher
+// ═════════════════════════════════════════════════════════════════════════════
+//
+// `spawn` is mocked so no MCP server is ever launched.  Signal handling and
+// exit-code propagation are exercised through injected fakes (an EventEmitter
+// double for the process and a fake child), plus a direct-run import that
+// verifies the CLI bootstrap branch.
+//
+// Covered scenarios:
+//   1.  default args (no env flags)
+//   2.  HEADLESS=true adds --headless
+//   3.  HEADLESS=false does not
+//   4.  VIEWPORT adds --viewport <size>
+//   5.  HEADLESS + VIEWPORT together
+//   6.  spawn is called as `npx <args>` with inherited stdio + shell
+//   7.  exit code 0 is forwarded
+//   8.  non-zero exit code is forwarded
+//   9.  missing exit code falls back to 0
+//  10.  SIGINT / SIGTERM are forwarded to the child
+//  11.  launch returns the child
+//  12.  direct run auto-launches; imported elsewhere it does not
+// ═════════════════════════════════════════════════════════════════════════════
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { EventEmitter } from 'node:events'
+import { fileURLToPath } from 'node:url'
+
+const cp = vi.hoisted(() => ({ spawn: vi.fn() }))
+
+vi.mock('node:child_process', () => ({
+  spawn: cp.spawn,
+}))
+
+import { spawn } from 'node:child_process'
+import { buildArgs, launch } from './playwright-mcp-launcher.js'
+
+/**
+ * Creates a fake ChildProcess.
+ *
+ * @returns {object} Fake child with kill/on and a helper to emit 'exit'.
+ */
+function makeChild() {
+  const handlers = {}
+  return {
+    kill: vi.fn(),
+    on: vi.fn((event, handler) => {
+      handlers[event] = handler
+    }),
+    emitExit(code) {
+      handlers.exit?.(code)
+    },
+  }
+}
+
+describe('playwright-mcp-launcher', () => {
+  let child
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    child = makeChild()
+    spawn.mockReturnValue(child)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  // ── buildArgs ────────────────────────────────────────────────────────────
+
+  it('buildArgs: returns only the package when no env flags are set', () => {
+    expect(buildArgs({})).toEqual(['@playwright/mcp@latest'])
+  })
+
+  it('buildArgs: HEADLESS=true adds --headless', () => {
+    expect(buildArgs({ HEADLESS: 'true' })).toEqual([
+      '@playwright/mcp@latest',
+      '--headless',
+    ])
+  })
+
+  it('buildArgs: HEADLESS=false does not add --headless', () => {
+    expect(buildArgs({ HEADLESS: 'false' })).toEqual(['@playwright/mcp@latest'])
+  })
+
+  it('buildArgs: VIEWPORT adds a two-token viewport flag', () => {
+    expect(buildArgs({ VIEWPORT: '1280x720' })).toEqual([
+      '@playwright/mcp@latest',
+      '--viewport',
+      '1280x720',
+    ])
+  })
+
+  it('buildArgs: combines headless and viewport flags', () => {
+    expect(buildArgs({ HEADLESS: 'true', VIEWPORT: '800x600' })).toEqual([
+      '@playwright/mcp@latest',
+      '--headless',
+      '--viewport',
+      '800x600',
+    ])
+  })
+
+  // ── launch ───────────────────────────────────────────────────────────────
+
+  it('launch: spawns npx with inherited stdio and shell', () => {
+    launch({ env: {}, proc: new EventEmitter(), exit: vi.fn() })
+
+    expect(spawn).toHaveBeenCalledWith('npx', ['@playwright/mcp@latest'], {
+      stdio: 'inherit',
+      shell: true,
+    })
+  })
+
+  it('launch: returns the spawned child', () => {
+    const returned = launch({
+      env: {},
+      proc: new EventEmitter(),
+      exit: vi.fn(),
+    })
+
+    expect(returned).toBe(child)
+  })
+
+  it('launch: forwards exit code 0', () => {
+    const exit = vi.fn()
+    launch({ env: {}, proc: new EventEmitter(), exit })
+
+    child.emitExit(0)
+
+    expect(exit).toHaveBeenCalledWith(0)
+  })
+
+  it('launch: forwards a non-zero exit code', () => {
+    const exit = vi.fn()
+    launch({ env: {}, proc: new EventEmitter(), exit })
+
+    child.emitExit(5)
+
+    expect(exit).toHaveBeenCalledWith(5)
+  })
+
+  it('launch: falls back to 0 when no exit code is provided', () => {
+    const exit = vi.fn()
+    launch({ env: {}, proc: new EventEmitter(), exit })
+
+    child.emitExit(undefined)
+
+    expect(exit).toHaveBeenCalledWith(0)
+  })
+
+  it('launch: forwards SIGINT to the child', () => {
+    const proc = new EventEmitter()
+    launch({ env: {}, proc, exit: vi.fn() })
+
+    proc.emit('SIGINT')
+
+    expect(child.kill).toHaveBeenCalledWith('SIGINT')
+  })
+
+  it('launch: forwards SIGTERM to the child', () => {
+    const proc = new EventEmitter()
+    launch({ env: {}, proc, exit: vi.fn() })
+
+    proc.emit('SIGTERM')
+
+    expect(child.kill).toHaveBeenCalledWith('SIGTERM')
+  })
+
+  // ── Direct-run guard ─────────────────────────────────────────────────────
+
+  it('direct run: auto-launches when argv[1] is this module', async () => {
+    const modulePath = fileURLToPath(
+      new URL('./playwright-mcp-launcher.js', import.meta.url),
+    )
+    const originalArgv1 = process.argv[1]
+    const intListeners = process.listeners('SIGINT')
+    const termListeners = process.listeners('SIGTERM')
+    process.argv[1] = modulePath
+
+    try {
+      vi.resetModules()
+      await import('./playwright-mcp-launcher.js')
+
+      expect(spawn).toHaveBeenCalledWith(
+        'npx',
+        expect.arrayContaining(['@playwright/mcp@latest']),
+        { stdio: 'inherit', shell: true },
+      )
+    } finally {
+      process.argv[1] = originalArgv1
+      for (const listener of process.listeners('SIGINT')) {
+        if (!intListeners.includes(listener)) {
+          process.removeListener('SIGINT', listener)
+        }
+      }
+      for (const listener of process.listeners('SIGTERM')) {
+        if (!termListeners.includes(listener)) {
+          process.removeListener('SIGTERM', listener)
+        }
+      }
+    }
+  })
+
+  it('imported with an empty argv[1]: does not launch', async () => {
+    const originalArgv1 = process.argv[1]
+    process.argv[1] = ''
+
+    try {
+      vi.resetModules()
+      await import('./playwright-mcp-launcher.js')
+
+      expect(spawn).not.toHaveBeenCalled()
+    } finally {
+      process.argv[1] = originalArgv1
+    }
+  })
+})

package/scripts/mcp-memory-server.js

@@ -20,6 +20,8 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
 import { search, rebuildIndex, incrementalUpdate, getFile, getStats } from './memory-index.js';
 
 const VALID_FILES = [
@@ -43,88 +45,92 @@ const server = new Server(
 
 // ── List tools ───────────────────────────────────────────────────────
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'memory_search',
-      description:
-        'Semantic search across the project memory bank (activeContext, systemPatterns, progress, decisions, tasks). ' +
-        'Returns ranked chunks with source file and similarity score. ' +
-        'Use this instead of reading all memory files to save tokens.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          query: {
-            type: 'string',
-            description: 'Natural language query about project context, decisions, or status',
-          },
-          topK: {
-            type: 'number',
-            default: 5,
-            description: 'Number of results to return (1-20)',
-          },
-          sourceFile: {
-            type: 'string',
-            description: 'Optional: filter to a specific memory file (e.g., "activeContext", "systemPatterns")',
+export async function listTools() {
+  return {
+    tools: [
+      {
+        name: 'memory_search',
+        description:
+          'Semantic search across the project memory bank (activeContext, systemPatterns, progress, decisions, tasks). ' +
+          'Returns ranked chunks with source file and similarity score. ' +
+          'Use this instead of reading all memory files to save tokens.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Natural language query about project context, decisions, or status',
+            },
+            topK: {
+              type: 'number',
+              default: 5,
+              description: 'Number of results to return (1-20)',
+            },
+            sourceFile: {
+              type: 'string',
+              description: 'Optional: filter to a specific memory file (e.g., "activeContext", "systemPatterns")',
+            },
           },
+          required: ['query'],
         },
-        required: ['query'],
       },
-    },
-    {
-      name: 'memory_rebuild',
-      description:
-        'Full rebuild of the memory vector index from memory-bank/*.md and docs/*.md files. ' +
-        'Re-indexes every file regardless of change. ' +
-        'Use memory_update instead for faster incremental sync (only changed files). ' +
-        'The index is disposable — rebuilding is safe.',
-      inputSchema: {
-        type: 'object',
-        properties: {},
+      {
+        name: 'memory_rebuild',
+        description:
+          'Full rebuild of the memory vector index from memory-bank/*.md and docs/*.md files. ' +
+          'Re-indexes every file regardless of change. ' +
+          'Use memory_update instead for faster incremental sync (only changed files). ' +
+          'The index is disposable — rebuilding is safe.',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
       },
-    },
-    {
-      name: 'memory_update',
-      description:
-        'Incremental update — only re-indexes files whose content changed (SHA-256 content hash). ' +
-        'Much faster than memory_rebuild for daily use (~2 seconds vs minutes). ' +
-        'Run this after completing tasks, writing to memory-bank, or after git pull.',
-      inputSchema: {
-        type: 'object',
-        properties: {},
+      {
+        name: 'memory_update',
+        description:
+          'Incremental update — only re-indexes files whose content changed (SHA-256 content hash). ' +
+          'Much faster than memory_rebuild for daily use (~2 seconds vs minutes). ' +
+          'Run this after completing tasks, writing to memory-bank, or after git pull.',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
       },
-    },
-    {
-      name: 'memory_get',
-      description:
-        'Read the full content of a specific memory file by name. ' +
-        'Use when you need the complete file, not just search snippets.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          file: {
-            type: 'string',
-            description: 'File ID without extension. One of: ' + VALID_FILES.join(', '),
-            enum: VALID_FILES,
+      {
+        name: 'memory_get',
+        description:
+          'Read the full content of a specific memory file by name. ' +
+          'Use when you need the complete file, not just search snippets.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file: {
+              type: 'string',
+              description: 'File ID without extension. One of: ' + VALID_FILES.join(', '),
+              enum: VALID_FILES,
+            },
           },
+          required: ['file'],
         },
-        required: ['file'],
       },
-    },
-    {
-      name: 'memory_stats',
-      description: 'Get statistics about the memory index (vector count, file count, database size).',
-      inputSchema: {
-        type: 'object',
-        properties: {},
+      {
+        name: 'memory_stats',
+        description: 'Get statistics about the memory index (vector count, file count, database size).',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
       },
-    },
-  ],
-}));
+    ],
+  };
+}
+
+server.setRequestHandler(ListToolsRequestSchema, listTools);
 
 // ── Handle tool calls ────────────────────────────────────────────────
 
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
+export async function handleToolCall(request) {
   const { name, arguments: args } = request.params;
 
   try {
@@ -227,17 +233,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       isError: true,
     };
   }
-});
+}
+
+server.setRequestHandler(CallToolRequestSchema, handleToolCall);
 
 // ── Start server ─────────────────────────────────────────────────────
 
-async function main() {
+export async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error('[memory-bank-mcp] Server started via stdio transport');
 }
 
-main().catch((err) => {
-  console.error('[memory-bank-mcp] Fatal error:', err);
-  process.exit(1);
-});
+export function bootstrap() {
+  return main().catch((err) => {
+    console.error('[memory-bank-mcp] Fatal error:', err);
+    process.exit(1);
+  });
+}
+
+const isDirectRun =
+  process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isDirectRun) {
+  bootstrap();
+}