thinkncollab-cli 0.0.76 → 0.0.78

package/bin/index.js

@@ -4,8 +4,6 @@ import axios from "axios";
 import fs from "fs";
 import os from "os";
 import path from "path";
-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";
@@ -16,12 +14,16 @@ import createBranch from "../commands/branch.js"
 import myTask from "../commands/myTask.js"
 import sendInvite from '../commands/sendInvite.js'
 import connect from '../commands/connect.js'
+import machine from  "node-machine-id";
+import push from "../commands/push.js";
+import taskCompletion from "../commands/taskCompletion.js";
+
 
 
 
 const RC_FILE = path.join(os.homedir(), ".tncrc");
 const VERSION_FILE = path.join(process.cwd(), ".tncversions");
-const BASE_URL = "http://localhost:3001/rooms";
+const BASE_URL = "https://thinkncollab.com/rooms";
 const CWD = process.cwd();
 
 /** ------------------ LOGIN ------------------ **/
@@ -29,13 +31,15 @@ async function login() {
   const answers = await inquirer.prompt([
     { type: "input", name: "email", message: "Email:" },
     { type: "password", name: "password", message: "Password:" }
+
   ]);
 
   try {
     console.log("🔐 Logging in...");
     const res = await axios.post("https://thinkncollab.com/login", {
       email: answers.email,
-      password: answers.password
+      password: answers.password,
+      machineId: await machine.machineIdSync()
     });
 
     const { token, email } = res.data;
@@ -60,377 +64,6 @@ async function logout() {
   }
 }
 
-/** ------------------ TOKEN UTILS ------------------ **/
-function readToken() {
-  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 };
-}
-
-/** ------------------ 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(line => line.trim())
-    .filter(line => line && !line.startsWith("#"));
-}
-
-function shouldIgnore(relativePath, ignoreList) {
-  return ignoreList.some(pattern => {
-    if (pattern.endsWith("/**")) {
-      const folder = pattern.slice(0, -3);
-      return relativePath === folder || relativePath.startsWith(folder + path.sep);
-    }
-    if (pattern.startsWith("*.")) {
-      return relativePath.endsWith(pattern.slice(1));
-    }
-    return relativePath === pattern;
-  });
-}
-
-/** ------------------ SCAN FOLDER - FIXED ------------------ **/
-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);
-
-    if (shouldIgnore(relativePath, ignoreList)) {
-      console.log("⚠️ Ignored:", relativePath);
-      continue;
-    }
-
-    if (item.isDirectory()) {
-      result.push({
-        name: item.name,
-        type: "folder",
-        children: scanFolder(fullPath, ignoreList, rootPath), // ✅ Keep same rootPath
-        path: item.name // ✅ Only store folder name, not full path
-      });
-    } else {
-      const stats = fs.statSync(fullPath);
-      result.push({
-        name: item.name,
-        type: "file",
-        path: relativePath, // ✅ Keep relative path for files
-        size: stats.size
-      });
-    }
-  }
-  return result;
-}
-
-/** ------------------ VERSIONING ------------------ **/
-function loadVersions() {
-  if (!fs.existsSync(VERSION_FILE)) return {};
-  const data = JSON.parse(fs.readFileSync(VERSION_FILE, "utf-8"));
-
-  // Backward compatibility: if old format (just strings), convert to new format
-  const converted = {};
-  for (const [path, value] of Object.entries(data)) {
-    if (typeof value === 'string') {
-      converted[path] = { hash: value, url: '', version: 1 };
-    } else {
-      converted[path] = value;
-    }
-  }
-  return converted;
-}
-
-function saveVersions(versionMap) {
-  fs.writeFileSync(VERSION_FILE, JSON.stringify(versionMap, null, 2));
-}
-
-function computeFileHash(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return null;
-
-    const stats = fs.statSync(filePath);
-    if (stats.isDirectory()) {
-      // For folders: hash of sorted file names + their hashes
-      const items = fs.readdirSync(filePath).sort();
-      const childrenHashes = items.map(name =>
-        computeFileHash(path.join(filePath, name))
-      ).filter(Boolean).join('|');
-
-      return crypto.createHash("sha256")
-        .update(`folder:${filePath}|${childrenHashes}`)
-        .digest("hex");
-    } else {
-      // For files: hash of content + file metadata
-      const content = fs.readFileSync(filePath);
-      const stats = fs.statSync(filePath);
-
-      return crypto.createHash("sha256")
-        .update(content)
-        .update(`size:${stats.size}|mtime:${stats.mtimeMs}`)
-        .digest("hex");
-    }
-  } catch (err) {
-    console.error(`❌ Error computing hash for ${filePath}:`, err.message);
-    return null;
-  }
-}
-
-function checkChanges(fileTree, versionMap, rootPath = CWD) {
-  return fileTree.map(item => {
-    const fullPath = path.join(rootPath, item.path || item.name);
-    const relativePath = item.path || item.name;
-
-    let hash = null;
-    let changed = true;
-
-    try {
-      if (fs.existsSync(fullPath)) {
-        hash = computeFileHash(fullPath);
-
-        // Check against previous version
-        const prevVersion = versionMap[relativePath];
-        if (prevVersion && prevVersion.hash === hash) {
-          changed = false;
-        }
-      }
-    } catch (err) {
-      console.error(`❌ Error checking changes for ${relativePath}:`, err.message);
-    }
-
-    const newItem = {
-      ...item,
-      changed,
-      hash,
-      path: relativePath // Ensure consistent path
-    };
-
-    // Recursively check children for folders
-    if (item.type === "folder" && item.children && item.children.length > 0) {
-      newItem.children = checkChanges(item.children, versionMap, rootPath);
-      newItem.changed = newItem.changed || newItem.children.some(c => c.changed);
-    }
-
-    return newItem;
-  });
-}
-
-/** ------------------ CLOUDINARY UPLOAD ------------------ **/
-async function uploadFileSigned(filePath, folder, roomId, token, email) {
-  const filename = path.basename(filePath);
-
-  const sigRes = await axios.post(
-    `${BASE_URL}/${roomId}/get-upload-signature`,
-    { filename, folder, roomId },
-    { headers: { authorization: `Bearer ${token}`, email } }
-  );
-
-  const { signature, timestamp, api_key, cloud_name } = sigRes.data;
-
-  const formData = new FormData();
-  formData.append("file", fs.createReadStream(filePath));
-  formData.append("folder", folder);
-  formData.append("public_id", filename);
-  formData.append("timestamp", timestamp);
-  formData.append("signature", signature);
-  formData.append("api_key", api_key);
-
-  const cloudRes = await axios.post(
-    `https://api.cloudinary.com/v1_1/${cloud_name}/auto/upload`,
-    formData,
-    { headers: formData.getHeaders() }
-  );
-
-  return cloudRes.data.secure_url;
-}
-
-/** ------------------ UPLOAD TREE - FIXED PATH CONSTRUCTION ------------------ **/
-async function uploadTree(fileTree, folderHex, roomId, token, email, previousVersions, parentPath = "") {
-  const uploaded = [];
-
-  for (const node of fileTree) {
-    // ✅ FIXED: Correct path construction without duplication
-    let relativePath;
-    if (parentPath) {
-      relativePath = path.join(parentPath, node.name).replace(/\\/g, "/");
-    } else {
-      relativePath = node.path || node.name;
-    }
-
-    if (node.type === "folder") {
-      const children = await uploadTree(node.children, folderHex, roomId, token, email, previousVersions, relativePath);
-
-      uploaded.push({
-        ...node,
-        children,
-        hash: node.hash,
-        path: relativePath
-      });
-    } else {
-      const prevFile = previousVersions[relativePath];
-
-      if (node.changed) {
-        try {
-          console.log(`📤 Uploading changed file: ${relativePath}`);
-          const url = await uploadFileSigned(path.join(CWD, node.path), `tnc_uploads/${folderHex}`, roomId, token, email);
-          console.log(`✅ Uploaded: ${relativePath}`);
-
-          uploaded.push({
-            ...node,
-            url,
-            hash: node.hash,
-            path: relativePath,
-            version: prevFile ? prevFile.version + 1 : 1
-          });
-        } catch (err) {
-          console.error(`❌ Failed to upload ${relativePath}:`, err.message);
-          // Fallback to previous version if upload fails
-          uploaded.push({
-            ...node,
-            url: prevFile?.url,
-            hash: node.hash,
-            path: relativePath,
-            version: prevFile?.version || 1
-          });
-        }
-      } else {
-        // Unchanged file - use previous URL and version
-        console.log(`📋 Using previous version for: ${relativePath}`);
-        uploaded.push({
-          ...node,
-          url: prevFile?.url,
-          hash: node.hash,
-          path: relativePath,
-          version: prevFile?.version || 1
-        });
-      }
-    }
-  }
-
-  return uploaded;
-}
-
-/** ------------------ PUSH FUNCTION ------------------ **/
-async function push(roomId, targetPath) {
-  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.");
-    process.exit(1);
-  }
-  const meta = JSON.parse(fs.readFileSync(tncMetaPath, "utf-8"));
-  const projectId = meta.projectId;
-
-
-   const tncPushInfo = path.join(process.cwd(), ".tnc", ".tncpush.json");
-  if (!fs.existsSync(tncMetaPath)) {
-    console.error("❌ Project not initialized. Run 'tnc init' first.");
-    process.exit(1);
-  }
-  const lastFolderId = JSON.parse(fs.readFileSync(tncPushInfo, "utf-8")).folderId;
-
-  
-
-  const stats = fs.statSync(targetPath);
-  const rootFolder = stats.isDirectory() ? targetPath : path.dirname(targetPath);
-  const ignoreList = loadIgnore(rootFolder);
-
-  let content;
-  if (stats.isDirectory()) {
-    content = scanFolder(targetPath, ignoreList);
-  } else {
-    const relativePath = path.basename(targetPath);
-    content = shouldIgnore(relativePath, ignoreList)
-      ? []
-      : [{ name: relativePath, type: "file", path: relativePath, size: stats.size }];
-  }
-
-  if (!content.length) {
-    console.log("⚠️ Nothing to upload (all ignored).");
-    return;
-  }
-
-  const previousVersions = loadVersions();
-  console.log('📁 Previous versions:', Object.keys(previousVersions).length);
-
-  const contentWithChanges = checkChanges(content, previousVersions);
-
-  // Debug: Show what changed
-  const changedFiles = contentWithChanges.flatMap(item =>
-    item.changed ? [item.path] : []
-  );
-  console.log('🔄 Changed files:', changedFiles.length, changedFiles);
-
-  const hasChanges = contentWithChanges.some(item => item.changed || (item.children && item.children.some(c => c.changed)));
-
-  if (!hasChanges) {
-    console.log("ℹ️ No changes detected since last push.");
-    return;
-  }
-
-  try {
-    const folderHex = crypto.createHash("md5").update(path.basename(targetPath) + Date.now()).digest("hex");
-
-    console.log("🚀 Uploading to Cloudinary...");
-    const uploadedTree = await uploadTree(contentWithChanges, folderHex, roomId, token, email, previousVersions);
-
-    console.log("🗂️ Sending metadata...");
-     const res = await axios.post(
-      `${BASE_URL}/${roomId}/upload`,
-      { folderId: folderHex, content: uploadedTree, uploadedBy: email, projectId, latestFolderId: lastFolderId},
-      { headers: { authorization: `Bearer ${token}`, email } }
-    );
-
-    console.log("✅ Upload complete! Metadata stored successfully.");
-
-    // Save version hashes WITH URLs
-    const newVersionMap = {};
-    const flattenAndStore = (items) => {
-      for (const item of items) {
-        if (item.type === "file") {
-          newVersionMap[item.path] = {
-            hash: item.hash,
-            url: item.url, // ✅ Store URL locally
-            version: item.version || 1
-          };
-        }
-        if (item.children) flattenAndStore(item.children);
-      }
-    };
-    flattenAndStore(uploadedTree);
-    saveVersions(newVersionMap);
-
-    // Determine latest version number from uploaded files
-    const versionNumbers = Object.values(newVersionMap).map(f => f.version || 1);
-    const latestVersion = versionNumbers.length > 0 ? Math.max(...versionNumbers) : 1;
-
-    const newPushRecord = {
-        version: latestVersion,
-        pushedAt: new Date().toISOString(),
-        roomId: roomId,
-        pushedBy: email,
-        projectId: projectId,
-        folderId: res.data.folderId
-    };
-
-
-
-    const pushFilePath = path.join(CWD, ".tnc", ".tncpush.json");
-    fs.writeFileSync(
-      pushFilePath,
-      JSON.stringify(newPushRecord, null, 2)
-    );
-
-    console.log(`💾 Saved ${Object.keys(newVersionMap).length} files to .tncversions`);
-
-  } catch (err) {
-    console.error("❌ Upload failed:", err.response?.data || err.message);
-  }
-}
 
 /** ------------------ CLI HANDLER ------------------ **/
 async function main() {
@@ -443,7 +76,7 @@ async function main() {
 
     case "logout":
       await logout();
-      break;
+      break;  
 
     case "push": {
       const roomIndex = args.indexOf("--room");
@@ -452,7 +85,7 @@ async function main() {
         process.exit(1);
       }
       const roomId = args[roomIndex + 1];
-      const targetPath = args[roomIndex + 3];
+      const targetPath = args[roomIndex + 2];
       await push(roomId, targetPath);
       break;
     }
@@ -461,7 +94,10 @@ async function main() {
       break;
 
     case "init":
-      await projectInit();
+      const roomIndex = args.indexOf("init");
+      const roomid = args[roomIndex + 1];
+      if (!roomid) console.log("Usage: tnc-cli init <roomId>");
+      await projectInit(roomid);
       break;
     
  case "create":
@@ -485,13 +121,19 @@ async function main() {
 
   case "connect": {
     const idx = args.indexOf("connect");
+    if(idx === -1 || !args[idx+1]){
+      console.log(" Usage: tnc-cli connect <roomId> ");
+      process.exit(1);
+    }
     const link = args[idx+1];
-
     await connect(link);
     break;
+  }
 
-    
-
+    case "task-complete": {
+    const idx = args.indexOf("task-complete");
+    await taskCompletion();
+    break;
   }
 
     case "pull": {
@@ -528,14 +170,18 @@ async function main() {
 
 case "my-tasks": {
   const roomIdx = args.indexOf("my-tasks");
-  const roomId = args[roomIdx + 1]; // fixed typo
+  const roomId = args[roomIdx + 1]; 
 
-  await myTask(roomId); 
+  await myTask(); 
   break;
 }
 case "invite": {
   const roomIdx = args.indexOf("invite");
-  const email = args[roomIdx + 1]; // fixed typo
+  if (roomIdx === -1 || !args[roomIdx + 1]) {
+    console.log("Usage: tnc-cli invite <invitee-email>");
+    process.exit(1);
+  }
+  const email = args[roomIdx + 1];
 
   await sendInvite(email); 
   break;
@@ -557,6 +203,7 @@ case "invite": {
       console.log("  tnc-cli logout");
       console.log("  tnc-cli help");
       console.log("  tnc-cli version");
+      console.log("  tnc-cli task-complete <task-Id>")
       
     }
 }

package/commands/branch.js

@@ -3,6 +3,7 @@ import path from "path";
 import axios from "axios";
 import os from "os";
 import inquirer from "inquirer";
+import getUserInfo from "../lib/getVerify.js";
 
 
 async function updateBranch(branchName, branchId) {
@@ -29,7 +30,7 @@ async function updateBranch(branchName, branchId) {
   }
 
   // Update the current branch
-  meta.currentBranch = branchName;
+  meta.branch = branchName;
   Object.assign(meta, {branchId: `${branchId}`});
 
   // Write updated data
@@ -58,25 +59,27 @@ async function createBranch(roomId) {
       },
     ]);
 
-    const homeDir = os.homedir();
-    const tncfilepath = path.join(homeDir, ".tncrc");
+   const userInfo = await getUserInfo();   // FIXED
 
-    if (!fs.existsSync(tncfilepath)) {
-      throw new Error("Configuration file not found. Please login first.");
-    }
+if (!userInfo) {
+  throw new Error("User info could not be loaded. Please login first.");
+}
 
-    const doc = fs.readFileSync(tncfilepath, "utf-8");
-    const obj = JSON.parse(doc);
-    const email = obj.email;
+const email = userInfo.email;
+const token = userInfo.token;
+
+if (!email || !token) {
+  throw new Error("User email or token missing. Please login again.");
+}
+
+console.log(email, token);
 
-    if (!email) {
-      throw new Error("User email not found in configuration. Please login again.");
-    }
 
     const res = await axios.post("https://thinkncollab.com/cli/createBranch", {
       branchName: branchName.trim(),
-      roomId,
-      email,
+      roomId : roomId,
+      email: email,
+      token:token
     });
 
 const {

package/commands/connect.js

@@ -1,13 +1,66 @@
-import fs from "fs";
-import path from "path";
 import axios from "axios";
+import machine from "node-machine-id";
+import fs from "fs";
 import os from "os";
-import inquirer from "inquirer";
+import path from "path";
+
+const tncrcPath = path.join(os.homedir(), ".tncrc");
+
+async function connect(roomId) {
+  if (!fs.existsSync(tncrcPath)) {
+    console.error("❌ You are not logged in. Run 'tnc login' first.");
+    process.exit(1);
+  }
+   const answer = await inquirer.prompt([
+      { type: "input", name: "BranchName", message: "Enter Branch Name to create a branch:" }
+    ]);
+
+  const data = fs.readFileSync(tncrcPath, "utf-8");
+  const { email, token } = JSON.parse(data);
+
+  try {
+    const response = await axios.post(`https://thinkncollab.com/cli/connect/${roomId}`, {
+      email: email,
+      token: token,
+      machineId: await machine.machineIdSync(),
+      branchName: answer.BranchName,
+    });
+    const CWD= process.cwd();
+    const tncFolderPath = path.join(CWD, ".tnc");
+     if (!fs.existsSync(tncFolderPath)) fs.mkdirSync(tncFolderPath, { recursive: true });
+   
+     // Write metadata file
+     const metaFilePath = path.join(tncFolderPath, ".tncmeta.json");
+     const pushFilePath = path.join(tncFolderPath, ".tncpush.json");
+
+    const metaFileInfo = JSON.stringify({
+      "projectId": response.data.project._id,
+      "projectName": response.data.project.name,
+      "roomId": response.data.project.roomId,
+      "branch": null
+    });
+    fs.writeFileSync(metaFilePath, metaFileInfo);
+     fs.writeFileSync(
+        pushFilePath,
+       " {} "
+      )
+
+console.log(response.data);
+
+
+
 
 
-export async function connect(link) {
+    // console.log("✅ Connected to project:", response.data.project.name);
+    // console.log("Members connected:", response.data.project.membersConnected);
 
-    const res = await axios.get("http://localhost:12/cli/connect/roomId");
+  } catch (err) {
+    if (err.response) {
+      console.error(" Error:", err.response.data.error);
+    } else {
+      console.error(" Error:", err.message);
+    }
+  }
+}
 
-    console.log(res.data);
-}
+export default connect;

package/commands/init.js

@@ -3,10 +3,11 @@ import os from "os";
 import path from "path";
 import inquirer from "inquirer";
 import axios from "axios";
+import machine from "node-machine-id";
 
 const CWD = process.cwd();
 
-async function projectInit() {
+async function projectInit(roomId) {
   const answer = await inquirer.prompt([
     { type: "input", name: "projectName", message: "Enter Project Name:" }
   ]);
@@ -21,11 +22,15 @@ async function projectInit() {
 
   const data = fs.readFileSync(tncrcPath, "utf-8");
   const currentUser = JSON.parse(data).email;
+  const userToken = JSON.parse(data).token;
 
   // Initialize project via backend
   const response = await axios.post("https://thinkncollab.com/cli/init", {
     projectName: answer.projectName,
-    owner: currentUser
+    owner: currentUser,
+    token: userToken,
+    machineId: await machine.machineIdSync(),
+    roomId: roomId 
   });
 
   const projectId = response.data.project._id;
@@ -44,6 +49,7 @@ async function projectInit() {
         projectId,
         projectName: answer.projectName,
         currentBranch: "main",
+        roomId: roomId,
         lastCommit: null,
         files: {}
       },

package/commands/myTask.js

@@ -4,7 +4,7 @@ import axios from "axios";
 import os from "os";
 
 const homeDir = os.homedir();
-const url = "https://thinkncollab.in/cli/mytasks"; // backend endpoint
+const url = "https://thinkncollab.com/cli/mytasks"; // backend endpoint
 
 // Get saved email from ~/.tncrc
 async function getEmail() {
@@ -32,10 +32,14 @@ async function getToken() {
 }
 
 // Fetch tasks for a given room
-async function myTask(roomId) {
+async function myTask() {
   try {
     const email = await getEmail();
     const token = await getToken();
+    const CWD = process.cwd();
+    const metaDataPath = path.join(".tnc", '.tncmeta.json'); // assuming room ID is the current directory name
+    const metaData = JSON.parse(fs.readFileSync(path.join(CWD, metaDataPath), 'utf-8'));
+    const roomId = metaData.roomId;
 
     const res = await axios.get(`${url}/${roomId}`, {
       params: { email, token } // since backend uses req.query
@@ -50,7 +54,7 @@ async function myTask(roomId) {
 
     console.log("📋 Your Tasks:");
     tasks.forEach((task, i) => {
-      console.log(`${i + 1}. ${task.title} — ${task.status}`);
+      console.log(`${i + 1}. ${task.title} — ${task.status}   ${task._id}`);
     });
 
   } catch (error) {