thinkncollab-cli 0.0.83 → 0.0.85

package/bin/index.js

@@ -17,6 +17,9 @@ import connect from '../commands/connect.js'
 import machine from  "node-machine-id";
 import push from "../commands/push.js";
 import taskCompletion from "../commands/taskCompletion.js";
+import task from "../commands/task.js";
+import createTask from "../commands/createTask.js";
+import myTeam from "../commands/myTeam.js";
 
 
 
@@ -26,6 +29,18 @@ const VERSION_FILE = path.join(process.cwd(), ".tncversions");
 const BASE_URL = "https://thinkncollab.com/rooms";
 const CWD = process.cwd();
 
+async function DAPP() {
+  try {
+   const res =  await axios.get(`http://localhost:4545/logout`);
+    console.log("✅ Command sent to ThinkNCollab Agent");
+    console.log(res.data.message);
+  } catch (err) {
+    console.error("❌ ThinkNCollab Agent not running");
+    process.exit(1);
+  }
+}
+
+
 /** ------------------ LOGIN ------------------ **/
 async function login() {
   const answers = await inquirer.prompt([
@@ -175,6 +190,17 @@ case "my-tasks": {
   await myTask(); 
   break;
 }
+case "create-task": {
+  const roomIdx = args.indexOf("create-task");
+
+
+  await createTask(); 
+  break;
+}
+case "send": {
+  await send(); 
+  break;
+}
 case "invite": {
   const roomIdx = args.indexOf("invite");
   if (roomIdx === -1 || !args[roomIdx + 1]) {
@@ -185,10 +211,28 @@ case "invite": {
 
   await sendInvite(email); 
   break;
+}
+case "task": {
+  task();
+  break;
+}
+
+case "myteam": {
+  myTeam();
+  break;
+}
+
+case "signout": {
+  await DAPP();
+  break;
+ 
 }
 
     default:
-      console.log("✅ TNC CLI ready!");
+      console.log('================================');
+      console.log(' START REAL SYSTEM SHELL ');
+      console.log('================================ */ ');
+      console.log("✅ ThinkNCollab CLI ready!");
       console.log("Commands:");
       console.log("  tnc-cli login --> to login");
       console.log("  tnc-cli init <roomId>  --> to use CLI for a room");
@@ -200,6 +244,7 @@ case "invite": {
       // console.log("  tnc-cli status");
       console.log("  tnc-cli whoami  --> to know by which Id you are loggedin");
       console.log("  tnc-cli my-tasks --> to get ur tasks from the room ");
+      console.log("  tnc-cli tasks --> to know thetask details");
       console.log("  tnc-cli task-complete  --> to change the task status to complete")
       console.log("  tnc-cli logout  --> to logout");
       console.log("  tnc-cli help  --> to get help");

package/commands/connect.js

@@ -3,6 +3,7 @@ import machine from "node-machine-id";
 import fs from "fs";
 import os from "os";
 import path from "path";
+import inquirer from "inquirer";
 
 const tncrcPath = path.join(os.homedir(), ".tncrc");
 
@@ -19,7 +20,7 @@ async function connect(roomId) {
   const { email, token } = JSON.parse(data);
 
   try {
-    const response = await axios.post(`https://thinkncollab.com/cli/connect/${roomId}`, {
+    const response = await axios.post(`http://localhost:3001/cli/connect/${roomId}`, {
       email: email,
       token: token,
       machineId: await machine.machineIdSync(),

package/commands/createTask.js

@@ -0,0 +1,260 @@
+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";
+import { fileURLToPath } from 'url';
+import open from 'open';
+import http from 'http';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const getVerifyModule = await import("../lib/getVerify.js");
+const getVerify = getVerifyModule.default;
+const { token } = await getVerify();
+
+const CWD = process.cwd();
+const tncmetaPath = path.join(CWD, ".tnc", ".tncmeta.json"); 
+const fileData = fs.existsSync(tncmetaPath) ? JSON.parse(fs.readFileSync(tncmetaPath, "utf-8")) : null;
+const roomId = fileData?.roomId || null;
+
+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;
+        }
+    };
+}
+
+async function createTask() {
+    try {
+        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;
+        }
+        
+        // console.log(chalk.green(`✅ Room ID: ${roomId}`));
+        // console.log(chalk.green(`✅ Token: ${token.substring(0, 10)}...${token.substring(token.length - 10)}\n`));
+        
+        // Construct the URL with CLI flag
+        const redirectUrl = `https://thinkncollab.in/cli/tasks/${roomId}/${token}/create?cli=true`;
+        
+        const spinner = createSpinner('Preparing task creation interface...');  
+        
+        console.log(chalk.blue('🔗 Opening task creation interface in your browser...'));
+        console.log(chalk.gray(`URL: ${redirectUrl}`));
+        
+        // Find available port
+        const PORT = await findAvailablePort(3002);
+        spinner.stop();
+        
+        // Create callback server
+// Create callback server with better CORS and request handling
+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 taskId = url.searchParams.get('taskId');
+        const attachments = url.searchParams.get('attachments');
+        const status = url.searchParams.get('status');
+        
+        // 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 ? attachments.length : 0,
+                    timestamp: new Date().toISOString(),
+                    roomId
+                }, null, 2));
+                console.log(chalk.gray(`📝 Task ID saved to .tnc/last-task.json`));
+            }
+            if (attachments) {
+                // console.log(chalk.blue(`📎 Attachments: ${attachments}`));
+            }
+        }
+        
+        // Send response to close browser (HTML with auto-close)
+        res.writeHead(200, { 
+            'Content-Type': 'text/html',
+            'Access-Control-Allow-Origin': '*'
+        });
+        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>
+            </html>
+        `);
+        
+        // Close server after response
+        setTimeout(() => {
+            server.close();
+            console.log(chalk.gray('\n📡 Callback server closed'));
+            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);
+            }
+        });
+        
+        // Start server
+        server.listen(PORT, () => {
+            // console.log(chalk.gray(`📡 Waiting for callback on http://localhost:${PORT}/callback`));
+            // console.log(chalk.gray('The browser will automatically close after task creation\n'));
+        });
+        
+        // Open browser
+        setTimeout(async () => {
+            try {
+                await open(redirectUrl);
+                // 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);
+                }
+            }
+        }, 500);
+        
+        // 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();
+            });
+        });
+        
+    } catch (err) {
+        console.error(chalk.red("❌ An unexpected error occurred:"), err.message);
+    }
+}
+
+// Helper function to find available port
+async function findAvailablePort(startPort) {
+    const net = await import('net');
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(startPort, () => {
+            const port = server.address().port;
+            server.close(() => resolve(port));
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(findAvailablePort(startPort + 1));
+            } else {
+                reject(err);
+            }
+        });
+    });
+}
+
+export default createTask;

