@miraj181/ipingyou 2.0.12 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraj181/ipingyou",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "description": "SecureLink-CLI — Secure peer-to-peer remote access via SSH & Cloudflare Tunnels",
   "main": "src/cli.js",
   "bin": {

package/src/lib/path-browser.js

@@ -6,6 +6,15 @@ import path from 'node:path';
 import os from 'node:os';
 import { buildSshArgs, formatRemoteCd } from './ssh.js';
 
+class RemoteDirectoryError extends Error {
+  constructor(message, remoteDir, stderr = '') {
+    super(message);
+    this.name = 'RemoteDirectoryError';
+    this.remoteDir = remoteDir;
+    this.stderr = stderr;
+  }
+}
+
 function expandLocalPath(inputPath) {
   const trimmed = inputPath.trim();
   if (trimmed === '~') return os.homedir();
@@ -108,12 +117,13 @@ async function listRemoteDirectory(username, hostname, privateKeyPath, remoteDir
   sshArgs.push(`${username}@${hostname}`, command);
 
   const result = await execa('ssh', sshArgs, {
-    stdio: ['inherit', 'pipe', 'inherit'],
+    stdio: ['inherit', 'pipe', 'pipe'],
     reject: false,
   });
 
   if (result.exitCode !== 0) {
-    throw new Error('Remote directory listing failed');
+    const detail = result.stderr.trim() || `ssh exited with code ${result.exitCode}`;
+    throw new RemoteDirectoryError(`Remote directory listing failed: ${detail}`, remoteDir, result.stderr);
   }
 
   const lines = result.stdout.split(/\r?\n/).filter(Boolean);
@@ -176,6 +186,18 @@ export async function promptRemotePath(username, hostname, privateKeyPath, purpo
       listing = await listRemoteDirectory(username, hostname, privateKeyPath, currentDir);
     } catch (err) {
       console.log(chalk.yellow(`  ⚠️  Could not browse host files: ${err.message}`));
+      if (/Operation not permitted/i.test(err.stderr || err.message)) {
+        console.log(chalk.dim('     macOS privacy blocked this SSH session from listing that folder.'));
+        console.log(chalk.dim('     On the host, allow Full Disk Access for sshd/Remote Login, or choose a non-protected folder.'));
+      }
+
+      const parentDir = currentDir === '/' ? '/' : path.posix.dirname(currentDir);
+      if (parentDir && parentDir !== currentDir) {
+        console.log(chalk.dim(`     Returning to ${parentDir}.`));
+        currentDir = parentDir;
+        continue;
+      }
+
       console.log(chalk.dim('     Falling back to manual host path entry.'));
       const { remotePath } = await inquirer.prompt([{
         type: 'input',

package/src/lib/ssh.js

@@ -21,10 +21,7 @@ export function formatRemoteCd(remotePath) {
 export function formatScpRemotePath(remotePath) {
   const trimmed = String(remotePath || '').trim();
   if (!trimmed || trimmed === '~') return trimmed || '~';
-  if (trimmed.startsWith('~/')) {
-    return `~/${quoteRemoteShell(trimmed.slice(2))}`;
-  }
-  return quoteRemoteShell(trimmed);
+  return trimmed;
 }
 
 export function getSshControlOptions(hostname) {

package/src/modes/client.js

@@ -42,6 +42,28 @@ async function promptUsername() {
   return username.trim();
 }
 
+function normalizePrivateKey(privateKey) {
+  const normalized = String(privateKey || '').replace(/\\n/g, '\n').replace(/\r\n/g, '\n');
+  return normalized.endsWith('\n') ? normalized : `${normalized}\n`;
+}
+
+async function writeEphemeralPrivateKey(privateKey) {
+  const keyPath = path.join(os.tmpdir(), `ipingyou_client_${Date.now()}`);
+  fs.writeFileSync(keyPath, normalizePrivateKey(privateKey), { mode: 0o600 });
+
+  const result = await execa('ssh-keygen', ['-y', '-f', keyPath], {
+    reject: false,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (result.exitCode !== 0) {
+    try { fs.unlinkSync(keyPath); } catch {}
+    throw new Error(result.stderr.trim() || 'OpenSSH could not parse the host-provided private key');
+  }
+
+  return keyPath;
+}
+
 /**
  * Start SSH connection through the Cloudflare tunnel.
  */
@@ -162,6 +184,7 @@ async function performSCP(username, hostname, direction, privateKeyPath) {
       if (direction === 'upload' && localHash) {
         console.log(chalk.dim('  🔍 Verifying remote SHA-256 checksum...'));
         try {
+          const remoteChecksumPath = joinRemotePath(remotePath, path.basename(localPath));
           const sshArgs = [
             '-o', `ProxyCommand=${proxyCommand}`,
             '-o', 'StrictHostKeyChecking=accept-new',
@@ -169,7 +192,7 @@ async function performSCP(username, hostname, direction, privateKeyPath) {
             ...getSshControlOptions(hostname)
           ];
           if (privateKeyPath) sshArgs.push('-i', privateKeyPath, '-o', 'IdentityAgent=none');
-          sshArgs.push(`${username}@${hostname}`, `shasum -a 256 ${quoteRemoteShell(remotePath)} || sha256sum ${quoteRemoteShell(remotePath)}`);
+          sshArgs.push(`${username}@${hostname}`, `shasum -a 256 ${quoteRemoteShell(remoteChecksumPath)} 2>/dev/null || sha256sum ${quoteRemoteShell(remoteChecksumPath)} 2>/dev/null || shasum -a 256 ${quoteRemoteShell(remotePath)} 2>/dev/null || sha256sum ${quoteRemoteShell(remotePath)}`);
           
           const { stdout } = await execa('ssh', sshArgs, { reject: false });
           const remoteHash = stdout.split(' ')[0].trim();
@@ -198,6 +221,13 @@ async function performSCP(username, hostname, direction, privateKeyPath) {
   }
 }
 
+function joinRemotePath(parent, child) {
+  const cleanParent = String(parent || '').replace(/\/+$/, '');
+  if (!cleanParent) return child;
+  if (cleanParent === '/') return `/${child}`;
+  return `${cleanParent}/${child}`;
+}
+
 /**
  * Main Client Mode entry point.
  */
@@ -334,11 +364,16 @@ export async function startClientMode(options = {}) {
   let privateKeyPath = null;
   if (payload.privateKey) {
     console.log(chalk.green('  🔑 Host provided an ephemeral SSH key for passwordless entry!'));
-    privateKeyPath = path.join(os.tmpdir(), `ipingyou_client_${Date.now()}`);
-    fs.writeFileSync(privateKeyPath, payload.privateKey, { mode: 0o600 });
-    addCleanupHook(() => {
-      try { fs.unlinkSync(privateKeyPath); } catch {}
-    });
+    try {
+      privateKeyPath = await writeEphemeralPrivateKey(payload.privateKey);
+      addCleanupHook(() => {
+        try { fs.unlinkSync(privateKeyPath); } catch {}
+      });
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠️  Could not use ephemeral SSH key: ${err.message}`));
+      console.log(chalk.dim('     Falling back to standard OS password.'));
+      privateKeyPath = null;
+    }
   }
 
   // Ask to save alias if we entered manually

package/src/modes/host.js

@@ -146,20 +146,27 @@ async function ensureTmuxInstalled() {
 
 // ─── Ephemeral SSH Key Management ────────────────────────────
 async function generateEphemeralKey() {
-  const tmpDir = os.tmpdir();
+  const tmpDir = os.tmpdir() || process.env.TMPDIR || process.env.TEMP || process.env.TMP;
+  if (!tmpDir) {
+    throw new Error('Could not resolve a temporary directory for SSH key generation');
+  }
   const keyPath = path.join(tmpDir, `ipingyou_${Date.now()}`);
   
   await execa('ssh-keygen', ['-t', 'ed25519', '-C', 'ipingyou-ephemeral', '-f', keyPath, '-N', '']);
   
-  const privKey = (await fs.promises.readFile(keyPath, 'utf8')).trim();
+  const privKey = await fs.promises.readFile(keyPath, 'utf8');
   const pubKey = (await fs.promises.readFile(`${keyPath}.pub`, 'utf8')).trim();
   
   return { keyPath, privKey, pubKey };
 }
 
 async function injectPublicKey(pubKey) {
-  const osInfo = detectOS();
-  const sshDir = path.join(osInfo.homedir, '.ssh');
+  const homedir = os.homedir();
+  if (!homedir) {
+    throw new Error('Could not resolve the current user home directory for authorized_keys');
+  }
+
+  const sshDir = path.join(homedir, '.ssh');
   
   if (!fs.existsSync(sshDir)) {
     await fs.promises.mkdir(sshDir, { mode: 0o700, recursive: true });
@@ -537,7 +544,7 @@ export async function startHostMode() {
       });
       console.log(chalk.green('  ✓ Ephemeral key injected. Client will connect without system password!'));
     } catch (err) {
-      console.log(chalk.yellow(`  ⚠️  Could not generate ephemeral key: ${err.message}`));
+      console.log(chalk.yellow(`  ⚠️  Could not prepare ephemeral SSH key: ${err.message}`));
       console.log(chalk.dim('     Client will need to use standard OS password.'));
     }
   } else {