thinkncollab-cli 0.0.90 → 0.0.91

package/bin/index.js

@@ -175,10 +175,16 @@ async function main() {
       break;
 
 case "my-tasks": {
-  const roomIdx = args.indexOf("my-tasks");
-  const roomId = args[roomIdx + 1]; 
-
-  await myTask(); 
+  const n = args.indexOf("-n");
+  let limit = 5;
+  if (n !== -1 && args[n + 1]) {
+    limit = parseInt(args[n + 1], 10);
+    if (isNaN(limit) || limit <= 0) {
+      console.log("⚠️ Invalid number for -n. Using default of 5.");
+      limit = 5;
+    }
+  }
+  await myTask(limit); 
   break;
 }
 case "create-task": {
@@ -236,9 +242,6 @@ default:
   console.log("  tnc-cli status                    Show project status");
   console.log("");
 
-  console.log("Branch:");
-  console.log("  tnc-cli create --room <roomId>    Create branch for a room");
-  console.log("");
 
 
   console.log("Tasks:");
@@ -248,6 +251,7 @@ default:
   console.log("  tnc-cli task-complete             Mark task as completed");
   console.log("");
 
+  
   console.log("Team:");
   console.log("  tnc-cli myteam                    Show team members");
   console.log("  tnc-cli invite <email>            Invite member to room");

package/commands/connect.js

@@ -12,56 +12,67 @@ async function connect(roomId) {
     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 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);
+  const machineId = machine.machineIdSync();
 
   try {
-    const response = await axios.post(`https://thinkncollab.com/cli/connect/${roomId}`, {
-      email: email,
-      token: token,
-      machineId: await machine.machineIdSync(),
-      branchName: answer.BranchName,
+    // USING HEADERS FOR AUTHENTICATION
+    const response = await axios({
+      method: 'post',
+      url: `https://thinkncollab.com/cli/connect/${roomId}`,
+      data: {
+        branchName: answer.BranchName  // Only branchName in request body
+      },
+      headers: {
+        'x-user-email': email,
+        'x-user-token': token,
+        'x-machine-id': machineId
+      }
     });
-    const CWD= process.cwd();
+
+    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");
+    
+    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
-    });
+      "currentBranch": answer.BranchName,
+      "lastCommit": null,
+      "files": {}
+    }, null, 2);
+    
     fs.writeFileSync(metaFilePath, metaFileInfo);
-     fs.writeFileSync(
-        pushFilePath,
-       " {} "
-      )
-
-console.log(response.data);
-
-
-
-
+    fs.writeFileSync(pushFilePath, JSON.stringify({}, null, 2));
 
     console.log("✅ Connected to project:", response.data.project.name);
-    console.log("Members connected:", response.data.project.membersConnected);
+    console.log("👥 Members connected:", response.data.project.membersConnected.length);
+    console.log("🌿 Current branch:", answer.BranchName);
 
   } catch (err) {
     if (err.response) {
-      console.error(" Error:", err.response.data.error);
+      console.error("❌ Error:", err.response.data.error || err.response.data.message);
+      if (err.response.status === 401) {
+        console.error("   Please login again.");
+      }
     } else {
-      console.error(" Error:", err.message);
+      console.error("❌ Error:", err.message);
     }
   }
 }
 
-export default connect;
+export default connect;

package/commands/createTask.js

@@ -1,6 +1,5 @@
 import axios from "axios";
 import fs from "fs";
-import os from "os";
 import path from "path";
 import machine from "node-machine-id";
 import chalk from "chalk";
@@ -9,250 +8,125 @@ import open from 'open';
 import http from 'http';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-
 const CWD = process.cwd();
