@miraj181/ipingyou 2.1.19 → 2.1.23

package/src/modes/ai.js

@@ -8,16 +8,16 @@ import inquirer from 'inquirer';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { getAlias } from '../lib/config.js';
-import { resolveUID } from '../lib/broker.js';
-import { buildSshArgs, extractHostname, quoteRemoteShell } from '../lib/ssh.js';
-import { addCleanupHook, cleanupAll } from '../lib/cleanup.js';
+import { getAlias } from '../lib/mod/config.js';
+import { resolveUID } from '../lib/client/broker.js';
+import { buildSshArgs, extractHostname, quoteRemoteShell } from '../lib/services/ssh.js';
+import { addCleanupHook, cleanupAll, trackPID, untrackPID } from '../lib/mod/cleanup.js';
 import { startHostMode } from './host.js';
 import { startClientMode } from './client.js';
 import { performSCPNonInteractive } from './client.js';
 import { DEFAULT_AI_MODEL, createGroqChatCompletion, getGroqApiKey, getRateLimitWarnings, listGroqModels, estimateTokensForMessages } from '../lib/ai/groq.js';
 import { assertSafeReadablePath, classifyCommand, redactSensitive, sanitizeUserTask, truncateForModel } from '../lib/ai/safety.js';
-import { recordEvent } from '../lib/session-log.js';
+import { recordEvent } from '../lib/mod/session-log.js';
 
 let BROKER_URL = process.env.BROKER_URL || 'https://ipingyou.onrender.com';
 
