@mexty/cli 1.0.1

package/src/commands/publish.ts

@@ -0,0 +1,159 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { apiClient } from '../utils/api';
+import { GitManager } from '../utils/git';
+import { createInterface } from 'readline';
+import { syncCommand } from './sync';
+import { requireAuthentication, getAuthenticatedUser } from '../utils/auth';
+
+// Simple confirmation function
+async function confirm(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(`${question} (y/N): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().trim() === 'y' || answer.toLowerCase().trim() === 'yes');
+    });
+  });
+}
+
+// Extract block ID from package.json or git URL
+async function findBlockId(): Promise<string | null> {
+  const packageJsonPath = path.join(process.cwd(), 'package.json');
+  
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      
+      // Look for block ID in package.json name or description
+      if (packageJson.name && packageJson.name.startsWith('block-')) {
+        return packageJson.name.replace('block-', '');
+      }
+      
+      // Look in description for block ID pattern
+      if (packageJson.description) {
+        const match = packageJson.description.match(/block[:\s]+([a-f0-9]{24})/i);
+        if (match) {
+          return match[1];
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow('⚠️  Could not parse package.json'));
+    }
+  }
+
+  // Try to extract from git remote URL
+  try {
+    const gitManager = new GitManager();
+    const remoteUrl = await gitManager.getRemoteUrl();
+    
+    if (remoteUrl) {
+      const match = remoteUrl.match(/block-([a-f0-9]{24})/);
+      if (match) {
+        return match[1];
+      }
+    }
+  } catch (error) {
+    // Ignore git errors
+  }
+
+  return null;
+}
+
+export async function publishCommand(): Promise<void> {
+  try {
+    // Check authentication first
+    requireAuthentication();
+    
+    const user = getAuthenticatedUser();
+    console.log(chalk.blue('🚀 Publishing block...'));
+    console.log(chalk.gray(`   User: ${user?.fullName || user?.email || 'Unknown'}`));
+
+    // Check if we're in a git repository
+    const gitManager = new GitManager();
+    const isGitRepo = await gitManager.isGitRepository();
+    
+    if (!isGitRepo) {
+      console.error(chalk.red('❌ Not a git repository. Please run this command from a block repository.'));
+      process.exit(1);
+    }
+
+    // Get repository information
+    const repoInfo = await gitManager.getRepositoryInfo();
+    console.log(chalk.gray(`   Current branch: ${repoInfo.branch}`));
+    console.log(chalk.gray(`   Remote URL: ${repoInfo.remoteUrl}`));
+
+    // Find block ID
+    const blockId = await findBlockId();
+    if (!blockId) {
+      console.error(chalk.red('❌ Could not determine block ID from repository.'));
+      console.error(chalk.yellow('   Make sure you are in a block repository created with mexty'));
+      process.exit(1);
+    }
+
+    console.log(chalk.gray(`   Block ID: ${blockId}`));
+
+    // Check for uncommitted changes
+    if (repoInfo.hasChanges) {
+      console.log(chalk.yellow('⚠️  You have uncommitted changes.'));
+      console.log(chalk.gray('   Please commit your changes before publishing:'));
+      console.log(chalk.gray('   git add . && git commit -m "Your commit message"'));
+      
+      const proceed = await confirm('Do you want to continue anyway?');
+      if (!proceed) {
+        console.log(chalk.yellow('🚫 Publishing cancelled.'));
+        return;
+      }
+    }
+
+    // Ask user to push changes
+    console.log(chalk.blue('\n📤 Push your changes to GitHub:'));
+    console.log(chalk.gray(`   git push origin ${repoInfo.branch}`));
+    
+    const pushed = await confirm('Have you pushed your changes to GitHub?');
+    if (!pushed) {
+      console.log(chalk.yellow('🚫 Please push your changes first and then run publish again.'));
+      return;
+    }
+
+    // Trigger save and bundle
+    console.log(chalk.yellow('📡 Triggering build and bundle process...'));
+    
+    try {
+      const result = await apiClient.saveAndBundle({ blockId });
+      
+      console.log(chalk.green('✅ Block published successfully!'));
+      console.log(chalk.gray(`   Bundle Path: ${result.bundlePath}`));
+      console.log(chalk.gray(`   Federation URL: ${result.federationUrl}`));
+      
+      if (result.message) {
+        console.log(chalk.blue(`   ${result.message}`));
+      }
+
+      // Automatically sync registry after successful publish
+      console.log(chalk.blue('\n🔄 Auto-syncing registry...'));
+      try {
+        await syncCommand();
+        console.log(chalk.green('✅ Registry synced! Your block is now available as a named component.'));
+      } catch (syncError: any) {
+        console.warn(chalk.yellow(`⚠️ Registry sync failed: ${syncError.message}`));
+        console.log(chalk.gray('   You can manually sync later with: mexty sync'));
+        // Don't fail the publish if sync fails - it's not critical
+      }
+      
+    } catch (buildError: any) {
+      console.error(chalk.red(`❌ Build failed: ${buildError.message}`));
+      console.log(chalk.yellow('   Check the server logs for more details.'));
+      process.exit(1);
+    }
+
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to publish block: ${error.message}`));
+    process.exit(1);
+  }
+} 

