@voxframeworks/linetools 1.0.0

package/main.js

@@ -0,0 +1,14 @@
+const mkdir = require('./tools/mkdir.js');
+const cp = require('./tools/cp.js');
+const touch = require('./tools/touch.js');
+const mv = require('./tools/mv.js');
+const tar = require('./tools/tar.js');
+const rmdir = require('./tools/rmdir.js');
+module.exports = {
+    mkdir : mkdir,
+    cp : cp,
+    touch : touch,
+    mv : mv,
+    tar : tar,
+    rmdir : rmdir
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@voxframeworks/linetools",
+  "version": "1.0.0",
+  "description": "command line tools for js",
+  "main": "main.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["line tools", "command line", "cli"],
+  "author": "VoxFrameworks",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "fstream": "^1.0.12",
+    "tar": "^7.5.3"
+  }
+}

package/readme.md

@@ -0,0 +1,27 @@
+```
+  _     _           _____           _     
+ | |   (_)_ __   __|_   _|__   ___ | |___ 
+ | |   | | '_ \ / _ \| |/ _ \ / _ \| / __|
+ | |___| | | | |  __/| | (_) | (_) | \__ \
+ |_____|_|_| |_|\___||_|\___/ \___/|_|___/
+
+
+Linetools is a npm package that lets you use command line tools in a js file.
+
+An Example usage is:
+linetools.mkdir('testDir');
+
+This will create a directory named testDir in the current directory.
+
+We have many commands available.
+The list of commands we have is:
+• mkdir
+• rmdir
+• cp
+• mv
+• touch
+• tar
+
+We will be adding more soon!
+
+By VoxFrameworks

package/test.js

@@ -0,0 +1,2 @@
+const linetools = require('linetools');
+linetools.tar('testOUT', 'testDir', 'rezip')

package/tools/cp.js

@@ -0,0 +1,19 @@
+const fs = require('fs').promises;
+
+/**
+ * Asynchronously copies the file or directory from the source path to the destination path.
+ *
+ * @param {string} sourcePath - The source file or directory path.
+ * @param {string} destinationPath - The destination file or directory path.
+ */
+async function cp(sourcePath, destinationPath) {
+  try {
+    // The 'recursive: true' option is necessary to copy directories and their contents.
+    await fs.cp(sourcePath, destinationPath, { recursive: true });
+    console.log(`Contents of '${sourcePath}' copied successfully to '${destinationPath}'!`);
+  } catch (error) {
+    console.error('Failed to copy files or directory:', error.message);
+  }
+}
+
+module.exports = cp;

package/tools/mkdir.js

@@ -0,0 +1,11 @@
+const fs = require('fs').promises;
+
+async function mkdir(directoryPath) {
+  try {
+    await fs.mkdir(directoryPath, { recursive: true });
+    console.log(`Directory '${directoryPath}' created successfully!`);
+  } catch (error) {
+    console.error('Failed to create directory:', error);
+  }
+}
+module.exports = mkdir;

package/tools/mv.js

@@ -0,0 +1,22 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+async function mv(oldPath, newPath) {
+  try {
+    // Ensure the destination directory exists (optional, but robust)
+    const destinationDir = path.dirname(newPath);
+    await fs.mkdir(destinationDir, { recursive: true });
+
+    // Move the file or directory
+    await fs.rename(oldPath, newPath);
+    console.log(`Moved from '${oldPath}' to '${newPath}' successfully!`);
+  } catch (error) {
+    console.error('Failed to move:', error);
+    // Handle specific errors like moving across different file systems (EXDEV)
+    if (error.code === 'EXDEV') {
+      console.error('Operation failed across different devices. Consider using fs-extra for cross-device moves.');
+    }
+  }
+}
+
+module.exports = mv;

package/tools/rmdir.js

@@ -0,0 +1,22 @@
+const fs = require('fs').promises;
+
+/**
+ * Asynchronously removes a directory.
+ * @param {string} directoryPath - The path to the directory to remove.
+ */
+async function rmdir(directoryPath) {
+  try {
+    // The 'recursive: true' option is crucial for removing non-empty directories.
+    await fs.rm(directoryPath, { recursive: true, force: true });
+    console.log(`Directory '${directoryPath}' removed successfully!`);
+  } catch (error) {
+    // Check if the error indicates the directory wasn't found to provide a clearer message
+    if (error.code === 'ENOENT') {
+      console.warn(`Directory '${directoryPath}' does not exist, skipping removal.`);
+    } else {
+      console.error('Failed to remove directory:', error);
+    }
+  }
+}
+
+module.exports = rmdir;

package/tools/tar.js

@@ -0,0 +1,69 @@
+const tarModule = require('tar');
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Handles tar archive operations (unzip/rezip) for files and folders.
+ * @param {string} targetPath - The path to the tarball file (output for rezip, input for unzip).
+ * @param {string} sourcePath - The source directory/files for rezip, or the destination directory for unzip.
+ * @param {'unzip' | 'rezip'} type - The operation type.
+ */
+async function tar(targetPath, sourcePath, type) {
+    try {
+        if (type === 'unzip') {
+            // Ensure the destination directory exists
+            await fs.mkdir(sourcePath, { recursive: true });
+            console.log(`Starting extraction of '${targetPath}' to '${sourcePath}'...`);
+            // Extracting from a tarball (handles .tar, .tar.gz automatically with modern 'tar')
+            await tarModule.extract({
+                file: targetPath,
+                cwd: sourcePath, // Extract *into* this directory
+            });
+            console.log('Extraction completed successfully!');
+        } else if (type === 'rezip') {
+            const tarballDir = path.dirname(targetPath);
+            await fs.mkdir(tarballDir, { recursive: true }); // Ensure output dir exists
+
+            // For zipping folders, use tar.pack() with streams for better control & recursion
+            // or tar.create() if you prefer the object API and ensure 'gzip: true' for .tar.gz
+console.log(`Starting creation of tarball '${targetPath}' from '${sourcePath}'...`);
+    // Use tar.create or tar.c for creating streams
+    const archiveStream = tarModule.create({ gzip: targetPath.endsWith('.gz') }, sourcePath);
+            
+          fileHandle = await fs.open(targetPath, 'w');
+
+        // Create the write stream from the file handle
+        const writeStream = fileHandle.createWriteStream();
+            
+            // If you need .tar.gz, pipe through gzip stream
+            if (targetPath.endsWith('.gz')) {
+                const zlib = require('zlib');
+                await new Promise((resolve, reject) => {
+                    archiveStream
+                        .pipe(zlib.createGzip()) // Add gzip compression
+                        .pipe(outputStream)
+                        .on('finish', resolve)
+                        .on('error', reject);
+                });
+            } else {
+                // For plain .tar
+                await new Promise((resolve, reject) => {
+                    archiveStream
+                        .pipe(outputStream)
+                        .on('finish', resolve)
+                        .on('error', reject);
+                });
+            }
+            
+            console.log('Tarball creation completed successfully!');
+
+        } else {
+            throw new Error('Invalid type specified. Use "unzip" or "rezip".');
+        }
+    } catch (error) {
+        console.error(`Failed to perform tar operation (${type}):`, error.message);
+        throw error; // Rethrow to allow the calling function to handle the error
+    }
+}
+
+module.exports = tar;

package/tools/touch.js

@@ -0,0 +1,21 @@
+const fs = require('fs').promises;
+
+async function touch(filePath) {
+  try {
+    const now = new Date();
+    // Try to update access and modification times (like 'touch' on existing files)
+    await fs.utimes(filePath, now, now);
+    console.log(`Updated timestamp for '${filePath}'`);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      // If file doesn't exist, create an empty one
+      // Using 'a' (append) ensures we don't overwrite if it was just created
+      const fileHandle = await fs.open(filePath, 'a');
+      await fileHandle.close();
+      console.log(`File '${filePath}' created successfully!`);
+    } else {
+      console.error('Failed to touch file:', error);
+    }
+  }
+}
+module.exports = touch;