@@ -223,11 +223,14 @@ async function runLocalCommand(command) {
   if (args.length === 0) {
     return { exitCode: 1, stdout: '', stderr: 'Empty or unsafe command after parsing' };
   }
-  const result = await execa(args[0], args.slice(1), {
+  const child = execa(args[0], args.slice(1), {
     reject: false,
     timeout: 30000,
     maxBuffer: 1024 * 1024,
   });
+  trackPID(child.pid);
+  const result = await child;
+  untrackPID(child.pid);
 
   return {
     exitCode: result.exitCode,
@@ -290,11 +293,14 @@ export function parseLocalCommand(command) {
 async function runRemoteCommand(context, command) {
   const sshArgs = buildSshArgs(context.hostname, context.privateKeyPath);
   sshArgs.push(`${context.username}@${context.hostname}`, command);
-  const result = await execa('ssh', sshArgs, {
+  const child = execa('ssh', sshArgs, {
     reject: false,
     timeout: 30000,
     maxBuffer: 1024 * 1024,
   });
+  trackPID(child.pid);
+  const result = await child;
+  untrackPID(child.pid);
 
   return {
     exitCode: result.exitCode,
@@ -650,7 +656,7 @@ async function tryAITransfer(task, context) {
   if (context && context.scope === 'remote' && context.hostname && context.username) {
     console.log(chalk.dim(`  Using active remote session: ${context.username}@${context.hostname}`));
 
-    const { buildProxyCommandOption, getSshControlOptions, formatScpRemotePath } = await import('../lib/ssh.js');
+    const { buildProxyCommandOption, getSshControlOptions, formatScpRemotePath } = await import('../lib/services/ssh.js');
     const scpArgs = [
       '-r',
       ...buildProxyCommandOption(context.hostname),
@@ -670,7 +676,10 @@ async function tryAITransfer(task, context) {
     }
 
     try {
-      const result = await execa('scp', scpArgs, { stdio: 'inherit', reject: false });
+      const child = execa('scp', scpArgs, { stdio: 'inherit', reject: false });
+      trackPID(child.pid);
+      const result = await child;
+      untrackPID(child.pid);
       if (result.exitCode === 0) {
         console.log(chalk.green('  ✅ Transfer completed via active remote session.'));
         recordEvent('ai_transfer_success', { direction, localPath, remotePath, hostname: context.hostname, reusedContext: true });

package/src/modes/client.js

@@ -18,20 +18,73 @@ import inquirer from 'inquirer';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { cleanupAll, trackPID, untrackPID, addCleanupHook } from '../lib/cleanup.js';
-import { createSpinner, sshSpinner, networkSpinner, fileTransferSpinner, showConnectionTrace, simulateTransferProgress } from '../lib/animations.js';
-import { getConfig, saveAlias } from '../lib/config.js';
-import { pushTelemetry, requestHostApproval, resolveUID, revokeUID, waitForApproval } from '../lib/broker.js';
-import { calculateChecksum } from '../lib/checksum.js';
-import { promptLocalPath, promptRemotePath } from '../lib/path-browser.js';
-import { buildProxyCommandOption, buildSshArgs, extractHostname, formatScpRemotePath, getKnownHostsOptions, getSshControlOptions, quoteRemoteShell } from '../lib/ssh.js';
-import { buildTmuxSessionName, TMUX_SOCKET_PATH } from '../lib/tmux.js';
-import { openUrl } from '../lib/open-url.js';
-import { secureSensitiveUrl } from '../lib/secure-print.js';
-import { cleanupSessionLog, initSessionLog, logSessionEvent, recordEvent } from '../lib/session-log.js';
+import { cleanupAll, trackPID, untrackPID, addCleanupHook } from '../lib/mod/cleanup.js';
+import { createSpinner, sshSpinner, networkSpinner, fileTransferSpinner, showConnectionTrace, simulateTransferProgress } from '../lib/mod/animations.js';
+import { getConfig, saveAlias } from '../lib/mod/config.js';
+import { pushTelemetry, requestHostApproval, resolveUID, revokeUID, waitForApproval } from '../lib/client/broker.js';
+import { calculateChecksum } from '../lib/mod/checksum.js';
+import { promptLocalPath, promptRemotePath } from '../lib/client/path-browser.js';
+import { buildProxyCommandOption, buildSshArgs, extractHostname, formatScpRemotePath, getKnownHostsOptions, getSshControlOptions, quoteRemoteShell } from '../lib/services/ssh.js';
+import { openUrl } from '../lib/mod/open-url.js';
+import { secureSensitiveUrl } from '../lib/mod/secure-print.js';
+import { cleanupSessionLog, initSessionLog, logSessionEvent, recordEvent } from '../lib/mod/session-log.js';
 
 let BROKER_URL = process.env.BROKER_URL || 'https://ipingyou.onrender.com';
 
+function startLiveLogSync(username, hostname, privateKeyPath, remoteDropPath, localLogPath, persistKnownHosts = true) {
+  if (!remoteDropPath || !localLogPath) return;
+
+  let lastSize = -1;
+  let lastMtime = 0;
+  let isSyncing = false;
+  let consecutiveFailures = 0;
+  let warnedOnce = false;
+  const interval = setInterval(async () => {
+    if (isSyncing) return;
+    isSyncing = true;
+    try {
+      if (!fs.existsSync(localLogPath)) return;
+      const stats = fs.statSync(localLogPath);
+      if (stats.size === lastSize && stats.mtimeMs === lastMtime) return;
+
+      const scpArgs = [
+        '-O',
+        ...buildProxyCommandOption(hostname),
+        ...getKnownHostsOptions(persistKnownHosts),
+        '-o', 'IdentitiesOnly=yes',
+        ...getSshControlOptions(hostname)
+      ];
+      if (privateKeyPath) {
+        scpArgs.push('-i', privateKeyPath, '-o', 'IdentityAgent=none');
+      }
+
+      const clientName = `${os.userInfo().username}-${os.hostname()}`;
+      const remoteFilePath = `${remoteDropPath}/client-${clientName}.log`;
+
+      scpArgs.push(localLogPath, `${username}@${hostname}:${formatScpRemotePath(remoteFilePath)}`);
+
+      const result = await execa('scp', scpArgs, { reject: false });
+      if (result.exitCode === 0) {
+        lastSize = stats.size;
+        lastMtime = stats.mtimeMs;
+        consecutiveFailures = 0;
+      } else {
+        consecutiveFailures++;
+        if (consecutiveFailures >= 5 && !warnedOnce) {
+          warnedOnce = true;
+          logSessionEvent('client_log_sync_failing', { failures: consecutiveFailures, stderr: (result.stderr || '').slice(0, 200) }, 'warn');
+        }
+      }
+    } catch {
+      consecutiveFailures++;
+    } finally {
+      isSyncing = false;
+    }
+  }, 3000);
+
+  addCleanupHook(() => clearInterval(interval));
+}
+
 async function promptUsername() {
   const { username } = await inquirer.prompt([
     {
@@ -94,18 +147,11 @@ async function connectSSH(username, hostname, privateKeyPath, persistKnownHosts
 
     const sshArgs = buildSshArgs(hostname, privateKeyPath, [
       '-o', 'ServerAliveInterval=30',
-      '-o', 'ServerAliveCountMax=3'
+      '-o', 'ServerAliveCountMax=3',
+      '-t'
     ], { persistKnownHosts });
 
     sshArgs.push(`${username}@${hostname}`);
-    const tmuxSession = buildTmuxSessionName(username);
-    const quotedSocket = quoteRemoteShell(TMUX_SOCKET_PATH);
-    const quotedSession = quoteRemoteShell(tmuxSession);
-    const tmuxSocketCmdStr = `tmux -S ${quotedSocket}`;
-    const tmuxPrepare = `${tmuxSocketCmdStr} has-session -t ${quotedSession} 2>/dev/null || ${tmuxSocketCmdStr} new-session -d -s ${quotedSession}`;
-    const tmuxAttach = `${tmuxSocketCmdStr} attach -t ${quotedSession}`;
-    const tmuxCommand = `if command -v tmux >/dev/null 2>&1; then (${tmuxPrepare} && ${tmuxAttach}) || exec $SHELL -l; else exec $SHELL -l; fi`;
-    sshArgs.push('-t', tmuxCommand);
 
     const child = execa('ssh', sshArgs, {
       stdio: 'inherit',
@@ -199,6 +245,7 @@ async function performSCP(username, hostname, direction, privateKeyPath, sharedD
   // Construct SCP args
   const scpArgs = [
     '-r', // recursive just in case
+    '-O', // Force legacy SCP protocol so that shell quoting in formatScpRemotePath works correctly
     ...buildProxyCommandOption(hostname),
     ...getKnownHostsOptions(persistKnownHosts),
     '-o', 'IdentitiesOnly=yes',
@@ -293,6 +340,7 @@ async function downloadSpecificRemotePath(username, hostname, privateKeyPath, re
   await showConnectionTrace('Local', 'Remote SCP');
   const scpArgs = [
     '-r',
+    '-O', // Force legacy SCP protocol
     ...buildProxyCommandOption(hostname),
     ...getKnownHostsOptions(persistKnownHosts),
     '-o', 'IdentitiesOnly=yes',
@@ -300,7 +348,10 @@ async function downloadSpecificRemotePath(username, hostname, privateKeyPath, re
   ];
   if (privateKeyPath) scpArgs.push('-i', privateKeyPath, '-o', 'IdentityAgent=none');
   scpArgs.push(`${username}@${hostname}:${formatScpRemotePath(remotePath)}`, localPath);
-  const result = await execa('scp', scpArgs, { stdio: 'inherit', reject: false });
+  const child = execa('scp', scpArgs, { stdio: 'inherit', reject: false });
+  trackPID(child.pid);
+  const result = await child;
+  untrackPID(child.pid);
   return result.exitCode === 0;
 }
 
@@ -435,12 +486,27 @@ export async function startClientMode(options = {}) {
     console.log(chalk.dim('  The host has enabled approval gating. Submitting your access request...'));
 
     try {
+      let localIp = '127.0.0.1';
+      try {
+        const interfaces = os.networkInterfaces();
+        for (const devName in interfaces) {
+          const iface = interfaces[devName];
+          for (const alias of iface) {
+            if (alias.family === 'IPv4' && !alias.internal) {
+              localIp = alias.address;
+              break;
+            }
+          }
+        }
+      } catch {}
+
       const approvalDetails = {
         username: os.userInfo().username,
         hostname: os.hostname(),
         os: `${os.type()} ${os.release()} (${os.arch()})`,
         intent: 'connect',
         time: new Date().toISOString(),
+        localIp,
       };
 
       const { requestId, status: reqStatus, approvalRequired } = await requestHostApproval(
@@ -457,9 +523,9 @@ export async function startClientMode(options = {}) {
         console.log(chalk.dim('     This may take a few minutes. Press Ctrl+C to cancel.'));
         console.log('');
 
-        const approved = await waitForApproval(BROKER_URL, targetUid, requestId, 300000);
+        const approvalResult = await waitForApproval(BROKER_URL, targetUid, requestId, 300000);
 
-        if (approved) {
+        if (approvalResult && approvalResult.approved) {
           console.log(chalk.green('  ✅ Host approved your access request!'));
           logSessionEvent('client_approval_granted', { uid: targetUid, requestId });
           payload = await resolveUID(BROKER_URL, targetUid, targetPassword, false, requestId);
@@ -560,6 +626,15 @@ export async function startClientMode(options = {}) {
     }
   }
 
+  // Push telemetry immediately so host can see the client in "See detailed client telemetry"
+  // even before the user picks an action (SSH/SCP/etc.)
+  await pushTelemetry(BROKER_URL, targetUid, targetPassword, username, 'connected');
+
+  // Start background E2E client log sync if sharedDropPath is configured
+  if (payload.sharedDropPath && sessionLogPath) {
+    startLiveLogSync(username, hostname, privateKeyPath, payload.sharedDropPath, sessionLogPath, persistKnownHosts);
+  }
+
   // ─── One-Time File Share Auto-Download ────────────────────
   if (payload.oneTime && payload.oneTimeSharePath) {
     console.log('');
@@ -684,7 +759,7 @@ export async function performSCPNonInteractive(params = {}) {
   const privateKeyPath = payload.privateKey ? await writeEphemeralPrivateKey(payload.privateKey) : null;
 
   // Build scp args similar to performSCP
-  const scpArgs = ['-r', ...buildProxyCommandOption(hostname), ...getKnownHostsOptions(persistKnownHosts), '-o', 'IdentitiesOnly=yes', ...getSshControlOptions(hostname)];
+  const scpArgs = ['-r', '-O', ...buildProxyCommandOption(hostname), ...getKnownHostsOptions(persistKnownHosts), '-o', 'IdentitiesOnly=yes', ...getSshControlOptions(hostname)];
   if (privateKeyPath) scpArgs.push('-i', privateKeyPath, '-o', 'IdentityAgent=none');
 
   const remoteSpec = `${username}@${hostname}:${formatScpRemotePath(remotePath)}`;
@@ -695,7 +770,10 @@ export async function performSCPNonInteractive(params = {}) {
   }
 
   try {
-    const result = await execa('scp', scpArgs, { stdio: 'inherit', reject: false });
+    const child = execa('scp', scpArgs, { stdio: 'inherit', reject: false });
+    trackPID(child.pid);
+    const result = await child;
+    untrackPID(child.pid);
     if (result.exitCode === 0) {
       recordEvent('scp_transfer_success', { direction, localPath, remotePath, hostname, automated: true });
       return true;

package/src/modes/doctor.js

@@ -7,8 +7,8 @@ import chalk from 'chalk';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { commandExists, detectOS } from '../lib/platform.js';
-import { pingBroker } from '../lib/broker.js';
+import { commandExists, detectOS, isLinuxSSHActive, getCloudflaredPath } from '../lib/services/platform.js';
+import { pingBroker } from '../lib/client/broker.js';
 import { classifyCommand, redactSensitive } from '../lib/ai/safety.js';
 
 let BROKER_URL = process.env.BROKER_URL || 'https://ipingyou.onrender.com';
@@ -96,13 +96,12 @@ async function checkSshService() {
   }
 
   if (osInfo.isLinux) {
-    const ssh = await execa('systemctl', ['is-active', 'ssh'], { reject: false, timeout: 5000 });
-    const sshd = ssh.exitCode === 0 ? ssh : await execa('systemctl', ['is-active', 'sshd'], { reject: false, timeout: 5000 });
-    if (sshd.exitCode === 0) return { status: 'pass', detail: 'SSH service is active' };
+    const active = await isLinuxSSHActive();
+    if (active) return { status: 'pass', detail: 'SSH service is active' };
     return {
       status: 'warn',
       detail: 'SSH service is not reported active',
-      hint: 'Run `sudo systemctl start ssh` or `sudo systemctl start sshd` before hosting.',
+      hint: 'Run `sudo systemctl start ssh`, `sudo service ssh start` or equivalent before hosting.',
     };
   }
 
@@ -231,8 +230,8 @@ export async function startDoctorMode(options = {}) {
   await check('ssh client', () => commandVersion('ssh', ['-V']));
   await check('scp client', () => commandFound('scp'));
   await check('ssh-keygen', () => commandFound('ssh-keygen'));
-  await check('cloudflared', () => commandVersion('cloudflared', ['--version']));
-  await check('tmux', () => commandVersion('tmux', ['-V']));
+  const cfPath = await getCloudflaredPath();
+  await check('cloudflared', () => commandVersion(cfPath || 'cloudflared', ['--version']));
 
   console.log(chalk.bold('\n  Host readiness'));
   await check('SSH service', checkSshService);