thinkncollab-cli 0.0.27 → 0.0.29

package/commands/pull.js

@@ -1,16 +1,18 @@
+#!/usr/bin/env node
 import fs from "fs";
 import path from "path";
 import axios from "axios";
 import https from "https";
-import os from "os"; // Add this import
+import http from "http";
+import os from "os";
+import chalk from "chalk";
 
 const RC_FILE = path.join(os.homedir(), ".tncrc");
-const CWD = process.cwd();
 
 /** ------------------ TOKEN UTILS ------------------ **/
 function readToken() {
   if (!fs.existsSync(RC_FILE)) {
-    console.error("❌ Not logged in. Run 'tnc login' first.");
+    console.error(chalk.red("❌ Not logged in. Run 'tnc login' first."));
     process.exit(1);
   }
   const data = JSON.parse(fs.readFileSync(RC_FILE));
@@ -21,31 +23,27 @@ function readToken() {
 async function downloadFile(url, filePath) {
   return new Promise((resolve, reject) => {
     const fileDir = path.dirname(filePath);
-    
-    // Create directory if it doesn't exist
-    if (!fs.existsSync(fileDir)) {
-      fs.mkdirSync(fileDir, { recursive: true });
-    }
+    if (!fs.existsSync(fileDir)) fs.mkdirSync(fileDir, { recursive: true });
 
     const file = fs.createWriteStream(filePath);
-    
-    https.get(url, (response) => {
-      if (response.statusCode !== 200) {
-        reject(new Error(`Failed to download: ${response.statusCode}`));
-        return;
-      }
-
-      response.pipe(file);
+    const client = url.startsWith("https") ? https : http;
 
-      file.on('finish', () => {
-        file.close();
-        resolve(filePath);
+    client
+      .get(url, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: ${response.statusCode}`));
+          return;
+        }
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close();
+          resolve(filePath);
+        });
+      })
+      .on("error", (err) => {
+        fs.unlink(filePath, () => {});
+        reject(err);
       });
-
-    }).on('error', (err) => {
-      fs.unlink(filePath, () => {}); // Delete the file on error
-      reject(err);
-    });
   });
 }
 
@@ -56,44 +54,44 @@ async function processFolderContent(content, basePath = "") {
   let errorCount = 0;
 
   for (const item of content) {
-    const itemPath = path.join(basePath, item.path || item.name);
+    const relPath = item.path ? item.path.replace(/^[\\/]+/, "") : item.name;
+    const itemPath = path.join(basePath, relPath);
 
     if (item.type === "folder") {
-      // Create directory
       if (!fs.existsSync(itemPath)) {
         fs.mkdirSync(itemPath, { recursive: true });
-        console.log(`📁 Created directory: ${itemPath}`);
+        console.log(chalk.cyan(`📁 Created directory: ${itemPath}`));
       }
 
-      // Process children recursively
       if (item.children && item.children.length > 0) {
-        const result = await processFolderContent(item.children, basePath);
+        const result = await processFolderContent(item.children, itemPath);
         downloadedCount += result.downloadedCount;
         skippedCount += result.skippedCount;
         errorCount += result.errorCount;
       }
     } else if (item.type === "file" && item.url) {
       try {
-        // Check if file already exists and has same content
+        fs.mkdirSync(path.dirname(itemPath), { recursive: true });
+
         if (fs.existsSync(itemPath)) {
           const existingStats = fs.statSync(itemPath);
           if (existingStats.size === item.size) {
-            console.log(`✅ Already exists: ${itemPath}`);
+            console.log(chalk.gray(`✅ Already exists: ${itemPath}`));
             skippedCount++;
             continue;
           }
         }
 
-        console.log(`📥 Downloading: ${itemPath}`);
+        console.log(chalk.yellow(`📥 Downloading: ${itemPath}`));
         await downloadFile(item.url, itemPath);
-        console.log(`✅ Downloaded: ${itemPath}`);
+        console.log(chalk.green(`✅ Downloaded: ${itemPath}`));
         downloadedCount++;
       } catch (err) {
-        console.error(`❌ Failed to download ${itemPath}:`, err.message);
+        console.error(chalk.red(`❌ Failed to download ${itemPath}: ${err.message}`));
         errorCount++;
       }
     } else if (item.type === "file" && !item.url) {
-      console.log(`⚠️  No URL available for: ${itemPath}`);
+      console.log(chalk.magenta(`⚠️  No URL available for: ${itemPath}`));
       skippedCount++;
     }
   }
@@ -105,113 +103,117 @@ async function processFolderContent(content, basePath = "") {
 export default async function pull(roomId, version = "latest") {
   try {
     const { token, email } = readToken();
-    
     const tncMetaPath = path.join(process.cwd(), ".tnc", ".tncmeta.json");
+
     if (!fs.existsSync(tncMetaPath)) {
-      console.error("❌ Project not initialized. Run 'tnc init' first.");
+      console.error(chalk.red("❌ Project not initialized. Run 'tnc init' first."));
       return;
     }
 
     const meta = JSON.parse(fs.readFileSync(tncMetaPath, "utf-8"));
     const projectId = meta.projectId;
 
-    console.log(`🚀 Pulling files from room ${roomId}...`);
+    console.log(chalk.blue(`\n🚀 Pulling files from room ${roomId}...`));
     console.log(`📋 Project: ${projectId}`);
-    console.log(`🎯 Version: ${version}`);
-    console.log("");
+    console.log(`🎯 Version: ${version}\n`);
 
-    // Get folder data from server
     let url = `http://localhost:3001/folder/${roomId}/download`;
     const params = { projectId };
-    
+
     if (version !== "latest") {
       const versionNum = parseInt(version);
       if (isNaN(versionNum)) {
-        console.error("❌ Version must be a number");
+        console.error(chalk.red("❌ Version must be a number"));
         return;
       }
       params.version = versionNum;
     }
 
-    console.log("🔍 Making API request with:", { roomId, projectId, version });
-    
+    console.log(chalk.gray("🔍 Making API request with:"), { roomId, projectId, version });
+    console.log(chalk.gray("🌐 API URL:"), url);
+
     const response = await axios.get(url, {
       params,
-      headers: {
-        authorization: `Bearer ${token}`,
-        email: email
-      }
+      headers: { authorization: `Bearer ${token}`, email },
     });
 
-    console.log("✅ API Response received");
+    console.log(chalk.green("✅ API Response received"));
     const folderData = response.data;
-    
-    if (!folderData || !folderData.rootContent) {
-      console.log("❌ No content found in response");
+
+    if (!folderData) {
+      console.log(chalk.red("❌ No data found in response"));
       return;
     }
 
-    console.log(`📦 Found version ${folderData.version} with ${folderData.rootContent.length} items`);
-    console.log("");
+    const rootContent = folderData.rootContent || folderData.content || folderData;
+    const folderVersion = folderData.version || 1;
+
+    if (!rootContent || !Array.isArray(rootContent)) {
+      console.log(chalk.red("❌ No valid content found in response"));
+      console.log("📋 Response structure:", Object.keys(folderData));
+      return;
+    }
 
-    // Create backup of current versions file if it exists
+    console.log(chalk.cyan(`📦 Found version ${folderVersion} with ${rootContent.length} items\n`));
+
+    // Backup versions file
     const versionsFile = path.join(process.cwd(), ".tncversions");
-    if (fs.existsSync(versionsFile)) {
-      const backupPath = path.join(process.cwd(), `.tncversions.backup.${Date.now()}`);
+    const backupPath = path.join(process.cwd(), `.tncversions.backup`);
+    if (fs.existsSync(versionsFile) && !fs.existsSync(backupPath)) {
       fs.copyFileSync(versionsFile, backupPath);
-      console.log(`💾 Backed up existing versions to: ${path.basename(backupPath)}`);
+      console.log(chalk.gray(`💾 Backup created: ${path.basename(backupPath)}`));
     }
 
-    // Process and download files
-    const result = await processFolderContent(folderData.rootContent, process.cwd());
+    // Download files
+    const result = await processFolderContent(rootContent, process.cwd());
 
-    console.log("");
-    console.log("📊 Download Summary:");
-    console.log("====================");
+    console.log("\n" + "=".repeat(35));
+    console.log(chalk.bold("\n📊 Download Summary"));
+    console.log("=".repeat(35));
     console.log(`✅ Downloaded: ${result.downloadedCount} files`);
-    console.log(`📋 Skipped: ${result.skippedCount} files (already exist)`);
+    console.log(`📋 Skipped: ${result.skippedCount} files`);
     console.log(`❌ Errors: ${result.errorCount} files`);
-    
+
     if (result.errorCount > 0) {
-      console.log("");
-      console.log("⚠️  Some files failed to download. Check the errors above.");
+      console.log(chalk.yellow("\n⚠️  Some files failed to download. Check above logs."));
     }
 
-    // Update local versions file with pulled data
+    // Update .tncversions
     const newVersionMap = {};
     const flattenContent = (items) => {
       for (const item of items) {
         if (item.type === "file") {
           newVersionMap[item.path] = {
-            hash: item.contentHash || item.hash,
-            url: item.url,
+            hash: item.contentHash || item.hash || "",
+            url: item.url || null,
             version: item.version || 1,
-            size: item.size || 0
+            size: item.size || 0,
           };
         }
-        if (item.children) {
-          flattenContent(item.children);
-        }
+        if (item.children) flattenContent(item.children);
       }
     };
-    
-    flattenContent(folderData.rootContent);
+
+    flattenContent(rootContent);
     fs.writeFileSync(versionsFile, JSON.stringify(newVersionMap, null, 2));
-    
-    console.log("");
-    console.log(`💾 Updated local versions file with ${Object.keys(newVersionMap).length} files`);
-    console.log(`🎉 Pull completed successfully!`);
 
+    console.log("");
+    console.log(chalk.green(`💾 Updated local versions file with ${Object.keys(newVersionMap).length} files`));
+    console.log(chalk.bold.green(`🎉 Pull completed successfully!\n`));
   } catch (err) {
-    console.error("❌ Pull failed with error:", err.message);
-    
+    console.error(chalk.red(`❌ Pull failed: ${err.message}`));
+
     if (err.response) {
-      console.error("📡 Server response:", {
-        status: err.response.status,
-        data: err.response.data
-      });
+      console.error(chalk.red(`📡 Server status: ${err.response.status}`));
+      const msg =
+        typeof err.response.data === "object"
+          ? err.response.data.message || JSON.stringify(err.response.data)
+          : err.response.data;
+      console.error(chalk.red("📡 Server message:"), msg);
     } else if (err.request) {
-      console.error("🌐 No response received from server");
+      console.error(chalk.yellow("🌐 No response from server — check backend (localhost:3001)."));
+    } else {
+      console.error(chalk.red("🔧 Configuration error:"), err.message);
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "thinkncollab-cli",
   "author": "Raman Singh",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "description": "CLI tool for ThinkNCollab",
   "main": "index.js",
   "bin": {
@@ -13,6 +13,7 @@
   "type": "module",
   "dependencies": {
     "axios": "^1.12.2",
+    "chalk": "^5.6.2",
     "inquirer": "^9.3.8"
   }
-}
+}