codecrypto-cli 1.0.7 → 1.0.9

package/src/commands/auth.ts

@@ -34,6 +34,7 @@ export const authCommand = new Command('auth')
   .option('--server-url <url>', 'Server URL', API_BASE_URL)
   .option('--poll-interval <seconds>', 'Polling interval in seconds', '3')
   .option('--debug', 'Show debug information', false)
+  .option('--force', 'Force creation of new token even if one exists', false)
   .action(async (options) => {
     console.log(chalk.blue('\n🔐 CodeCrypto Authentication\n'));
 
@@ -41,6 +42,40 @@ export const authCommand = new Command('auth')
     const pollInterval = parseInt(options.pollInterval || '3', 10) * 1000;
 
     try {
+      // Verificar si ya existe un token guardado
+      const homeDir = os.homedir();
+      const codecryptoDir = path.join(homeDir, '.codecrypto');
+      const tokenFile = path.join(codecryptoDir, 'token.json');
+      
+      // Verificar si ya existe un token y si se debe crear uno nuevo
+      if (!options.force && fs.existsSync(tokenFile)) {
+        try {
+          const existingTokenData = JSON.parse(fs.readFileSync(tokenFile, 'utf-8'));
+          if (existingTokenData.token && existingTokenData.email) {
+            console.log(chalk.yellow('⚠️  Found existing authentication token'));
+            console.log(chalk.gray(`  Email: ${chalk.cyan(existingTokenData.email)}`));
+            console.log(chalk.gray(`  Created: ${chalk.cyan(existingTokenData.createdAt || 'unknown')}`));
+            console.log(chalk.yellow('\n💡 You already have a valid token. Creating a new one will generate a new token in the database.'));
+            console.log(chalk.yellow('   To use the existing token, you can skip this authentication.'));
+            console.log(chalk.yellow('   To create a new token, use: codecrypto auth --force\n'));
+            
+            // Por defecto, no crear un nuevo token si ya existe uno
+            console.log(chalk.green('✅ Using existing token. No new token will be created.'));
+            console.log(chalk.gray(`  Token location: ${chalk.cyan(tokenFile)}\n`));
+            process.exit(0);
+          }
+        } catch (error) {
+          // Si hay error leyendo el token existente, continuar con la creación
+          if (options.debug) {
+            console.log(chalk.yellow(`[DEBUG] Could not read existing token: ${error}`));
+          }
+        }
+      }
+      
+      if (options.force && fs.existsSync(tokenFile)) {
+        console.log(chalk.yellow('⚠️  Force flag detected. Creating new token (this will not invalidate the previous one).\n'));
+      }
+
       // Paso 1: Solicitar código de autenticación
       const requestSpinner = ora('Requesting authentication code...').start();
       
@@ -59,6 +94,12 @@ export const authCommand = new Command('auth')
 
         const jsonData = await response.json();
         
+        // Mostrar respuesta raw
+        console.log(chalk.gray('\n[RAW RESPONSE] POST /api/tokens:'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(JSON.stringify(jsonData, null, 2));
+        console.log(chalk.gray('─'.repeat(60)));
+        
         if (options.debug) {
           console.log(chalk.gray(`\n[DEBUG] POST Response: ${JSON.stringify(jsonData, null, 2)}`));
         }
@@ -122,7 +163,7 @@ export const authCommand = new Command('auth')
         process.exit(1);
       }
 
-      const tokenUrl = `${serverUrl}/token`;
+      const tokenUrl = `${serverUrl}/login?token=${tokenId}`;
 
       // Mostrar información al usuario con el ID REAL obtenido
       console.log(chalk.green('\n✅ Authentication code generated!'));
@@ -139,6 +180,7 @@ export const authCommand = new Command('auth')
       
       let verifiedToken: string | null = null;
       let tokenEmail: string | null = null;
+      let verificationData: any = null; // Guardar toda la respuesta de verificación
       let attempts = 0;
 
       // Función helper para extraer el token JWT y el email de la respuesta
@@ -233,15 +275,24 @@ export const authCommand = new Command('auth')
           if (verifyResponse.ok) {
             const verifyData = await verifyResponse.json();
             
+            // Mostrar respuesta raw solo en el primer intento exitoso o si hay token
+            const extracted = extractToken(verifyData);
+            if (extracted.token && !verifiedToken) {
+              console.log(chalk.gray('\n[RAW RESPONSE] GET /api/tokens/{id}:'));
+              console.log(chalk.gray('─'.repeat(60)));
+              //console.log(JSON.stringify(verifyData, null, 2));
+              console.log(chalk.gray('─'.repeat(60)));
+            }
+            
             if (options.debug) {
               console.log(chalk.gray(`\n[DEBUG] Attempt ${attempts + 1} - Response: ${JSON.stringify(verifyData, null, 2)}`));
             }
             
             // Intentar extraer el token
-            const extracted = extractToken(verifyData);
             if (extracted.token) {
               verifiedToken = extracted.token;
               tokenEmail = extracted.email;
+              verificationData = verifyData; // Guardar toda la respuesta
               break;
             }
           } else {
@@ -275,9 +326,7 @@ export const authCommand = new Command('auth')
       pollSpinner.succeed('Token verified successfully');
 
       // Paso 3: Guardar token en ~/.codecrypto
-      const homeDir = os.homedir();
-      const codecryptoDir = path.join(homeDir, '.codecrypto');
-      const tokenFile = path.join(codecryptoDir, 'token.json');
+      // Reutilizar las variables ya declaradas arriba
 
       const saveSpinner = ora('Saving authentication token...').start();
 
@@ -287,14 +336,27 @@ export const authCommand = new Command('auth')
           fs.mkdirSync(codecryptoDir, { recursive: true });
         }
 
-        // Guardar token
-        const tokenContent = {
+        // Guardar datos básicos y extraer globals de la respuesta
+        const tokenContent: any = {
+          // Datos básicos extraídos
           token: verifiedToken,
           email: tokenEmail,
+          tokenId: tokenId,
+          code: code,
           serverUrl: serverUrl,
-          createdAt: new Date().toISOString(),
+          verifiedAt: new Date().toISOString(),
         };
 
+        // Extraer studentGlobalsAll y adminGlobals de verificationResponse.globals
+        if (verificationData && verificationData.globals) {
+          if (verificationData.globals.studentGlobalsAll) {
+            tokenContent.studentGlobalsAll = verificationData.globals.studentGlobalsAll;
+          }
+          if (verificationData.globals.adminGlobals) {
+            tokenContent.adminGlobals = verificationData.globals.adminGlobals;
+          }
+        }
+
         fs.writeFileSync(tokenFile, JSON.stringify(tokenContent, null, 2), 'utf-8');
         saveSpinner.succeed('Token saved successfully');
       } catch (error: any) {
@@ -308,6 +370,7 @@ export const authCommand = new Command('auth')
       if (tokenEmail) {
         console.log(chalk.gray(`  Email: ${chalk.cyan(tokenEmail)}`));
       }
+      console.log(chalk.gray(`  Token ID: ${chalk.cyan(tokenId)}`));
       console.log('');
 
     } catch (error: any) {

package/src/commands/deploy-sc.ts

@@ -4,6 +4,7 @@ import ora from 'ora';
 import { execSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 export const deployScCommand = new Command('deploy-sc')
   .description('Deploy smart contract using Foundry')
@@ -15,6 +16,7 @@ export const deployScCommand = new Command('deploy-sc')
   .option('--verify', 'Verify contract on block explorer', false)
   .option('--broadcast', 'Broadcast the transaction', true)
   .option('--slow', 'Use slow mode for deployment', false)
+  .option('--debug', 'Show debug information', false)
   .action(async (scriptPath: string, options) => {
     console.log(chalk.blue('\n🔷 CodeCrypto Smart Contract Deployment\n'));
 
@@ -168,6 +170,29 @@ export const deployScCommand = new Command('deploy-sc')
 
         deploySpinner.succeed('Smart contract desplegado exitosamente');
         
+        // Buscar y leer el archivo de transacciones generado por Foundry (solo si se hizo broadcast)
+        if (options.broadcast) {
+          const uploadSpinner = ora('Uploading deployment results to database...').start();
+          try {
+            await uploadDeploymentResults({
+              scriptPath: scriptRelativePath,
+              foundryProjectDir,
+              rpcUrl: options.url,
+              privateKey: privateKey || (options.account !== undefined ? `account-${options.account}` : null),
+              debug: options.debug || false,
+            });
+            uploadSpinner.succeed('Deployment results uploaded successfully');
+          } catch (uploadError: any) {
+            uploadSpinner.warn(`Failed to upload deployment results: ${uploadError.message}`);
+            console.log(chalk.yellow('   Deployment was successful, but results were not saved to database'));
+            if (uploadError.message.includes('run-latest.json')) {
+              console.log(chalk.yellow('   Note: Make sure --broadcast flag is used to generate transaction files'));
+            }
+          }
+        } else {
+          console.log(chalk.gray('\n💡 Deployment results not uploaded (--broadcast was not used)'));
+        }
+        
         console.log(chalk.green('\n✅ Deployment completed successfully!'));
         console.log(chalk.gray('Contract details:'));
         console.log(chalk.white(`  Script: ${chalk.cyan(scriptRelativePath)}`));
@@ -198,3 +223,160 @@ export const deployScCommand = new Command('deploy-sc')
     }
   });
 
+// Función para subir los resultados del despliegue a la base de datos
+async function uploadDeploymentResults(config: {
+  scriptPath: string;
+  foundryProjectDir: string;
+  rpcUrl: string;
+  privateKey: string | null;
+  debug?: boolean;
+}) {
+  // 1. Leer token.json para obtener email y serverUrl
+  const tokenFilePath = path.join(os.homedir(), '.codecrypto', 'token.json');
+  if (!fs.existsSync(tokenFilePath)) {
+    throw new Error('Token file not found. Please run "codecrypto auth" first.');
+  }
+
+  let tokenData: any;
+  try {
+    tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf-8'));
+  } catch (error: any) {
+    throw new Error(`Failed to read token file: ${error.message}`);
+  }
+
+  const email = tokenData.email;
+  const serverUrl = tokenData.serverUrl || 'http://localhost:3000';
+  const token = tokenData.token;
+
+  if (!email) {
+    throw new Error('Email not found in token.json');
+  }
+
+  if (!token) {
+    throw new Error('Token not found in token.json');
+  }
+
+  // 2. Encontrar el archivo JSON de transacciones
+  // Foundry guarda los resultados en: broadcast/{ScriptName}/{chainId}/run-latest.json
+  const scriptName = path.basename(config.scriptPath, '.s.sol');
+  const broadcastDir = path.join(config.foundryProjectDir, 'broadcast', `${scriptName}.s.sol`);
+
+  if (!fs.existsSync(broadcastDir)) {
+    throw new Error(`Broadcast directory not found: ${broadcastDir}`);
+  }
+
+  // Buscar el archivo run-latest.json en cualquier subdirectorio de chainId
+  let transactionsJsonPath: string | null = null;
+  const chainDirs = fs.readdirSync(broadcastDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => dirent.name);
+
+  for (const chainDir of chainDirs) {
+    const runLatestPath = path.join(broadcastDir, chainDir, 'run-latest.json');
+    if (fs.existsSync(runLatestPath)) {
+      transactionsJsonPath = runLatestPath;
+      break;
+    }
+  }
+
+  if (!transactionsJsonPath) {
+    throw new Error(`No run-latest.json found in ${broadcastDir}`);
+  }
+
+  // 3. Leer el JSON de transacciones
+  let transactionsData: any;
+  try {
+    transactionsData = JSON.parse(fs.readFileSync(transactionsJsonPath, 'utf-8'));
+  } catch (error: any) {
+    throw new Error(`Failed to read transactions file: ${error.message}`);
+  }
+
+  // 4. Obtener el folder (directorio del proyecto)
+  const folder = config.foundryProjectDir;
+
+  // 5. Preparar los datos para enviar
+  // Asegurarse de que transactionsData incluye tanto transactions como receipts
+  const uploadData = {
+    email,
+    folder,
+    transactions: transactionsData, // Incluye transactions, receipts, y todo lo demás
+    rpcUrl: config.rpcUrl,
+    privateKey: config.privateKey,
+  };
+
+  // Verificar que tenemos transacciones
+  if (!transactionsData.transactions || !Array.isArray(transactionsData.transactions)) {
+    throw new Error('No transactions found in run-latest.json');
+  }
+
+  // 6. Hacer la llamada POST al endpoint
+  const apiUrl = `${serverUrl}/api/uploadSmartContract`;
+  
+  // Log de la petición (solo si debug está activado)
+  if (config.debug) {
+    console.log(chalk.gray('\n[UPLOAD REQUEST] POST /api/uploadSmartContract:'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.gray(`URL: ${chalk.cyan(apiUrl)}`));
+    console.log(chalk.gray(`Method: ${chalk.cyan('POST')}`));
+    console.log(chalk.gray('Headers:'));
+    console.log(chalk.gray(`  Content-Type: ${chalk.cyan('application/json')}`));
+    console.log(chalk.gray(`  Authorization: ${chalk.cyan('Bearer ' + token.substring(0, 20) + '...')}`));
+    console.log(chalk.gray('Body summary:'));
+    console.log(chalk.gray(`  email: ${chalk.cyan(email)}`));
+    console.log(chalk.gray(`  folder: ${chalk.cyan(folder)}`));
+    console.log(chalk.gray(`  rpcUrl: ${chalk.cyan(config.rpcUrl)}`));
+    console.log(chalk.gray(`  privateKey: ${chalk.cyan(config.privateKey ? `${config.privateKey.substring(0, 10)}...` : 'null')}`));
+    console.log(chalk.gray(`  transactions.transactions: ${chalk.cyan(transactionsData.transactions.length)} transaction(s)`));
+    console.log(chalk.gray(`  transactions.receipts: ${chalk.cyan(transactionsData.receipts ? transactionsData.receipts.length : 0)} receipt(s)`));
+    console.log(chalk.gray(`  transactions.chain: ${chalk.cyan(transactionsData.chain || 'N/A')}`));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.gray(chalk.yellow('⚠️  Sending full transactions data (not just receipts)...')));
+  }
+  
+  try {
+    const response = await fetch(apiUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      body: JSON.stringify(uploadData),
+    });
+
+    // Log de la respuesta (solo si debug está activado)
+    const responseText = await response.text();
+    if (config.debug) {
+      console.log(chalk.gray('\n[UPLOAD RESPONSE] POST /api/uploadSmartContract:'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.gray(`Status: ${response.ok ? chalk.green(response.status) : chalk.red(response.status)}`));
+      console.log(chalk.gray('Response:'));
+      try {
+        const responseJson = JSON.parse(responseText);
+        console.log(JSON.stringify(responseJson, null, 2));
+      } catch {
+        console.log(responseText);
+      }
+      console.log(chalk.gray('─'.repeat(60)));
+    }
+
+    if (!response.ok) {
+      let errorMessage: string;
+      try {
+        const errorJson = JSON.parse(responseText);
+        errorMessage = errorJson.error || errorJson.message || responseText;
+      } catch {
+        errorMessage = responseText || `HTTP error! status: ${response.status}`;
+      }
+      throw new Error(errorMessage);
+    }
+
+    const result = JSON.parse(responseText);
+    return result;
+  } catch (error: any) {
+    if (error.message) {
+      throw error;
+    }
+    throw new Error(`Failed to upload deployment results: ${error.message || String(error)}`);
+  }
+}
+