package/commands/myTask.js

@@ -2,97 +2,138 @@ import fs from "fs";
 import path from "path";
 import axios from "axios";
 import os from "os";
-import machine from 'node-machine-id';
-
+import machine from "node-machine-id";
+import CliTable3 from "cli-table3";
+import chalk from "chalk";
 
 const homeDir = os.homedir();
-const url = "https://thinkncollab.com/cli/mytasks"; // backend endpoint
+const url = "https://thinkncollab.com/cli/mytasks";
 
-// Get saved email from ~/.tncrc
-async function getEmail() {
+// -----------------------------
+// Read ~/.tncrc
+// -----------------------------
+function getAuthData() {
   const rcFile = path.join(homeDir, ".tncrc");
 
   if (!fs.existsSync(rcFile)) {
-    console.log("⚠️ Please login first!");
-    process.exit(1);
-  }
-
-  const content = fs.readFileSync(rcFile, "utf-8");
-  const email = JSON.parse(content).email;
-  return email;
-}
-
-// Get saved token from ~/.tncrc
-async function getToken() {
-  const rcFile = path.join(homeDir, ".tncrc");
-  if (!fs.existsSync(rcFile)) {
-    console.log("⚠️ Please login first!");
+    console.log(chalk.red("⚠️ Please login first!"));
     process.exit(1);
   }
 
-  const content = fs.readFileSync(rcFile, "utf-8");
-  const token = JSON.parse(content).token;
-  return token;
+  return JSON.parse(fs.readFileSync(rcFile, "utf-8"));
 }
 
-// Fetch tasks for a given room
+// -----------------------------
+// Main Function
+// -----------------------------
 async function myTask() {
   try {
-    const email = await getEmail();
-    const token = await getToken();
+    const { email, token } = getAuthData();
 
     const CWD = process.cwd();
-    const metaDataPath = path.join(".tnc", ".tncmeta.json"); // assuming room ID is stored here
-    if (!fs.existsSync(path.join(CWD, metaDataPath))) {
-      console.log("⚠️ Room metadata not found in current directory!");
+    const metaDataPath = path.join(CWD, ".tnc", ".tncmeta.json");
+
+    if (!fs.existsSync(metaDataPath)) {
+      console.log(chalk.yellow("⚠️ Room metadata not found in current directory!"));
       return;
     }
 
-    const metaData = JSON.parse(fs.readFileSync(path.join(CWD, metaDataPath), "utf-8"));
+    const metaData = JSON.parse(fs.readFileSync(metaDataPath, "utf-8"));
     const roomId = metaData.roomId;
 
-    // Prepare cache
-    const cacheDir = path.join(homeDir, ".tnc");
+    const cacheDir = path.join(CWD, ".tnc");
     if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir);
-    const cacheFile = path.join(cacheDir, `${roomId}-tasks.json`);
+
+    const cacheFile = path.join(cacheDir, "tasks.json");
 
     let tasks = [];
 
     try {
-      // Try fetching tasks online
       const res = await axios.get(`${url}/${roomId}`, {
-        params: { email, token, machineId: machine.machineId() }
+        params: {
+          email,
+          token,
+          machineId: machine.machineIdSync()
+        }
       });
 
       tasks = res.data.tasks || [];
 
-      // Save to cache
       fs.writeFileSync(cacheFile, JSON.stringify(tasks, null, 2));
 
     } catch (error) {
-      // If fetch fails, use offline cache
       if (fs.existsSync(cacheFile)) {
-        console.log("⚠️ Offline mode: showing cached tasks");
+        console.log(chalk.yellow("⚠️ Offline mode: showing cached tasks"));
         tasks = JSON.parse(fs.readFileSync(cacheFile, "utf-8"));
       } else {
-        console.error("❌ Error fetching tasks and no cache available:", error.response?.data || error.message);
+        console.error(
+          chalk.red("❌ Error fetching tasks and no cache available:"),
+          error.response?.data || error.message
+        );
         return;
       }
     }
 
-    // Display tasks
     if (!tasks.length) {
-      console.log("📭 No tasks assigned.");
+      console.log(chalk.gray("📭 No tasks assigned."));
       return;
     }
 
-    console.log("📋 Your Tasks:");
-    tasks.forEach((task, i) => {
-      console.log(`${i + 1}. ${task.title} — ${task.status}   ${task._id}`);
+    // -----------------------------
+    // Create Table
+    // -----------------------------
+const table = new CliTable3({
+  head: [
+    chalk.cyan.bold("Title"),
+    chalk.green.bold("Status"),
+    chalk.magenta.bold("Category"),
+    chalk.red.bold("Priority"),
+    chalk.yellow.bold("ID"),
+    chalk.blue.bold("Att.")
+  ],
+  colWidths: [30, 12, 18, 10, 26, 6], // adjusted
+  wordWrap: true,
+  style: {
+    head: [],
+    border: ["grey"]
+  }
+});
+
+
+    console.log(chalk.bold.cyan("\n📋 YOUR TASKS\n"));
+
+    tasks.forEach(task => {
+
+      // Status color
+      let statusColor =
+        task.status === "completed"
+          ? chalk.green
+          : task.status === "in-progress"
+          ? chalk.yellow
+          : chalk.red;
+
+      // Priority color
+      let priorityColor =
+        task.priority === "high"
+          ? chalk.red
+          : task.priority === "medium"
+          ? chalk.yellow
+          : chalk.green;
+
+      table.push([
+        chalk.white(task.title),
+        statusColor(task.status),
+        chalk.magenta(task.category || "General"),
+        priorityColor(task.priority || "low"),
+        chalk.gray(task._id),
+        chalk.blue(task.attachments?.length || 0)
+      ]);
     });
 
+    console.log(table.toString());
+
   } catch (error) {
-    console.error("❌ Error:", error.message);
+    console.error(chalk.red("❌ Error:"), error.message);
   }
 }
 

package/commands/myTeam.js

@@ -0,0 +1,44 @@
+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";
+import FormData from "form-data";
+import getVerify from "../lib/getVerify.js";
+
+const CWD = process.cwd();
+const TNC_API_URL = "http://localhost:3001/";
+const metaDataFile = path.join(CWD, ".tnc", ".tncmeta.json");
+const metaData = JSON.parse(fs.readFileSync(metaDataFile, "utf-8"));
+const roomId = metaData.roomId;
+
+async function myTeam() {
+    try {
+        const verifyData = await getVerify();
+        const { email, token } = verifyData;
+        const response = await axios.get(`${TNC_API_URL}cli/myTeam/${roomId}`, {
+            headers: {
+                email,
+                token,
+                machineId: machine.machineIdSync(),
+            },
+        });
+        const teamMembers = response.data.RoomMembers || [];
+        if (teamMembers.length === 0) {
+            console.log(chalk.yellow("⚠️  You are not part of any team yet."));
+            return;
+        }
+        console.log(chalk.green("👥 Your Team Members:"))
+        teamMembers.forEach(member => {
+            console.log(chalk.blue(`- ${member.name} (${member.email})`));
+        });
+    } catch (err) {
+        if (err.response) {
+            console.error(chalk.red("❌ Error:"), chalk.red(err.response.data.error));
+        } else {
+            console.error(chalk.red("❌ Error:"), chalk.red(err.message));
+        }
+    }
+}
+export default myTeam;

package/commands/send.js

@@ -0,0 +1,16 @@
+import axios from "axios"
+
+let data = {
+    
+}
+
+function sendData() {
+    const res = axios.post('http://172.16.44.215:5001/senddata', 
+        {
+            "name": "Raman Singh",
+            "email": "admin@thinkncollab.com"
+        }
+    );
+
+}
+sendData();

package/commands/task.js

@@ -0,0 +1,190 @@
+import axios from "axios";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import machine from "node-machine-id";
+import inquirer from "inquirer";
+import chalk from "chalk";
+
+const CWD = process.cwd();
+const tncrcPath = path.join(os.homedir(), ".tncrc");
+const taskFilePath = path.join(CWD, ".tnc", "tasks.json");
+
+async function task() {
+    try {
+        // Validate login
+        if (!fs.existsSync(tncrcPath)) {
+            console.error("❌ You are not logged in. Run 'tnc login' first.");
+            return;
+        }
+
+        // Validate project init
+        if (!fs.existsSync(taskFilePath)) {
+            console.error("❌ This directory is not initialized. Run 'tnc init' first.");
+            return;
+        }
+
+        // Ask Task ID
+        const { taskId } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "taskId",
+                message: "Enter Task ID:",
+            },
+        ]);
+
+        if (!taskId?.trim()) {
+            console.error("❌ Task ID cannot be empty.");
+            return;
+        }
+
+        const { email, token } = JSON.parse(fs.readFileSync(tncrcPath, "utf-8"));
+        const localData = JSON.parse(fs.readFileSync(taskFilePath, "utf-8"));
+        const localTasks = localData.tasks || [];
+
+        // API call (correct way using headers)
+        const response = await axios.get(
+            `https://thinkncollab.com/cli/task/${taskId.trim()}`,
+            {
+                headers: {
+                    email,
+                    token,
+                    machineId: machine.machineIdSync(),
+                },
+            }
+        );
+
+        const serverTasks = Array.isArray(response.data.task)
+            ? response.data.task
+            : [response.data.task];
+
+        // Sync with local file
+        serverTasks.forEach((serverTask) => {
+            const index = localTasks.findIndex((t) => t.id === serverTask.id);
+
+            if (index !== -1) {
+                localTasks[index] = {
+                    ...localTasks[index],
+                    ...serverTask,
+                };
+            } else {
+                localTasks.push(serverTask);
+            }
+        });
+
+        fs.writeFileSync(
+            taskFilePath,
+            JSON.stringify({ tasks: localTasks }, null, 2)
+        );
+
+        console.log("✅ Task synced successfully");
+
+        serverTasks.forEach(task => {
+            console.log(chalk.gray("\n------------------------------------------"));
+
+            const statusColor =
+                task.status === "completed"
+                    ? chalk.green
+                    : task.status === "in-progress"
+                        ? chalk.yellow
+                        : chalk.red;
+            const priorityColor =
+                task.priority === "high"
+                    ? chalk.red
+                    : task.priority === "medium"
+                        ? chalk.yellow
+                        : chalk.green;
+
+
+            printField("Task ID", task._id, chalk.cyan.bold, chalk.white);
+            printField("Title", task.title, chalk.green.bold, chalk.white);
+            printField("Description", task.description || "N/A", chalk.yellow.bold, chalk.white);
+            printField("Status", task.status, chalk.blue.bold, statusColor);
+            printField("Priority", task.priority, chalk.magenta.bold, priorityColor);
+            printField(
+                "Due Date",
+                task.dueDate ? new Date(task.dueDate).toDateString() : "N/A",
+                chalk.cyan.bold,
+                chalk.white
+            );
+
+            if (task.attachments?.length > 0) {
+                printField("Attachments", `${task.attachments.length}`, chalk.blue.bold, chalk.white);
+
+                task.attachments.forEach((att, index) => {
+                    console.log(
+                        chalk.gray(`                 ${index + 1}. ID: ${att._id}`)
+                    );
+                    console.log(
+                        chalk.gray(`                    Name: ${att.name}`)
+                    );
+                });
+            } else {
+                printField("Attachments", "None", chalk.blue.bold, chalk.gray);
+            }
+
+            console.log(chalk.gray("------------------------------------------\n"));
+        });
+
+
+
+
+    } catch (err) {
+        console.error(
+            "❌ Error:",
+            err.response?.data?.error || err.message
+        );
+    }
+}
+
+function printField(label, value, labelColor, valueColor, width = 15) {
+  const terminalWidth = process.stdout.columns || 80;
+
+  const plainLabel = label.padEnd(width);
+  const labelPart = `${plainLabel} : `;
+  const indent = " ".repeat(labelPart.length);
+
+  const availableWidth = terminalWidth - indent.length;
+
+  // Normalize multiline input
+  const rawLines = String(value).replace(/\r/g, "").split("\n");
+
+  rawLines.forEach((rawLine, lineIndex) => {
+    let words = rawLine.split(" ");
+    let currentLine = "";
+
+    words.forEach(word => {
+      if ((currentLine + word).length > availableWidth) {
+        if (lineIndex === 0 && currentLine === "") {
+          console.log(
+            labelColor(plainLabel) + " : " + valueColor(word)
+          );
+        } else {
+          console.log(indent + valueColor(currentLine.trim()));
+          currentLine = word + " ";
+        }
+      } else {
+        currentLine += word + " ";
+      }
+    });
+
+    if (currentLine.trim()) {
+      if (lineIndex === 0) {
+        console.log(
+          labelColor(plainLabel) +
+            " : " +
+            valueColor(currentLine.trim())
+        );
+      } else {
+        console.log(indent + valueColor(currentLine.trim()));
+      }
+    }
+
+    // After first printed line, ensure next raw lines are indented
+    lineIndex = 1;
+  });
+}
+
+
+
+export default task;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "thinkncollab-cli",
   "author": "Raman Singh",
-  "version": "0.0.83",
+  "version": "0.0.85",
   "description": "CLI tool for ThinkNCollab",
   "main": "index.js",
   "bin": {
@@ -14,7 +14,11 @@
   "dependencies": {
     "axios": "^1.12.2",
     "chalk": "^5.6.2",
-    "inquirer": "^9.3.8",
-    "node-machine-id": "^1.1.12"
+    "cli-table3": "^0.6.5",
+    "form-data": "^4.0.5",
+    "inquirer": "^8.2.5",
+    "inquirer-file-selector": "^1.0.1",
+    "node-machine-id": "^1.1.12",
+    "open": "^11.0.0"
   }
-}
+}