thinkncollab-cli 0.0.24 → 0.0.26

package/bin/index.js

@@ -8,6 +8,7 @@ import crypto from "crypto";
 import FormData from "form-data";
 import projectInit from "../commands/init.js";
 import Status from "../commands/status.js";
+import pull from "../commands/pull.js";
 
 const RC_FILE = path.join(os.homedir(), ".tncrc");
 const VERSION_FILE = path.join(process.cwd(), ".tncversions");
@@ -414,6 +415,22 @@ async function main() {
     case "init":
       await projectInit();
       break;
+      
+    case "pull": {
+      const roomIndex = args.indexOf("--room");
+      const versionIndex = args.indexOf("--version");
+      
+      if (roomIndex === -1 || !args[roomIndex + 1]) {
+        console.error("Usage: tnc pull --room <roomId> [--version <version>]");
+        process.exit(1);
+      }
+      
+      const roomId = args[roomIndex + 1];
+      const version = versionIndex !== -1 && args[versionIndex + 1] ? args[versionIndex + 1] : "latest";
+      
+      await pull(roomId, version);
+      break;
+    }
 
     default:
       console.log("✅ TNC CLI ready!");

package/commands/pull.js

@@ -1,124 +1,213 @@
-#!/usr/bin/env node
 import fs from "fs";
 import path from "path";
-import crypto from "crypto";
 import axios from "axios";
+import https from "https";
 import os from "os";
-import { createUploader } from "./cloudUploader.js";
 
-const BASE_URL = "http://localhost:3001";
+
+const RC_FILE = path.join(os.homedir(), ".tncrc");
 const CWD = process.cwd();
 
+/** ------------------ TOKEN UTILS ------------------ **/
 function readToken() {
-  const homeDir = os.homedir();
-  return JSON.parse(fs.readFileSync(path.join(homeDir, ".tncrc")));
+  if (!fs.existsSync(RC_FILE)) {
+    console.error("❌ Not logged in. Run 'tnc login' first.");
+    process.exit(1);
+  }
+  const data = JSON.parse(fs.readFileSync(RC_FILE));
+  return { token: data.token, email: data.email };
 }
 
-function readMeta() {
-  const metaPath = path.join(CWD, ".tnc", ".tncmeta.json");
-  return fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath)) : null;
-}
+/** ------------------ DOWNLOAD FILE ------------------ **/
+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 });
+    }
 
-function writeMeta(meta) {
-  const metaPath = path.join(CWD, ".tnc", ".tncmeta.json");
-  fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
-}
+    const file = fs.createWriteStream(filePath);
+    
+    https.get(url, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
 
-// ========== IGNORE HANDLING ==========
-function loadIgnore(folderPath) {
-  const ignoreFile = path.join(folderPath, ".ignoretnc");
-  if (!fs.existsSync(ignoreFile)) return [];
-  return fs.readFileSync(ignoreFile, "utf-8")
-           .split("\n")
-           .map(l => l.trim())
-           .filter(l => l && !l.startsWith("#"));
-}
+      response.pipe(file);
 
-function shouldIgnore(relativePath, ignoreList) {
-  relativePath = relativePath.replace(/\\/g, "/");
-  return ignoreList.some(pattern => {
-    pattern = pattern.replace(/\\/g, "/");
-    if (pattern.endsWith("/**")) {
-      const folder = pattern.slice(0, -3);
-      return relativePath === folder || relativePath.startsWith(folder + "/");
-    }
-    if (pattern.startsWith("*.")) return relativePath.endsWith(pattern.slice(1));
-    return relativePath === pattern;
+      file.on('finish', () => {
+        file.close();
+        resolve(filePath);
+      });
+
+    }).on('error', (err) => {
+      fs.unlink(filePath, () => {}); // Delete the file on error
+      reject(err);
+    });
   });
 }
 