-
-
-function createSpinner(message) {
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let i = 0;
-    
-    const spinner = setInterval(() => {
-        process.stdout.write(`\r${chalk.cyan(frames[i])} ${message}`);
-        i = (i + 1) % frames.length;
-    }, 80);
-    
-    return {
-        stop: (clearMessage = true) => {
-            clearInterval(spinner);
-            if (clearMessage) {
-                process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 50) + '\r');
-            }
-        },
-        update: (newMessage) => {
-            message = newMessage;
-        }
-    };
-}
+const BASE_URL = "https://thinkncollab.com/cli";
 
 async function createTask() {
     try {
-         const { default: getVerify } = await import("../lib/getVerify.js");
+        const { default: getVerify } = await import("../lib/getVerify.js");
+        const { email, token } = await getVerify();
+        const machineId = machine.machineIdSync();
 
-        const { token } = await getVerify();
-
-        const CWD = process.cwd();
         const tncmetaPath = path.join(CWD, ".tnc", ".tncmeta.json");
 
         if (!fs.existsSync(tncmetaPath)) {
             console.error(chalk.red("❌ Not inside a ThinkNCollab project."));
-            console.log(chalk.yellow("Run `tnc-cli init <roomId>` first."));
             return;
         }
 
-        const fileData = JSON.parse(
-            fs.readFileSync(tncmetaPath, "utf-8")
-        );
-
+        const fileData = JSON.parse(fs.readFileSync(tncmetaPath, "utf-8"));
         const roomId = fileData.roomId;
+        const projectName = fileData.projectName || "Unknown Project";
 
         if (!roomId) {
             console.error(chalk.red("❌ No roomId found."));
             return;
         }
-        console.log(chalk.blue('\n🚀 Task Creation CLI\n'));
-        
-        // Validate roomId and token
-        if (!roomId) {
-            console.error(chalk.red('❌ No roomId found in .tnc/.tncmeta.json'));
-            console.log(chalk.yellow('Please ensure you are in a ThinkNCollab project directory'));
-            return;
-        }
-        
-        if (!token) {
-            console.error(chalk.red('❌ No token found'));
-            console.log(chalk.yellow('Please login first using: tnc login'));
-            return;
-        }
         
-        // STEP 1: Find available port FIRST
-        console.log(chalk.gray('🔍 Finding available port for callback server...'));
-        const PORT = await findAvailablePort(3002);
-        console.log(chalk.green(`✅ Callback server will run on port: ${PORT}`));
+        console.log(chalk.blue('\n🚀 Task Creation CLI'));
+        console.log(chalk.gray(`📁 Project: ${projectName}`));
+        console.log(chalk.gray(`🏠 Room ID: ${roomId}\n`));
         
-        // STEP 2: Construct the URL with the found port
-        const redirectUrl = `https://thinkncollab.in/cli/tasks/${roomId}/${token}/create?cli=true&callbackPort=${PORT}`;
+        // STEP 1: Find available port for callback
+        console.log(chalk.gray('🔍 Finding available port for callback...'));
+        const CALLBACK_PORT = await findAvailablePort(3002);
+        console.log(chalk.green(`✅ Callback server on port: ${CALLBACK_PORT}`));
         
-        const spinner = createSpinner('Preparing task creation interface...');  
+        // STEP 2: Create a session first using a direct API call
+        console.log(chalk.blue('\n🔐 Creating secure session...'));
         
-        console.log(chalk.blue('🔗 Opening task creation interface in your browser...'));
-        console.log(chalk.gray(`URL: ${redirectUrl}`));
+        const sessionResponse = await axios.post(`${BASE_URL}/create-session`, {}, {
+            headers: {
+                'x-user-email': email,
+                'x-user-token': token,
+                'x-machine-id': machineId,
+                'x-room-id': roomId
+            }
+        });
         
-        spinner.stop();
+        const { sessionToken } = sessionResponse.data;
+        console.log(chalk.green(`✅ Session created successfully!`));
         
         // STEP 3: Create callback server
-        const server = http.createServer((req, res) => {
-            console.log(chalk.yellow(`\n📨 Callback received: ${req.url}`));
-            
-            // CORS headers for all responses
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-CLI-Callback-URL');
-            res.setHeader('Access-Control-Max-Age', '86400'); // 24 hours
-            
-            // Handle preflight
-            if (req.method === 'OPTIONS') {
-                res.writeHead(200);
-                res.end();
-                return;
-            }
-            
-            // Parse URL
-            const url = new URL(req.url, `http://localhost:${PORT}`);
-            
-            // Check for callback (handle both /callback and direct query params)
-            if (req.url.includes('/callback') || url.searchParams.has('taskId')) {
+        const callbackServer = http.createServer((req, res) => {
+            if (req.url.includes('/callback') || req.url.includes('?taskId=')) {
+                const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
                 const taskId = url.searchParams.get('taskId');
-                const attachments = url.searchParams.get('attachments');
-                const status = url.searchParams.get('status');
+                const taskTitle = url.searchParams.get('title');
                 
-                // Log success
-                if (status === 'error') {
-                    console.log(chalk.red('\n❌ Task creation failed!'));
-                } else {
-                    console.log(chalk.green('\n✅ Task created successfully!'));
-                    if (taskId) {
-                        console.log(chalk.blue(`📋 Task ID: ${taskId}`));
-                        
-                        // Save task ID to file
-                        const taskMetaPath = path.join(CWD, ".tnc", "last-task.json");
-                        fs.writeFileSync(taskMetaPath, JSON.stringify({
-                            taskId,
-                            attachments: attachments ? parseInt(attachments) : 0,
-                            timestamp: new Date().toISOString(),
-                            roomId
-                        }, null, 2));
-                        console.log(chalk.gray(`📝 Task ID saved to .tnc/last-task.json`));
-                    }
-                }
+                console.log(chalk.green(`\n✅ Task Created: ${taskTitle || 'Untitled'} (ID: ${taskId})`));
                 
-                // Send response to close browser (HTML with auto-close)
-                res.writeHead(200, { 
-                    'Content-Type': 'text/html',
-                    'Access-Control-Allow-Origin': '*'
-                });
+                res.writeHead(200, { 'Content-Type': 'text/html' });
                 res.end(`
-                    <!DOCTYPE html>
                     <html>
-                    <head>
-                        <title>${status === 'error' ? 'Failed' : 'Success'}</title>
-                        <style>
-                            body { 
-                                font-family: Arial, sans-serif;
-                                display: flex;
-                                justify-content: center;
-                                align-items: center;
-                                height: 100vh;
-                                margin: 0;
-                                background: ${status === 'error' ? '#f44336' : '#4CAF50'};
-                                color: white;
-                            }
-                            .message {
-                                text-align: center;
-                                padding: 20px;
-                            }
-                        </style>
-                    </head>
-                    <body>
-                        <div class="message">
-                            <h1>${status === 'error' ? '❌ Task Failed' : '✅ Task Created'}</h1>
-                            ${taskId ? `<p>Task ID: ${taskId}</p>` : ''}
-                            <p>Closing in 3 seconds...</p>
-                        </div>
-                        <script>
-                            // Send one more callback to ensure it was received
-                            fetch(window.location.href, { method: 'GET', mode: 'no-cors' });
-                            
-                            // Auto close
-                            setTimeout(() => window.close(), 3000);
-                            
-                            // Fallback
-                            setTimeout(() => {
-                                window.location.href = 'about:blank';
-                                setTimeout(() => window.close(), 100);
-                            }, 4000);
-                        </script>
-                    </body>
+                        <body style="font-family: Arial; text-align: center; padding: 50px;">
+                            <h2>✅ Task Created Successfully!</h2>
+                            <p>Task ID: ${taskId}</p>
+                            <p>Title: ${taskTitle || 'Untitled'}</p>
+                            <p>You can close this window now.</p>
+                            <script>
+                                setTimeout(() => window.close(), 2000);
+                            </script>
+                        </body>
                     </html>
                 `);
                 
-                // Close server after response
+                // Close servers after callback
                 setTimeout(() => {
-                    server.close();
-                    console.log(chalk.gray('\n📡 Callback server closed'));
+                    callbackServer.close();
+                    console.log(chalk.green('\n✅ Task creation complete!'));
                     process.exit(0);
                 }, 2000);
             } else {
-                // Handle other requests (like favicon)
                 res.writeHead(404);
                 res.end('Not found');
             }
         });
         
-        // Server error handling
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                console.log(chalk.yellow(`⚠️  Port ${PORT} is already in use. Callback might not work.`));
-                console.log(chalk.yellow('The task will still be created, but you may need to check manually.'));
-            } else {
-                console.error(chalk.red('Server error:'), err.message);
-            }
+        callbackServer.listen(CALLBACK_PORT, () => {
+            console.log(chalk.green(`✅ Callback server on http://localhost:${CALLBACK_PORT}`));
         });
         
-        // Start server
-        server.listen(PORT, () => {
-            console.log(chalk.gray(`📡 Waiting for callback on http://localhost:${PORT}/callback`));
-        });
+        // STEP 4: Open the task creation page directly with session token
+        const taskCreationUrl = `http://localhost:3001/cli/tasks/${roomId}/create?session=${sessionToken}&cli=true&callbackPort=${CALLBACK_PORT}`;
+        
+        console.log(chalk.blue('\n🔗 Opening task creation interface...'));
         
-        // Open browser
         setTimeout(async () => {
             try {
-                await open(redirectUrl);
+                await open(taskCreationUrl);
                 console.log(chalk.green('✅ Browser opened successfully!'));
             } catch (err) {
-                if (err.message.includes('No application')) {
-                    console.error(chalk.red('❌ Could not open browser automatically.'));
-                    console.log(chalk.yellow('Please manually open this URL in your browser:'));
-                    console.log(chalk.cyan(redirectUrl));
-                } else {
-                    console.error(chalk.red('Browser error:'), err.message);
-                }
+                console.error(chalk.red('❌ Could not open browser automatically.'));
+                console.log(chalk.yellow('Please open this URL manually in your browser:'));
+                console.log(chalk.cyan(taskCreationUrl));
             }
-        }, 500);
+        }, 1000);
         
-        // Wait for callback or timeout
-        await new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                console.log(chalk.yellow('\n⚠️  No callback received within 5 minutes.'));
-                console.log(chalk.gray('Your task may have been created successfully.'));
-                console.log(chalk.gray('Check your browser to confirm.'));
-                server.close();
-                resolve();
-            }, 300000); // 5 minutes
-            
-            server.on('close', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-        });
+        console.log(chalk.gray('\n⏳ Waiting for task creation in browser...'));
+        console.log(chalk.gray('   (The CLI will automatically close when task is created)\n'));
+        
+        // Wait forever (until callback closes)
+        await new Promise(() => {});
         
     } catch (err) {
-        console.error(chalk.red("❌ An unexpected error occurred:"), err.message);
+        console.error(chalk.red("❌ Error:"), err.message);
+        if (err.response) {
+            console.error(chalk.red("Server response:"), err.response.data);
+        }
     }
 }
 
