@tertium/hlpr 0.5.8 → 0.6.1

package/bin/commands/process/list-port/list-port.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/process/list-port/list-port.ts
+import { execSync } from "child_process";
+import { platform } from "os";
+function getProcessesOnWindowsPort(port) {
+  try {
+    const output = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+    const processes = [];
+    const lines = output.split(`
+`);
+    const pids = new Set;
+    for (const line of lines) {
+      const match = line.match(/\s+(\d+)\s*$/);
+      if (match) {
+        const pid = parseInt(match[1], 10);
+        if (pid > 0 && !pids.has(pid)) {
+          pids.add(pid);
+          try {
+            const taskOutput = execSync(`tasklist /FI "PID eq ${pid}" /NH /FO CSV`, { encoding: "utf-8" }).trim();
+            const parts = taskOutput.split('","');
+            const command = parts[0].replace(/^"|"$/g, "");
+            processes.push({
+              pid,
+              state: "LISTENING",
+              command
+            });
+          } catch {
+            processes.push({
+              pid,
+              state: "LISTENING"
+            });
+          }
+        }
+      }
+    }
+    return processes;
+  } catch (error) {
+    return [];
+  }
+}
+function getProcessesOnLinuxPort(port) {
+  try {
+    const output = execSync(`lsof -i :${port} -n -P`, { encoding: "utf-8" });
+    const processes = [];
+    const lines = output.split(`
+`);
+    const pids = new Set;
+    for (let i = 1;i < lines.length; i++) {
+      const parts = lines[i].trim().split(/\s+/);
+      if (parts.length > 2) {
+        const command = parts[0];
+        const pid = parseInt(parts[1], 10);
+        const state = parts[7] || "LISTENING";
+        if (!isNaN(pid) && pid > 0 && !pids.has(pid)) {
+          pids.add(pid);
+          processes.push({
+            pid,
+            state,
+            command
+          });
+        }
+      }
+    }
+    return processes;
+  } catch {
+    try {
+      const output = execSync(`netstat -tulnp 2>/dev/null | grep :${port}`, { encoding: "utf-8" });
+      const processes = [];
+      const lines = output.split(`
+`);
+      const pids = new Set;
+      for (const line of lines) {
+        const match = line.match(/(\d+)\/(.+)/);
+        if (match) {
+          const pid = parseInt(match[1], 10);
+          const command = match[2];
+          if (!pids.has(pid)) {
+            pids.add(pid);
+            processes.push({
+              pid,
+              state: "LISTENING",
+              command
+            });
+          }
+        }
+      }
+      return processes;
+    } catch {
+      return [];
+    }
+  }
+}
+function formatTable(processes) {
+  if (processes.length === 0) {
+    return "No processes found";
+  }
+  const pidWidth = 10;
+  const stateWidth = 12;
+  const commandWidth = 50;
+  const header = `${"PID".padEnd(pidWidth)} ${"STATE".padEnd(stateWidth)} COMMAND`;
+  const separator = "\u2500".repeat(pidWidth + stateWidth + commandWidth + 2);
+  const rows = processes.map((p) => {
+    const command = p.command || "unknown";
+    const truncated = command.length > commandWidth ? command.substring(0, commandWidth - 3) + "..." : command;
+    return `${p.pid.toString().padEnd(pidWidth)} ${p.state.padEnd(stateWidth)} ${truncated}`;
+  });
+  return `${header}
+${separator}
+${rows.join(`
+`)}`;
+}
+async function listPort(port, options = {}) {
+  const { verbose = false } = options;
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port number: ${port}. Port must be between 1 and 65535.`);
+  }
+  const os = platform();
+  if (verbose)
+    console.log(`Searching for processes on port ${port} (${os})...
+`);
+  let processes = [];
+  if (os === "win32") {
+    processes = getProcessesOnWindowsPort(port);
+  } else {
+    processes = getProcessesOnLinuxPort(port);
+  }
+  return processes;
+}
+if (import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, "/"))) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    console.log("Usage: list-port <port> [options]");
+    console.log("List process(es) running on a specified port (Windows & Linux support)");
+    console.log();
+    console.log("Arguments:");
+    console.log("  port                  Port number (1-65535)");
+    console.log();
+    console.log("Options:");
+    console.log("  -v, --verbose         Show verbose output");
+    console.log("  -h, --help            Show this help message");
+    console.log();
+    console.log("Examples:");
+    console.log("  hlpr process list-port 3000");
+    console.log("  hlpr process list-port 8080 --verbose");
+    console.log("  hlpr process list-port 5432 -v");
+    process.exit(0);
+  }
+  const port = parseInt(args[0], 10);
+  const verbose = args.includes("-v") || args.includes("--verbose");
+  listPort(port, { verbose }).then((processes) => {
+    console.log(formatTable(processes));
+    process.exit(processes.length === 0 ? 1 : 0);
+  }).catch((error) => {
+    console.error("Error:", error.message);
+    process.exit(1);
+  });
+}
+var list_port_default = { listPort };
+export {
+  listPort,
+  list_port_default as default
+};

package/bin/commands/ssh/README.md

@@ -0,0 +1,80 @@
+# SSH Commands
+
+SSH configuration and setup utilities.
+
+## Platform Support
+
+- ✅ **Linux** - Fully supported
+- ✅ **macOS** - Fully supported
+- ✅ **Windows** - Requires Git Bash or WSL
+  - Git Bash (included with Git for Windows) provides Unix-like `~/.ssh` directory
+  - Native Windows SSH uses `%USERPROFILE%\.ssh` instead
+
+## init-dir
+
+Initialize SSH directory with proper permissions.
+
+### Usage
+
+```bash
+hlpr ssh init-dir
+```
+
+### What it does
+
+Creates the `~/.ssh` directory and essential SSH configuration files with correct permissions:
+
+1. Creates `~/.ssh` directory (if it doesn't exist)
+2. Creates `~/.ssh/known_hosts` file
+3. Creates `~/.ssh/config` file
+4. Sets directory permissions to 700 (rwx------)
+5. Sets file permissions to 644 (rw-r--r--)
+
+### Permissions explained
+
+- `~/.ssh/` → 700 (only owner can read/write/execute)
+- `~/.ssh/known_hosts` → 644 (owner can write, others can read)
+- `~/.ssh/config` → 644 (owner can write, others can read)
+
+These permissions are required by SSH for security. If permissions are incorrect, SSH will refuse to use the files.
+
+### When to use
+
+- Setting up SSH on a new system
+- Fixing SSH permission issues
+- After accidentally deleting SSH configuration files
+
+### Example
+
+```bash
+$ hlpr ssh init-dir
+# Creates ~/.ssh/ with proper structure and permissions
+```
+
+### Verify
+
+```bash
+ls -la ~/.ssh/
+# Should show:
+# drwx------  ~/.ssh/
+# -rw-r--r--  ~/.ssh/config
+# -rw-r--r--  ~/.ssh/known_hosts
+```
+
+### Note
+
+This command will fail if `~/.ssh` already exists. If you need to fix permissions on an existing directory, you can:
+
+```bash
+chmod 700 ~/.ssh
+chmod 644 ~/.ssh/known_hosts
+chmod 644 ~/.ssh/config
+```
+
+### Next steps
+
+After initializing the SSH directory, you typically:
+
+1. Generate SSH keys: `ssh-keygen -t ed25519 -C "your_email@example.com"`
+2. Add SSH config entries to `~/.ssh/config`
+3. Add public key to remote servers or services (GitHub, GitLab, etc.)

package/bin/index.js

@@ -6,7 +6,6 @@ import { exec } from "node:child_process";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import * as readline from "node:readline";
-import * as os from "node:os";
 import { fileURLToPath } from "node:url";
 async function getVersion() {
   try {
@@ -20,13 +19,6 @@ async function getVersion() {
     return "0.0.0";
   }
 }
-function detectShell() {
-  const isWindows = os.platform() === "win32";
-  if (isWindows) {
-    return "bash";
-  }
-  return "bash";
-}
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
 var scriptDir = path.join(__dirname2, "..", "src");
@@ -245,7 +237,7 @@ async function main() {
       }
     }
     if (!isTypeScriptCommand && restArgs.length > 0) {
-      const scriptName = restArgs.join("");
+      const scriptName = restArgs[0];
       let scriptPathCandidate = path.join(scriptDir, "commands", category, `${scriptName}.sh`);
       if (!fs.existsSync(scriptPathCandidate)) {
         scriptPathCandidate = path.join(__dirname2, "..", "bin", "commands", category, `${scriptName}.sh`);
@@ -273,8 +265,8 @@ async function main() {
       const finalCommand = `node "${scriptPath}" ${tsArgs.join(" ")}`;
       console.log(`Executing command: ${finalCommand}`);
       const success2 = await executeCommand(finalCommand, {});
-      const helpFlags = ["-h", "--help", "help", "/h", "/help", "/?"];
-      const isHelpInvocation = tsArgs.some((arg) => helpFlags.includes(arg));
+      const helpFlags2 = ["-h", "--help", "help", "/h", "/help", "/?"];
+      const isHelpInvocation = tsArgs.some((arg) => helpFlags2.includes(arg));
       if (!success2 && !forceFlag && !isHelpInvocation) {
         console.error("Command failed, stopping execution.");
         process.exit(1);
@@ -284,6 +276,7 @@ async function main() {
       return;
     }
     const scriptContent = await readFile(scriptPath, "utf-8");
+    const scriptArgs = restArgs.slice(1);
     const variableRegex = /{{([^}]+)}}/g;
     const variables = {};
     const uniqueVars = new Set;
@@ -291,9 +284,13 @@ async function main() {
     while ((match = variableRegex.exec(scriptContent)) !== null) {
       uniqueVars.add(match[1]);
     }
-    for (const varName of uniqueVars) {
-      const value = await prompt(`Enter ${varName}: `);
-      variables[varName] = value;
+    const helpFlags = ["-h", "--help", "help", "/h", "/help", "/?"];
+    const isHelpRequested = scriptArgs.some((arg) => helpFlags.includes(arg));
+    if (!isHelpRequested) {
+      for (const varName of uniqueVars) {
+        const value = await prompt(`Enter ${varName}: `);
+        variables[varName] = value;
+      }
     }
     let processedScript = scriptContent;
     for (const [key, value] of Object.entries(variables)) {
@@ -301,8 +298,8 @@ async function main() {
     }
     const tempScriptPath = path.join(path.dirname(scriptPath), `_temp_${path.basename(scriptPath)}`);
     fs.writeFileSync(tempScriptPath, processedScript);
-    const shell = detectShell();
-    const command = shell === "powershell" ? `powershell -File "${tempScriptPath}"` : `bash "${tempScriptPath}"`;
+    const argsStr = scriptArgs.map((arg) => `"${arg}"`).join(" ");
+    const command = `bash "${tempScriptPath}" ${argsStr}`;
     const success = await executeCommand(command, {});
     fs.unlinkSync(tempScriptPath);
     if (!success && !forceFlag) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tertium/hlpr",
-  "version": "0.5.8",
+  "version": "0.6.1",
   "description": "Windows and *Nix utility for typical programming activity",
   "author": "Vitalii Balabanov",
   "email": "tertiumnon@gmail.com",
@@ -8,22 +8,21 @@
   "type": "module",
   "scripts": {
     "build:main": "bun build ./src/index.ts --outfile ./bin/index.js --target node",
-    "build:commands": "bun build-commands.js",
+    "build:commands": "bun scripts/build-commands/build-commands.ts",
     "build": "bun run build:main && bun run build:commands",
     "test": "bun test",
-    "test:e2e": "bun scripts/test-rename-e2e.cjs",
+    "test:e2e": "bun scripts/test-rename/test-rename.ts",
     "prepublishOnly": "bun run build",
-    "release:minor": "bun node_modules/@tertium/js/scripts/release.js minor",
     "release:patch": "bun node_modules/@tertium/js/scripts/release.js patch",
+    "release:minor": "bun node_modules/@tertium/js/scripts/release.js minor",
     "release:major": "bun node_modules/@tertium/js/scripts/release.js major",
-    "prepare": "husky"
+    "setup:hooks": "git config core.hooksPath .githooks"
   },
   "dependencies": {
     "@tertium/js": "^1.4.7"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",
-    "husky": "^9.1.7",
     "typescript": "^5.8.3"
   },
   "bin": {