-// ========== SCAN FOLDER ==========
-function scanFolder(folderPath, ignoreList, rootPath = folderPath) {
-  const items = fs.readdirSync(folderPath, { withFileTypes: true });
-  const result = [];
-  for (const item of items) {
-    const fullPath = path.join(folderPath, item.name);
-    const relativePath = path.relative(rootPath, fullPath).replace(/\\/g, "/");
-    if (shouldIgnore(relativePath, ignoreList)) continue;
-
-    if (item.isDirectory()) {
-      result.push({ name: item.name, type: "folder", children: scanFolder(fullPath, ignoreList, rootPath) });
-    } else {
-      const stats = fs.statSync(fullPath);
-      result.push({ name: item.name, type: "file", path: fullPath, size: stats.size });
+/** ------------------ PROCESS FOLDER CONTENT ------------------ **/
+async function processFolderContent(content, basePath = "") {
+  let downloadedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+
+  for (const item of content) {
+    const itemPath = path.join(basePath, item.path || item.name);
+
+    if (item.type === "folder") {
+      // Create directory
+      if (!fs.existsSync(itemPath)) {
+        fs.mkdirSync(itemPath, { recursive: true });
+        console.log(`📁 Created directory: ${itemPath}`);
+      }
+
+      // Process children recursively
+      if (item.children && item.children.length > 0) {
+        const result = await processFolderContent(item.children, basePath);
+        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
+        if (fs.existsSync(itemPath)) {
+          const existingStats = fs.statSync(itemPath);
+          if (existingStats.size === item.size) {
+            console.log(`✅ Already exists: ${itemPath}`);
+            skippedCount++;
+            continue;
+          }
+        }
+
+        console.log(`📥 Downloading: ${itemPath}`);
+        await downloadFile(item.url, itemPath);
+        console.log(`✅ Downloaded: ${itemPath}`);
+        downloadedCount++;
+      } catch (err) {
+        console.error(`❌ Failed to download ${itemPath}:`, err.message);
+        errorCount++;
+      }
+    } else if (item.type === "file" && !item.url) {
+      console.log(`⚠️  No URL available for: ${itemPath}`);
+      skippedCount++;
     }
   }
-  return result;
+
+  return { downloadedCount, skippedCount, errorCount };
 }
 
-// ========== PUSH EVERYTHING ==========
-export async function dpushAll() {
-  const { token, email } = readToken();
-  const meta = readMeta();
-  if (!meta) return console.log("❌ Project not initialized locally. Run init first.");
-  const { projectId, currentBranch } = meta;
+/** ------------------ PULL FUNCTION ------------------ **/
+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.");
+      return;
+    }
 
-  const stats = fs.statSync(CWD);
-  const ignoreList = loadIgnore(CWD);
+    const meta = JSON.parse(fs.readFileSync(tncMetaPath, "utf-8"));
+    const projectId = meta.projectId;
 
-  const content = scanFolder(CWD, ignoreList);
-  if (!content.length) return console.log("⚠️ Nothing to upload (all ignored).");
+    console.log(`🚀 Pulling files from room ${roomId}...`);
+    console.log(`📋 Project: ${projectId}`);
+    console.log(`🎯 Version: ${version}`);
+    console.log("");
 
-  try {
-    const uploader = createUploader(BASE_URL, token, email);
-    const folderHex = crypto.createHash("md5").update(path.basename(CWD) + Date.now()).digest("hex");
-
-    console.log("🚀 Uploading entire project...");
-    const uploadedTree = await uploader.uploadTree(content, folderHex, projectId);
-
-    // Prepare metadata
-    const filesMetadata = [];
-    function flattenTree(nodes, parent = "") {
-      for (const node of nodes) {
-        const relPath = path.join(parent, node.name).replace(/\\/g, "/");
-        if (node.type === "file") {
-          const hash = crypto.createHash("md5").update(fs.readFileSync(path.join(CWD, relPath))).digest("hex");
-          filesMetadata.push({ filename: relPath, contentHash: hash, path: node.url, version: 0 });
-        } else if (node.type === "folder") {
-          flattenTree(node.children, relPath);
-        }
+    // Get folder data from server
+    let url = `http://localhost:3001/folders/${roomId}/download`;
+    const params = { projectId };
+    
+    if (version !== "latest") {
+      params.version = version;
+    }
+
+    const response = await axios.get(url, {
+      params,
+      headers: {
+        authorization: `Bearer ${token}`,
+        email: email
       }
+    });
+
+    const folderData = response.data;
+    
+    if (!folderData || !folderData.rootContent) {
+      console.log("❌ No content found to download.");
+      return;
+    }
+
+    console.log(`📦 Found version ${folderData.version} with ${folderData.rootContent.length} items`);
+    console.log("");
+
+    // Create backup of current versions file if it exists
+    const versionsFile = path.join(process.cwd(), ".tncversions");
+    if (fs.existsSync(versionsFile)) {
+      const backupPath = path.join(process.cwd(), `.tncversions.backup.${Date.now()}`);
+      fs.copyFileSync(versionsFile, backupPath);
+      console.log(`💾 Backed up existing versions to: ${path.basename(backupPath)}`);
     }
-    flattenTree(uploadedTree);
-
-    console.log("🗂️ Sending metadata to backend...");
-    const pushRes = await axios.post(
-      `${BASE_URL}/cli/push`,
-      { projectId, branchName: currentBranch, files: filesMetadata, author: email, message: "Full project push" },
-      { headers: { authorization: `Bearer ${token}`, email } }
-    );
-
-    console.log("✅ Push successful:", pushRes.data);
-
-    // Update local meta
-    meta.lastCommit = pushRes.data.commitId;
-    for (const f of pushRes.data.files) meta.files[f.filename] = f.version;
-    writeMeta(meta);
-    console.log("📝 Local metadata updated.");
+
+    // Process and download files
+    const result = await processFolderContent(folderData.rootContent, process.cwd());
+
+    console.log("");
+    console.log("📊 Download Summary:");
+    console.log("====================");
+    console.log(`✅ Downloaded: ${result.downloadedCount} files`);
+    console.log(`📋 Skipped: ${result.skippedCount} files (already exist)`);
+    console.log(`❌ Errors: ${result.errorCount} files`);
+    
+    if (result.errorCount > 0) {
+      console.log("");
+      console.log("⚠️  Some files failed to download. Check the errors above.");
+    }
+
+    // Update local versions file with pulled data
+    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,
+            version: item.version || 1,
+            size: item.size || 0
+          };
+        }
+        if (item.children) {
+          flattenContent(item.children);
+        }
+      }
+    };
+    
+    flattenContent(folderData.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!`);
+
   } catch (err) {
-    console.error("❌ Push failed:", err.response?.data || err.message);
+    if (err.response) {
+      console.error("❌ Pull failed:", err.response.data.message || err.response.statusText);
+    } else {
+      console.error("❌ Pull failed:", err.message);
+    }
   }
 }
 
-// Call push all
-dpushAll();
+/** ------------------ PULL WITH OPTIONS ------------------ **/
+export async function pullWithOptions(roomId, options = {}) {
+  const version = options.version || "latest";
+  const targetPath = options.targetPath || process.cwd();
+  
+  await pull(roomId, version, targetPath);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "thinkncollab-cli",
   "author": "Raman Singh",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "CLI tool for ThinkNCollab",
   "main": "index.js",
   "bin": {