-// Helper function to find available port
 async function findAvailablePort(startPort) {
     const net = await import('net');
     return new Promise((resolve, reject) => {

package/commands/init.js

@@ -3,66 +3,104 @@ import os from "os";
 import path from "path";
 import inquirer from "inquirer";
 import axios from "axios";
-import machine from "node-machine-id";
+import machineId from "node-machine-id";
 
 const CWD = process.cwd();
 
 async function projectInit(roomId) {
-  const answer = await inquirer.prompt([
-    { type: "input", name: "projectName", message: "Enter Project Name:" }
-  ]);
+  try {
+    const answer = await inquirer.prompt([
+      { type: "input", name: "projectName", message: "Enter Project Name:" }
+    ]);
 
-  const HomeDir = os.homedir();
-  const tncrcPath = path.join(HomeDir, ".tncrc");
+    const HomeDir = os.homedir();
+    const tncrcPath = path.join(HomeDir, ".tncrc");
 
-  if (!fs.existsSync(tncrcPath)) {
-    console.error("❌ You are not logged in. Run 'tnc login' first.");
-    process.exit(1);
-  }
-
-  const data = fs.readFileSync(tncrcPath, "utf-8");
-  const currentUser = JSON.parse(data).email;
-  const userToken = JSON.parse(data).token;
+    if (!fs.existsSync(tncrcPath)) {
+      console.error("❌ You are not logged in. Run 'tnc login' first.");
+      process.exit(1);
+    }
 
-  // Initialize project via backend
-  const response = await axios.post("https://thinkncollab.com/cli/init", {
-    projectName: answer.projectName,
-    owner: currentUser,
-    token: userToken,
-    machineId: await machine.machineIdSync(),
-    roomId: roomId 
-  });
+    // Read user credentials from .tncrc
+    const data = fs.readFileSync(tncrcPath, "utf-8");
+    const userData = JSON.parse(data);
+    const currentUser = userData.email;
+    const userToken = userData.token;
+    const machineIdValue = machineId.machineIdSync(); // or await machineId.machineId()
 
-  const projectId = response.data.project._id;
+    console.log("Initializing project...");
 
-  // Ensure .tnc folder exists at project root
-  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");
-  fs.writeFileSync(
-    metaFilePath,
-    JSON.stringify(
+    // Initialize project via backend - CREDENTIALS IN HEADERS
+    const response = await axios.post(
+      "https://thinkncollab.com/cli/init",
       {
-        projectId,
         projectName: answer.projectName,
-        currentBranch: "main",
-        roomId: roomId,
-        lastCommit: null,
-        files: {}
+        roomId: roomId
+        // Note: owner, token, machineId are NOT in body
       },
-      null,
-      2
-    )
-  );
-  fs.writeFileSync(
-    pushFilePath,
-   " {} "
-  )
+      {
+        headers: {
+          'x-user-email': currentUser,
+          'x-user-token': userToken,
+          'x-machine-id': machineIdValue
+        }
+      }
+    );
 
-  console.log("✅ Project initialized successfully!");
+    const projectData = response.data;
+    const projectId = projectData.project._id;
+
+    // Ensure .tnc folder exists at project root
+    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");
+    
+    fs.writeFileSync(
+      metaFilePath,
+      JSON.stringify(
+        {
+          projectId,
+          projectName: answer.projectName,
+          currentBranch: "main",
+          roomId: roomId,
+          lastCommit: null,
+          files: {}
+        },
+        null,
+        2
+      )
+    );
+    
+    fs.writeFileSync(
+      pushFilePath,
+      JSON.stringify({}, null, 2)
+    );
+
+    console.log("✅ Project initialized successfully!");
+    console.log(`📁 Project ID: ${projectId}`);
+    console.log(`🌿 Branch: main`);
+    
+  } catch (error) {
+    if (error.response) {
+      // The request was made and the server responded with a status code outside of 2xx
+      console.error(`❌ Server error: ${error.response.data.message || error.response.status}`);
+      if (error.response.status === 400) {
+        console.error("Please check your login credentials");
+      }
+    } else if (error.request) {
+      // The request was made but no response was received
+      console.error("❌ No response from server. Please check your internet connection.");
+    } else {
+      // Something happened in setting up the request
+      console.error("❌ Error:", error.message);
+    }
+    process.exit(1);
+  }
 }
 
-export default projectInit;
+export default projectInit;