@kya-os/create-mcpi-app 1.7.38-canary.2 → 1.7.38

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

@@ -1,337 +0,0 @@
-/**
- * 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

@@ -1,312 +0,0 @@
-/**
- * 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);
-    });
-  });
-});
-