package/src/commands/sync.ts

@@ -0,0 +1,284 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { apiClient } from '../utils/api';
+
+interface BlockRegistryEntry {
+  blockId: string;
+  componentName: string;
+  author?: string; // Username of the author
+  title: string;
+  description: string;
+  version?: string;
+  tags?: string[];
+  lastUpdated: string;
+}
+
+interface BlockRegistry {
+  [componentName: string]: BlockRegistryEntry;
+}
+
+interface AuthorNamespaceRegistry {
+  [author: string]: {
+    [componentName: string]: BlockRegistryEntry;
+  };
+}
+
+export async function syncCommand(): Promise<void> {
+  try {
+    console.log(chalk.blue('🔄 Syncing block registry...'));
+
+    // Fetch registry from server
+    console.log(chalk.yellow('📡 Fetching registry from server...'));
+    const response = await fetch('http://localhost:3001/api/blocks/registry');
+    
+    if (!response.ok) {
+      throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    const registry: BlockRegistry = data.registry;
+    const authorRegistry: AuthorNamespaceRegistry = data.authorRegistry;
+    const meta = data.meta;
+
+    console.log(chalk.green(`✅ Registry fetched successfully!`));
+    console.log(chalk.gray(`   Total blocks: ${meta.totalBlocks}`));
+    console.log(chalk.gray(`   Total components: ${meta.totalComponents}`));
+    console.log(chalk.gray(`   Total authors: ${meta.totalAuthors || 0}`));
+    console.log(chalk.gray(`   Last updated: ${meta.lastUpdated}`));
+
+    if (Object.keys(registry).length === 0) {
+      console.log(chalk.yellow('⚠️  No components found in registry.'));
+      console.log(chalk.gray('   Make sure you have built some blocks first using "mexty publish"'));
+      return;
+    }
+
+    // Display available components
+    console.log(chalk.blue('\n📋 Available components (global namespace):'));
+    for (const [componentName, entry] of Object.entries(registry)) {
+      console.log(chalk.green(`   ${componentName}${entry.author ? chalk.gray(` (by ${entry.author})`) : ''}`));
+      console.log(chalk.gray(`      Block ID: ${entry.blockId}`));
+      console.log(chalk.gray(`      Title: ${entry.title}`));
+      console.log(chalk.gray(`      Description: ${entry.description.substring(0, 60)}${entry.description.length > 60 ? '...' : ''}`));
+      console.log(chalk.gray(`      Tags: ${entry.tags?.join(', ') || 'none'}`));
+      console.log('');
+    }
+
+    // Display author namespaces
+    if (Object.keys(authorRegistry).length > 0) {
+      console.log(chalk.blue('\n👤 Author namespaces:'));
+      for (const [author, components] of Object.entries(authorRegistry)) {
+        console.log(chalk.cyan(`   @${author}:`));
+        for (const [componentName, entry] of Object.entries(components)) {
+          console.log(chalk.green(`     ${componentName}`));
+          console.log(chalk.gray(`        Block ID: ${entry.blockId}`));
+          console.log(chalk.gray(`        Title: ${entry.title}`));
+        }
+        console.log('');
+      }
+    }
+
+    // Generate named exports file and author entry files
+    const mextBlockPath = findMextBlockPath();
+    if (mextBlockPath) {
+      console.log(chalk.blue('🔧 Updating mext-block exports...'));
+      await generateNamedExports(mextBlockPath, registry, authorRegistry);
+      await generateAuthorEntryFiles(mextBlockPath, authorRegistry);
+      console.log(chalk.green(`✅ Exports updated in ${mextBlockPath}`));
+      console.log(chalk.gray(`   Generated ${Object.keys(authorRegistry).length} author entry files`));
+    } else {
+      console.log(chalk.yellow('⚠️  mext-block package not found locally.'));
+      console.log(chalk.gray('   Named exports file not generated.'));
+    }
+
+    console.log(chalk.green('\n🎉 Registry sync completed!'));
+
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to sync registry: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Find the mext-block package path
+ */
+function findMextBlockPath(): string | null {
+  // Look for mext-block in common locations
+  const possiblePaths = [
+    path.join(process.cwd(), '..', 'mext-block'),
+    path.join(process.cwd(), 'mext-block'),
+    path.join(process.cwd(), '..', '..', 'mext-block'),
+  ];
+
+  for (const possiblePath of possiblePaths) {
+    if (fs.existsSync(path.join(possiblePath, 'package.json'))) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(possiblePath, 'package.json'), 'utf8'));
+        if (packageJson.name === '@mexty/block' || packageJson.name === 'mextblock') {
+          return possiblePath;
+        }
+      } catch (error) {
+        // Ignore invalid package.json files
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Generate named exports file for the mext-block package
+ */
+async function generateNamedExports(mextBlockPath: string, registry: BlockRegistry, authorRegistry: AuthorNamespaceRegistry): Promise<void> {
+  const namedExportsPath = path.join(mextBlockPath, 'src', 'namedExports.ts');
+  
+  // Generate the file content
+  const content = `// Auto-generated file - DO NOT EDIT MANUALLY
+// Generated on: ${new Date().toISOString()}
+// Total components: ${Object.keys(registry).length}
+// Total authors: ${Object.keys(authorRegistry).length}
+
+import { createNamedBlock } from './components/NamedBlock';
+import { createAuthorBlock } from './components/AuthorBlock';
+
+// ===== GLOBAL NAMESPACE COMPONENTS =====
+${Object.entries(registry).map(([componentName, entry]) => 
+`// ${entry.title}${entry.author ? ` (by ${entry.author})` : ''}
+// Block ID: ${entry.blockId}
+// Description: ${entry.description}
+// Tags: ${entry.tags?.join(', ') || 'none'}
+export const ${componentName} = createNamedBlock('${componentName}');`
+).join('\n\n')}
+
+// Export all global components as an object for convenience
+export const NamedComponents = {
+${Object.keys(registry).map(componentName => `  ${componentName},`).join('\n')}
+};
+
+// Note: Author-specific components are now available via direct imports:
+// import { ComponentName } from '@mexty/block/authorname'
+// Available authors: ${Object.keys(authorRegistry).join(', ')}
+
+// Registry metadata
+export const registryMetadata = {
+  totalComponents: ${Object.keys(registry).length},
+  totalAuthors: ${Object.keys(authorRegistry).length},
+  lastGenerated: '${new Date().toISOString()}',
+  components: {
+${Object.entries(registry).map(([componentName, entry]) => 
+`    ${componentName}: {
+      blockId: '${entry.blockId}',
+      title: '${entry.title}',
+      description: '${entry.description.replace(/'/g, "\\'")}',
+      author: '${entry.author || ''}',
+      tags: [${entry.tags?.map(tag => `'${tag}'`).join(', ') || ''}],
+      lastUpdated: '${entry.lastUpdated}'
+    },`
+).join('\n')}
+  },
+  authors: {
+${Object.entries(authorRegistry).map(([author, components]) => 
+`    ${author}: {
+${Object.entries(components).map(([componentName, entry]) => 
+`      ${componentName}: {
+        blockId: '${entry.blockId}',
+        title: '${entry.title}',
+        description: '${entry.description.replace(/'/g, "\\'")}',
+        tags: [${entry.tags?.map(tag => `'${tag}'`).join(', ') || ''}],
+        lastUpdated: '${entry.lastUpdated}'
+      },`
+).join('\n')}
+    },`
+).join('\n')}
+  }
+};
+`;
+
+  // Ensure directory exists
+  const srcDir = path.dirname(namedExportsPath);
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true });
+  }
+
+  // Write the file
+  fs.writeFileSync(namedExportsPath, content, 'utf8');
+
+  // Update the main index.ts to include these exports
+  const indexPath = path.join(mextBlockPath, 'src', 'index.ts');
+  if (fs.existsSync(indexPath)) {
+    let indexContent = fs.readFileSync(indexPath, 'utf8');
+    
+    // Add export for named exports if not already present
+    if (!indexContent.includes('export * from \'./namedExports\'')) {
+      indexContent += '\n// Auto-generated named exports\nexport * from \'./namedExports\';\n';
+      fs.writeFileSync(indexPath, indexContent, 'utf8');
+    }
+  }
+}
+
+/**
+ * Generate author-specific entry files for direct imports
+ */
+async function generateAuthorEntryFiles(mextBlockPath: string, authorRegistry: AuthorNamespaceRegistry): Promise<void> {
+  const authorsDir = path.join(mextBlockPath, 'src', 'authors');
+  
+  // Clean up existing author files
+  if (fs.existsSync(authorsDir)) {
+    fs.rmSync(authorsDir, { recursive: true, force: true });
+  }
+  
+  // Create authors directory
+  fs.mkdirSync(authorsDir, { recursive: true });
+  
+  // Generate an entry file for each author
+  for (const [author, components] of Object.entries(authorRegistry)) {
+    const authorDir = path.join(authorsDir, author);
+    fs.mkdirSync(authorDir, { recursive: true });
+    
+    const authorEntryPath = path.join(authorDir, 'index.ts');
+    
+    // Generate the author's entry file content
+    const content = `// Auto-generated author entry file for ${author}
+// Generated on: ${new Date().toISOString()}
+// Total components: ${Object.keys(components).length}
+
+import { createAuthorBlock } from '../../components/AuthorBlock';
+
+${Object.entries(components).map(([componentName, entry]) => 
+`// ${entry.title}
+// Block ID: ${entry.blockId}
+// Description: ${entry.description}
+// Tags: ${entry.tags?.join(', ') || 'none'}
+export const ${componentName} = createAuthorBlock('${author}', '${componentName}');`
+).join('\n\n')}
+
+// Export all components as default for convenience
+export default {
+${Object.keys(components).map(componentName => `  ${componentName},`).join('\n')}
+};
+
+// Author metadata
+export const authorMetadata = {
+  author: '${author}',
+  totalComponents: ${Object.keys(components).length},
+  lastGenerated: '${new Date().toISOString()}',
+  components: {
+${Object.entries(components).map(([componentName, entry]) => 
+`    ${componentName}: {
+      blockId: '${entry.blockId}',
+      title: '${entry.title}',
+      description: '${entry.description.replace(/'/g, "\\'")}',
+      tags: [${entry.tags?.map(tag => `'${tag}'`).join(', ') || ''}],
+      lastUpdated: '${entry.lastUpdated}'
+    },`
+).join('\n')}
+  }
+};
+`;
+
+    // Write the author entry file
+    fs.writeFileSync(authorEntryPath, content, 'utf8');
+    
+    console.log(chalk.gray(`   Created entry file for ${author} (${Object.keys(components).length} components)`));
+  }
+} 

