@mexty/cli 1.0.1

package/src/utils/api.ts

@@ -0,0 +1,240 @@
+import axios, { AxiosInstance, AxiosResponse } from 'axios';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface Block {
+  _id: string;
+  blockType: string;
+  title: string;
+  description: string;
+  gitUrl?: string;
+  courseId?: string;
+  courseName?: string;
+  allowedBrickTypes: string[];
+  allowedBlockTypes?: string[];
+  scope: ('library' | 'user-store' | 'published-store')[];
+  content: any[];
+  bundlePath?: string;
+  federationUrl?: string;
+  buildStatus?: 'pending' | 'building' | 'success' | 'failed';
+  buildError?: string;
+  lastBuilt?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateBlockRequest {
+  blockType: string;
+  title: string;
+  description: string;
+  gitUrl?: string;
+  courseId?: string;
+  courseName?: string;
+  allowedBrickTypes: string[];
+  allowedBlockTypes?: string[];
+  scope: string[];
+  content?: any[];
+}
+
+export interface ForkBlockRequest {
+  blockId: string;
+  title?: string;
+  description?: string;
+}
+
+export interface SaveAndBundleRequest {
+  blockId: string;
+}
+
+export interface AuthResponse {
+  success: boolean;
+  message: string;
+  token?: string;
+  user?: {
+    id: string;
+    email: string;
+    fullName?: string;
+    occupation?: string;
+    isProfileComplete: boolean;
+  };
+}
+
+export interface LoginRequest {
+  email: string;
+  otp: string;
+}
+
+class ApiClient {
+  private client: AxiosInstance;
+  private baseUrl: string;
+  private tokenPath: string;
+
+  constructor(baseUrl: string = 'http://localhost:3001') {
+    this.baseUrl = baseUrl;
+    this.tokenPath = path.join(os.homedir(), '.mext', 'auth.json');
+    
+    this.client = axios.create({
+      baseURL: baseUrl,
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    // Add request interceptor to include auth token
+    this.client.interceptors.request.use(
+      (config) => {
+        const token = this.getStoredToken();
+        if (token) {
+          config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+
+    // Add response interceptor for error handling
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (error.response?.status === 401) {
+          console.error(chalk.red('Authentication required. Please login first: mexty login'));
+          this.clearStoredToken();
+        } else if (error.response) {
+          console.error(chalk.red(`API Error ${error.response.status}: ${error.response.data?.error || error.message}`));
+        } else if (error.request) {
+          console.error(chalk.red('Network Error: Could not reach MEXT server'));
+          console.error(chalk.yellow(`Make sure the server is running at ${this.baseUrl}`));
+        } else {
+          console.error(chalk.red(`Request Error: ${error.message}`));
+        }
+        throw error;
+      }
+    );
+  }
+
+  private getStoredToken(): string | null {
+    try {
+      if (fs.existsSync(this.tokenPath)) {
+        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
+        return authData.token || null;
+      }
+    } catch (error) {
+      // Ignore errors reading token file
+    }
+    return null;
+  }
+
+  private storeToken(token: string, user: any): void {
+    try {
+      const authDir = path.dirname(this.tokenPath);
+      if (!fs.existsSync(authDir)) {
+        fs.mkdirSync(authDir, { recursive: true });
+      }
+      
+      const authData = {
+        token,
+        user,
+        timestamp: new Date().toISOString()
+      };
+      
+      fs.writeFileSync(this.tokenPath, JSON.stringify(authData, null, 2));
+    } catch (error: any) {
+      console.warn(chalk.yellow(`Warning: Could not store auth token: ${error.message}`));
+    }
+  }
+
+  private clearStoredToken(): void {
+    try {
+      if (fs.existsSync(this.tokenPath)) {
+        fs.unlinkSync(this.tokenPath);
+      }
+    } catch (error) {
+      // Ignore errors clearing token file
+    }
+  }
+
+  public isAuthenticated(): boolean {
+    return this.getStoredToken() !== null;
+  }
+
+  public getStoredUser(): any {
+    try {
+      if (fs.existsSync(this.tokenPath)) {
+        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
+        return authData.user || null;
+      }
+    } catch (error) {
+      // Ignore errors reading user data
+    }
+    return null;
+  }
+
+  async createBlock(data: CreateBlockRequest): Promise<Block> {
+    const response: AxiosResponse<Block> = await this.client.post('/api/blocks', data);
+    return response.data;
+  }
+
+  async forkBlock(data: ForkBlockRequest): Promise<Block> {
+    const response: AxiosResponse<Block> = await this.client.post('/api/blocks/fork', data);
+    return response.data;
+  }
+
+  async deleteBlock(blockId: string): Promise<void> {
+    await this.client.delete(`/api/blocks/${blockId}`);
+  }
+
+  async getBlock(blockId: string): Promise<Block> {
+    const response: AxiosResponse<Block> = await this.client.get(`/api/blocks/${blockId}`);
+    return response.data;
+  }
+
+  async saveAndBundle(data: SaveAndBundleRequest): Promise<any> {
+    const response = await this.client.post('/api/blocks/save-and-bundle', data);
+    return response.data;
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      await this.client.get('/api/health');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async requestOTP(email: string): Promise<AuthResponse> {
+    const response: AxiosResponse<AuthResponse> = await this.client.post('/api/auth/request-otp', { email });
+    return response.data;
+  }
+
+  async verifyOTP(email: string, otp: string): Promise<AuthResponse> {
+    const response: AxiosResponse<AuthResponse> = await this.client.post('/api/auth/verify-otp', { email, otp });
+    const data = response.data;
+    
+    if (data.success && data.token && data.user) {
+      this.storeToken(data.token, data.user);
+    }
+    
+    return data;
+  }
+
+  async logout(): Promise<void> {
+    try {
+      await this.client.post('/api/auth/logout');
+    } catch (error) {
+      // Ignore logout errors
+    } finally {
+      this.clearStoredToken();
+    }
+  }
+
+  setBaseUrl(url: string): void {
+    this.baseUrl = url;
+    this.client.defaults.baseURL = url;
+  }
+}
+
+export const apiClient = new ApiClient(); 

package/src/utils/auth.ts

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import { apiClient } from './api';
+
+export function checkAuthentication(): boolean {
+  if (!apiClient.isAuthenticated()) {
+    console.error(chalk.red('❌ Authentication required'));
+    console.log(chalk.yellow('   Please login first: mexty login'));
+    return false;
+  }
+  return true;
+}
+
+export function getAuthenticatedUser(): any {
+  return apiClient.getStoredUser();
+}
+
+export function requireAuthentication(): void {
+  if (!checkAuthentication()) {
+    process.exit(1);
+  }
+} 

package/src/utils/git.ts

@@ -0,0 +1,194 @@
+import simpleGit, { SimpleGit } from 'simple-git';
+import path from 'path';
+import fs from 'fs';
+import chalk from 'chalk';
+
+// Simple spinner implementation since ora v5 has import issues
+class SimpleSpinner {
+  private message: string;
+  private interval: NodeJS.Timeout | null = null;
+  private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  private currentFrame = 0;
+
+  constructor(message: string) {
+    this.message = message;
+  }
+
+  start(): this {
+    process.stdout.write(this.message);
+    this.interval = setInterval(() => {
+      process.stdout.write(`\r${this.frames[this.currentFrame]} ${this.message}`);
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    }, 80);
+    return this;
+  }
+
+  succeed(message: string): void {
+    this.stop();
+    console.log(`\r✅ ${message}`);
+  }
+
+  fail(message: string): void {
+    this.stop();
+    console.log(`\r❌ ${message}`);
+  }
+
+  private stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    process.stdout.write('\r');
+  }
+}
+
+function ora(message: string): SimpleSpinner {
+  return new SimpleSpinner(message);
+}
+
+export class GitManager {
+  private git: SimpleGit;
+
+  constructor(cwd?: string) {
+    this.git = simpleGit(cwd);
+  }
+
+  /**
+   * Clone a repository to a local directory
+   */
+  async cloneRepository(repoUrl: string, targetDir: string): Promise<void> {
+    const spinner = ora(`Cloning repository from ${repoUrl}...`).start();
+
+    try {
+      // Ensure target directory doesn't exist
+      if (fs.existsSync(targetDir)) {
+        spinner.fail(chalk.red(`Directory ${targetDir} already exists`));
+        throw new Error(`Directory ${targetDir} already exists`);
+      }
+
+      // Clone the repository
+      await this.git.clone(repoUrl, targetDir);
+      
+      spinner.succeed(chalk.green(`Repository cloned to ${targetDir}`));
+    } catch (error: any) {
+      spinner.fail(chalk.red(`Failed to clone repository: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * Check if current directory is a Git repository
+   */
+  async isGitRepository(dir?: string): Promise<boolean> {
+    try {
+      const git = dir ? simpleGit(dir) : this.git;
+      await git.status();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get the current repository's remote URL
+   */
+  async getRemoteUrl(dir?: string): Promise<string | null> {
+    try {
+      const git = dir ? simpleGit(dir) : this.git;
+      const remotes = await git.getRemotes(true);
+      const origin = remotes.find(remote => remote.name === 'origin');
+      return origin?.refs?.fetch || null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if there are uncommitted changes
+   */
+  async hasUncommittedChanges(dir?: string): Promise<boolean> {
+    try {
+      const git = dir ? simpleGit(dir) : this.git;
+      const status = await git.status();
+      return !status.isClean();
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Push current branch to remote
+   */
+  async pushToRemote(dir?: string): Promise<void> {
+    const spinner = ora('Pushing changes to remote repository...').start();
+
+    try {
+      const git = dir ? simpleGit(dir) : this.git;
+      
+      // Get current branch
+      const status = await git.status();
+      const currentBranch = status.current;
+
+      if (!currentBranch) {
+        throw new Error('No current branch found');
+      }
+
+      // Push to remote
+      await git.push('origin', currentBranch);
+      
+      spinner.succeed(chalk.green('Changes pushed to remote repository'));
+    } catch (error: any) {
+      spinner.fail(chalk.red(`Failed to push changes: ${error.message}`));
+      throw error;
+    }
+  }
+
+  /**
+   * Get repository information
+   */
+  async getRepositoryInfo(dir?: string): Promise<{
+    branch: string;
+    remoteUrl: string | null;
+    hasChanges: boolean;
+  }> {
+    const git = dir ? simpleGit(dir) : this.git;
+    
+    const status = await git.status();
+    const remoteUrl = await this.getRemoteUrl(dir);
+    
+    return {
+      branch: status.current || 'unknown',
+      remoteUrl,
+      hasChanges: !status.isClean()
+    };
+  }
+
+  /**
+   * Extract repository name from URL
+   */
+  static extractRepoName(gitUrl: string): string {
+    // Handle both SSH and HTTPS URLs
+    const match = gitUrl.match(/\/([^\/]+?)(?:\.git)?$/);
+    if (match) {
+      return match[1];
+    }
+    
+    // Fallback: use the last part of the URL
+    const parts = gitUrl.split('/');
+    return parts[parts.length - 1].replace('.git', '');
+  }
+
+  /**
+   * Validate Git URL format
+   */
+  static isValidGitUrl(url: string): boolean {
+    const patterns = [
+      /^https:\/\/github\.com\/[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
+      /^git@github\.com:[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
+      /^https:\/\/gitlab\.com\/[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
+      /^git@gitlab\.com:[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/
+    ];
+
+    return patterns.some(pattern => pattern.test(url));
+  }
+} 

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}