@kya-os/create-mcpi-app 1.7.17 → 1.7.20

package/src/__tests__/helpers/fetch-cloudflare-mcpi-template.test.ts

@@ -0,0 +1,337 @@
+/**
+ * Fetch Cloudflare MCP-I Template Tests
+ *
+ * Tests for template fetching logic, caching, network failure handling,
+ * and template transformation.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { fetchCloudflareMcpiTemplate } from '../../helpers/fetch-cloudflare-mcpi-template';
+import fs from 'fs-extra';
+import path from 'path';
+
+describe('fetchCloudflareMcpiTemplate', () => {
+  let tempDir: string;
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+
+  beforeEach(() => {
+    tempDir = path.join(process.cwd(), 'test-temp', `fetch-test-${Date.now()}-${Math.random().toString(36).substring(7)}`);
+    fs.ensureDirSync(tempDir);
+    console.log = vi.fn();
+    console.error = vi.fn();
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.removeSync(tempDir);
+    }
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  });
+
+  describe('Template fetching logic', () => {
+    it('should fetch and generate template successfully', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project'
+      });
+
+      // Verify template was generated
+      expect(fs.existsSync(path.join(tempDir, 'package.json'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'src', 'index.ts'))).toBe(true);
+    });
+
+    it('should use default project name from path when not provided', async () => {
+      const customPath = path.join(tempDir, 'my-project');
+      await fetchCloudflareMcpiTemplate(customPath, {
+        packageManager: 'npm'
+      });
+
+      const packageJsonPath = path.join(customPath, 'package.json');
+      const packageJson = fs.readJsonSync(packageJsonPath);
+      expect(packageJson.name).toBe('my-project');
+    });
+
+    it('should handle different package managers', async () => {
+      for (const pm of ['npm', 'yarn', 'pnpm']) {
+        const pmDir = path.join(tempDir, `test-${pm}`);
+        await fetchCloudflareMcpiTemplate(pmDir, {
+          packageManager: pm,
+          projectName: `test-${pm}`
+        });
+
+        const packageJsonPath = path.join(pmDir, 'package.json');
+        expect(fs.existsSync(packageJsonPath)).toBe(true);
+      }
+    });
+
+    it('should generate template with correct project structure', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project'
+      });
+
+      // Check directory structure
+      expect(fs.existsSync(path.join(tempDir, 'src'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'src', 'tools'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'scripts'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'tests'))).toBe(true);
+    });
+  });
+
+  describe('Template caching', () => {
+    it('should generate consistent template structure on multiple calls', async () => {
+      const dir1 = path.join(tempDir, 'project1');
+      const dir2 = path.join(tempDir, 'project2');
+
+      await fetchCloudflareMcpiTemplate(dir1, {
+        packageManager: 'npm',
+        projectName: 'project1'
+      });
+
+      await fetchCloudflareMcpiTemplate(dir2, {
+        packageManager: 'npm',
+        projectName: 'project2'
+      });
+
+      // Both should have same structure
+      const files1 = fs.readdirSync(dir1);
+      const files2 = fs.readdirSync(dir2);
+
+      // Should have same top-level files
+      expect(files1.sort()).toEqual(files2.sort());
+    });
+
+    it('should handle template generation without overwriting existing files incorrectly', async () => {
+      // Create existing file
+      const existingFile = path.join(tempDir, 'package.json');
+      fs.writeJsonSync(existingFile, { name: 'existing' });
+
+      // Generate template - should overwrite
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'new-project'
+      });
+
+      const packageJson = fs.readJsonSync(existingFile);
+      expect(packageJson.name).toBe('new-project');
+    });
+  });
+
+  describe('Error handling for network failures', () => {
+    it('should handle missing dependencies gracefully', async () => {
+      // This test verifies that the function doesn't fail if dependencies are missing
+      // Since this is a local file operation, we test that it handles file system errors
+      const invalidPath = '/invalid/path/that/does/not/exist';
+      
+      await expect(async () => {
+        await fetchCloudflareMcpiTemplate(invalidPath, {
+          packageManager: 'npm',
+          projectName: 'test'
+        });
+      }).rejects.toThrow();
+    });
+
+    it('should handle permission errors gracefully', async () => {
+      const readOnlyDir = path.join(tempDir, 'readonly');
+      fs.ensureDirSync(readOnlyDir);
+      
+      try {
+        // Make directory read-only (if possible on this system)
+        fs.chmodSync(readOnlyDir, 0o444);
+        
+        await expect(async () => {
+          await fetchCloudflareMcpiTemplate(readOnlyDir, {
+            packageManager: 'npm',
+            projectName: 'test'
+          });
+        }).rejects.toThrow();
+      } catch (error) {
+        // Permission errors are expected
+        expect(error).toBeDefined();
+      } finally {
+        // Restore permissions for cleanup
+        try {
+          fs.chmodSync(readOnlyDir, 0o755);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+
+    it('should handle disk space errors (simulated)', async () => {
+      // Test that function handles file write errors
+      const diskFullDir = path.join(tempDir, 'disk-full');
+      
+      // Mock fs.writeFileSync to throw error
+      const originalWriteFileSync = fs.writeFileSync;
+      const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync').mockImplementationOnce(() => {
+        throw new Error('ENOSPC: No space left on device');
+      });
+
+      await expect(async () => {
+        await fetchCloudflareMcpiTemplate(diskFullDir, {
+          packageManager: 'npm',
+          projectName: 'test'
+        });
+      }).rejects.toThrow();
+
+      writeFileSyncSpy.mockRestore();
+    });
+  });
+
+  describe('Template transformation', () => {
+    it('should transform project name to valid class name', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'my-awesome-project'
+      });
+
+      const indexPath = path.join(tempDir, 'src', 'index.ts');
+      const indexContent = fs.readFileSync(indexPath, 'utf-8');
+
+      // Should sanitize special characters - "my-awesome-project" becomes "MyawesomeprojectMCP"
+      // Class name should not contain hyphens
+      expect(indexContent).toMatch(/class\s+\w+MCP/);
+      // Should not contain the original hyphenated name in the class declaration
+      const classMatch = indexContent.match(/class\s+(\w+)MCP/);
+      expect(classMatch).toBeTruthy();
+      if (classMatch) {
+        expect(classMatch[1]).not.toContain('-');
+      }
+    });
+
+    it('should handle special characters in project name', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test@123!project'
+      });
+
+      const indexPath = path.join(tempDir, 'src', 'index.ts');
+      const indexContent = fs.readFileSync(indexPath, 'utf-8');
+
+      // Should sanitize special characters
+      expect(indexContent).toMatch(/class\s+\w+MCP/);
+    });
+
+    it('should handle numeric project names', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: '123project'
+      });
+
+      const indexPath = path.join(tempDir, 'src', 'index.ts');
+      const indexContent = fs.readFileSync(indexPath, 'utf-8');
+
+      // Should prefix with underscore if starts with number
+      expect(indexContent).toMatch(/class\s+_?\w+MCP/);
+    });
+
+    it('should transform KV namespace bindings correctly', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'TestProject'
+      });
+
+      const wranglerPath = path.join(tempDir, 'wrangler.toml');
+      const wranglerContent = fs.readFileSync(wranglerPath, 'utf-8');
+
+      // Should use uppercase class name for KV bindings
+      expect(wranglerContent).toContain('TESTPROJECT_');
+    });
+
+    it('should transform package.json scripts correctly', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'MyProject'
+      });
+
+      const packageJsonPath = path.join(tempDir, 'package.json');
+      const packageJson = fs.readJsonSync(packageJsonPath);
+
+      // Scripts should use transformed class name
+      expect(packageJson.scripts['kv:create-nonce']).toContain('MYPROJECT_');
+    });
+
+    it('should transform index.ts class name correctly', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project'
+      });
+
+      const indexPath = path.join(tempDir, 'src', 'index.ts');
+      const indexContent = fs.readFileSync(indexPath, 'utf-8');
+
+      // Should create PascalCase class - "test-project" becomes "TestprojectMCP"
+      expect(indexContent).toContain('class TestprojectMCP');
+    });
+  });
+
+  describe('API key handling', () => {
+    it('should include API key in .dev.vars when provided', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project',
+        apikey: 'sk_test_1234567890'
+      });
+
+      const devVarsPath = path.join(tempDir, '.dev.vars');
+      if (fs.existsSync(devVarsPath)) {
+        const devVarsContent = fs.readFileSync(devVarsPath, 'utf-8');
+        expect(devVarsContent).toContain('sk_test_1234567890');
+      }
+    });
+
+    it('should handle missing API key gracefully', async () => {
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project'
+      });
+
+      // Template should still be generated
+      expect(fs.existsSync(path.join(tempDir, 'package.json'))).toBe(true);
+    });
+  });
+
+  describe('Skip identity option', () => {
+    it('should skip identity generation when skipIdentity is true', async () => {
+      const generateIdentitySpy = vi.spyOn(await import('../../helpers/generate-identity'), 'generateIdentity');
+
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project',
+        skipIdentity: true
+      });
+
+      // generateIdentity should not be called
+      expect(generateIdentitySpy).not.toHaveBeenCalled();
+      
+      generateIdentitySpy.mockRestore();
+    });
+
+    it('should generate identity when skipIdentity is false', async () => {
+      const generateIdentitySpy = vi.spyOn(await import('../../helpers/generate-identity'), 'generateIdentity');
+      generateIdentitySpy.mockResolvedValue({
+        did: 'did:key:ztest',
+        kid: 'did:key:ztest#key-1',
+        privateKey: 'test-private',
+        publicKey: 'test-public',
+        createdAt: new Date().toISOString(),
+        type: 'development'
+      });
+
+      await fetchCloudflareMcpiTemplate(tempDir, {
+        packageManager: 'npm',
+        projectName: 'test-project',
+        skipIdentity: false
+      });
+
+      // generateIdentity should be called
+      expect(generateIdentitySpy).toHaveBeenCalled();
+      
+      generateIdentitySpy.mockRestore();
+    });
+  });
+});
+

package/src/__tests__/helpers/generate-config.test.ts

@@ -0,0 +1,312 @@
+/**
+ * Generate Config Tests
+ *
+ * Tests for config generation from prompts, default values, config merging,
+ * and validation rules.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { generateConfig } from '../../helpers/generate-config';
+import fs from 'fs-extra';
+import path from 'path';
+
+describe('generateConfig', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // Ensure parent directory exists first to avoid race conditions
+    const testTempDir = path.join(process.cwd(), 'test-temp');
+    fs.ensureDirSync(testTempDir);
+    tempDir = path.join(testTempDir, `config-test-${Date.now()}-${Math.random().toString(36).substring(7)}`);
+    fs.ensureDirSync(tempDir);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.removeSync(tempDir);
+    }
+    if (fs.existsSync(path.join(process.cwd(), 'test-temp'))) {
+      const testTempContents = fs.readdirSync(path.join(process.cwd(), 'test-temp'));
+      if (testTempContents.length === 0) {
+        fs.removeSync(path.join(process.cwd(), 'test-temp'));
+      }
+    }
+  });
+
+  describe('Config generation from prompts', () => {
+    it('should generate xmcp.config.ts with default values', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      expect(fs.existsSync(configPath)).toBe(true);
+
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      expect(configContent).toContain('XmcpConfig');
+      expect(configContent).toContain('paths');
+      expect(configContent).toContain('./src/tools');
+    });
+
+    it('should generate config with HTTP transport when specified', () => {
+      generateConfig(tempDir, ['http'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).toContain('http: true');
+      expect(configContent).not.toContain('stdio: true');
+    });
+
+    it('should generate config with STDIO transport when specified', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).toContain('stdio: true');
+      expect(configContent).not.toContain('http: true');
+    });
+
+    it('should generate config with both transports when both specified', () => {
+      generateConfig(tempDir, ['http', 'stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).toContain('http: true');
+      expect(configContent).toContain('stdio: true');
+    });
+
+    it('should generate config without identity when skipIdentity is true', () => {
+      generateConfig(tempDir, ['stdio'], true);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).not.toContain('identity:');
+    });
+
+    it('should generate config with identity when skipIdentity is false', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).toContain('identity:');
+      expect(configContent).toContain('enabled: true');
+    });
+  });
+
+  describe('Default values', () => {
+    it('should use default tools path', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).toContain('tools: "./src/tools"');
+    });
+
+    it('should use default development environment for identity', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      expect(configContent).toContain('environment: "development"');
+    });
+
+    it('should generate runtime config with default values', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      expect(fs.existsSync(runtimeConfigPath)).toBe(true);
+
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+      expect(runtimeConfigContent).toContain('getRuntimeConfig');
+      expect(runtimeConfigContent).toContain('buildBaseConfig');
+    });
+
+    it('should include default Node.js server configuration', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      expect(runtimeConfigContent).toContain('port:');
+      expect(runtimeConfigContent).toContain('host:');
+      expect(runtimeConfigContent).toContain('cors:');
+    });
+  });
+
+  describe('Config merging', () => {
+    it('should merge base config with Node.js-specific properties', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      // Should include base config properties
+      expect(runtimeConfigContent).toContain('baseConfig');
+      // Should include Node.js-specific properties
+      expect(runtimeConfigContent).toContain('server:');
+      expect(runtimeConfigContent).toContain('storage:');
+      expect(runtimeConfigContent).toContain('nodeEnv:');
+    });
+
+    it('should merge identity config when not skipped', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      // The runtime config uses buildBaseConfig which includes identity
+      // Check that buildBaseConfig is called (which includes identity)
+      expect(runtimeConfigContent).toContain('buildBaseConfig');
+      expect(runtimeConfigContent).toContain('baseConfig');
+      
+      // Also verify that xmcp.config.ts contains identity when not skipped
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      expect(configContent).toContain('identity');
+    });
+
+    it('should merge proofing config', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      // The runtime config uses buildBaseConfig which includes proofing
+      // buildBaseConfig is imported and called, which internally includes proofing configuration
+      expect(runtimeConfigContent).toContain('buildBaseConfig');
+      expect(runtimeConfigContent).toContain('baseConfig');
+      // The baseConfig spread includes proofing via buildBaseConfig
+      expect(runtimeConfigContent).toContain('...baseConfig');
+    });
+
+    it('should merge delegation config', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      expect(runtimeConfigContent).toContain('delegation');
+    });
+  });
+
+  describe('Validation rules', () => {
+    it('should create valid TypeScript config file', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      // Should be valid TypeScript syntax
+      expect(configContent).toContain('import');
+      expect(configContent).toContain('export default');
+      expect(configContent).toContain('const config');
+    });
+
+    it('should create valid TypeScript runtime config file', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      // Should be valid TypeScript syntax
+      expect(runtimeConfigContent).toContain('import');
+      expect(runtimeConfigContent).toContain('export function');
+      expect(runtimeConfigContent).toContain('NodeRuntimeConfig');
+    });
+
+    it('should validate transport options', () => {
+      // Empty transports array should still work
+      generateConfig(tempDir, [], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      expect(fs.existsSync(configPath)).toBe(true);
+    });
+
+    it('should handle invalid transport values gracefully', () => {
+      // Invalid transports should be ignored
+      generateConfig(tempDir, ['invalid-transport' as any], false);
+
+      const configPath = path.join(tempDir, 'xmcp.config.ts');
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+
+      // Should not contain invalid transport
+      expect(configContent).not.toContain('invalid-transport');
+    });
+
+    it('should validate file paths exist', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      // Should create src directory for runtime config
+      expect(fs.existsSync(path.join(tempDir, 'src'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'src', 'mcpi-runtime-config.ts'))).toBe(true);
+    });
+  });
+
+  describe('Environment variable handling', () => {
+    it('should use process.env in runtime config', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      expect(runtimeConfigContent).toContain('process.env');
+    });
+
+    it('should handle PORT environment variable', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      expect(runtimeConfigContent).toContain('PORT');
+      expect(runtimeConfigContent).toContain('"3000"');
+    });
+
+    it('should handle HOST environment variable', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      expect(runtimeConfigContent).toContain('HOST');
+      expect(runtimeConfigContent).toContain('"0.0.0.0"');
+    });
+
+    it('should handle NODE_ENV environment variable', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      const runtimeConfigPath = path.join(tempDir, 'src', 'mcpi-runtime-config.ts');
+      const runtimeConfigContent = fs.readFileSync(runtimeConfigPath, 'utf-8');
+
+      expect(runtimeConfigContent).toContain('NODE_ENV');
+    });
+  });
+
+  describe('File structure', () => {
+    it('should create src directory if it does not exist', () => {
+      generateConfig(tempDir, ['stdio'], false);
+
+      expect(fs.existsSync(path.join(tempDir, 'src'))).toBe(true);
+    });
+
+    it('should not overwrite existing src directory', () => {
+      const srcDir = path.join(tempDir, 'src');
+      fs.ensureDirSync(srcDir);
+      const existingFile = path.join(srcDir, 'existing.ts');
+      fs.writeFileSync(existingFile, '// existing file');
+
+      generateConfig(tempDir, ['stdio'], false);
+
+      // Existing file should still exist
+      expect(fs.existsSync(existingFile)).toBe(true);
+      // Runtime config should also exist
+      expect(fs.existsSync(path.join(srcDir, 'mcpi-runtime-config.ts'))).toBe(true);
+    });
+  });
+});
+