package/src/index.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loginCommand } from './commands/login';
+import { createCommand } from './commands/create';
+import { forkCommand } from './commands/fork';
+import { deleteCommand } from './commands/delete';
+import { publishCommand } from './commands/publish';
+import { syncCommand } from './commands/sync';
+import { apiClient } from './utils/api';
+
+const program = new Command();
+
+// CLI Configuration
+program
+  .name('mexty')
+  .description('MEXT CLI for managing React microfrontend blocks and components')
+  .version('1.0.0');
+
+// Add commands
+program
+  .command('login')
+  .description('Authenticate with MEXT')
+  .action(loginCommand);
+
+program
+  .command('logout')
+  .description('Logout from MEXT')
+  .action(async () => {
+    try {
+      if (!apiClient.isAuthenticated()) {
+        console.log(chalk.yellow('⚠️  You are not logged in'));
+        return;
+      }
+      
+      await apiClient.logout();
+      console.log(chalk.green('✅ Logged out successfully'));
+    } catch (error: any) {
+      console.error(chalk.red(`❌ Logout failed: ${error.message}`));
+    }
+  });
+
+program
+  .command('create <name>')
+  .description('Create a new React microfrontend block')
+  .option('-d, --description <description>', 'Block description')
+  .option('-t, --type <type>', 'Block type', 'custom')
+  .action(createCommand);
+
+program
+  .command('fork <blockId>')
+  .description('Fork an existing block and clone its repository')
+  .action(forkCommand);
+
+program
+  .command('delete <blockId>')
+  .description('Delete a block (requires ownership)')
+  .action(deleteCommand);
+
+program
+  .command('publish')
+  .description('Publish current block with automatic bundling')
+  .action(publishCommand);
+
+program
+  .command('sync')
+  .description('Sync block registry and update typed exports')
+  .action(syncCommand);
+
+// Error handling
+program.on('command:*', () => {
+  console.error(chalk.red(`Invalid command: ${program.args.join(' ')}`));
+  console.log(chalk.yellow('See --help for a list of available commands.'));
+  process.exit(1);
+});
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}