@miraj181/ipingyou 2.0.13 → 2.1.0

package/src/lib/broker.js

@@ -2,16 +2,45 @@ import chalk from 'chalk';
 import os from 'node:os';
 import { decrypt, encrypt } from './crypto.js';
 import { createSpinner, cryptoSpinner, networkSpinner } from './animations.js';
+import { logSessionEvent } from './session-log.js';
+
+async function fetchWithLog(action, endpoint, options = {}) {
+  const method = options.method || 'GET';
+  const startedAt = Date.now();
+  logSessionEvent('broker_request', { action, method, endpoint });
+  try {
+    const res = await fetch(endpoint, options);
+    logSessionEvent('broker_response', {
+      action,
+      method,
+      endpoint,
+      status: res.status,
+      ok: res.ok,
+      durationMs: Date.now() - startedAt,
+    });
+    return res;
+  } catch (err) {
+    logSessionEvent('broker_error', {
+      action,
+      method,
+      endpoint,
+      error: err.message,
+      durationMs: Date.now() - startedAt,
+    }, 'error');
+    throw err;
+  }
+}
 
 export async function pingBroker(url) {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), 3000);
   try {
-    const controller = new AbortController();
-    const id = setTimeout(() => controller.abort(), 3000);
-    const res = await fetch(`${url}/health`, { signal: controller.signal });
-    clearTimeout(id);
+    const res = await fetchWithLog('health', `${url}/health`, { signal: controller.signal });
     return res.ok;
   } catch {
     return false;
+  } finally {
+    clearTimeout(id);
   }
 }
 
@@ -25,7 +54,7 @@ export async function registerWithBroker(brokerUrl, uid, tunnelUrl, password, se
 
     spinner.text = 'Registering with broker...';
 
-    const res = await fetch(`${brokerUrl}/register`, {
+    const res = await fetchWithLog('register', `${brokerUrl}/register`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -33,43 +62,134 @@ export async function registerWithBroker(brokerUrl, uid, tunnelUrl, password, se
         iv: encrypted.iv,
         ciphertext: encrypted.ciphertext,
         salt: encrypted.salt,
+        approvalRequired: Boolean(serviceConfig.approvalRequired),
+        oneTime: Boolean(serviceConfig.oneTimeSharePath),
       }),
     });
 
     if (!res.ok) {
       const data = await res.json().catch(() => ({}));
+      logSessionEvent('broker_register_failed', { uid, status: res.status, error: data.error || 'unknown' }, 'error');
       throw new Error(data.error || `HTTP ${res.status}`);
     }
 
+    const result = await res.json();
     spinner.succeed(`Registered with broker ${chalk.dim(`(${brokerUrl})`)} ${chalk.green('[E2E encrypted]')}`);
-    return true;
+    logSessionEvent('broker_registered', { uid, broker: brokerUrl });
+    // Return the host authentication token — needed for all host-only broker operations
+    return { success: true, hostToken: result.hostToken || null };
   } catch (err) {
     spinner.fail(`Broker registration failed: ${err.message}`);
     console.error(chalk.red(`  ❌ Error: ${err.message}`));
+    logSessionEvent('broker_register_error', { uid, broker: brokerUrl, error: err.message }, 'error');
     console.log(chalk.yellow('  ⚠️  Remote clients won\'t be able to find you without the broker.'));
     console.log(chalk.dim('     Share the tunnel URL directly if needed.'));
-    return false;
+    return { success: false, hostToken: null };
   }
 }
 
-export async function resolveUID(brokerUrl, uid, password, silent = false) {
+export async function requestHostApproval(brokerUrl, uid, password, details) {
+  const encrypted = encrypt(JSON.stringify(details), password);
+  const res = await fetchWithLog('approval_request', `${brokerUrl}/approval-request/${uid}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(encrypted),
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    logSessionEvent('broker_approval_request_failed', { uid, status: res.status, error: data.error || 'unknown' }, 'error');
+    throw new Error(data.error || `HTTP ${res.status}`);
+  }
+  return res.json();
+}
+
+export async function waitForApproval(brokerUrl, uid, requestId, timeoutMs = 300000) {
+  const startedAt = Date.now();
+  logSessionEvent('approval_wait_started', { uid, requestId, timeoutMs });
+  while (Date.now() - startedAt < timeoutMs) {
+    const res = await fetchWithLog('approval_status', `${brokerUrl}/approval-status/${uid}/${requestId}`);
+    if (res.ok) {
+      const data = await res.json();
+      if (data.status === 'approved') {
+        logSessionEvent('approval_granted', { uid, requestId });
+        return true;
+      }
+      if (data.status === 'denied') {
+        logSessionEvent('approval_denied', { uid, requestId });
+        return false;
+      }
+    }
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+  logSessionEvent('approval_timeout', { uid, requestId, timeoutMs }, 'warn');
+  throw new Error('Timed out waiting for host approval');
+}
+
+export async function fetchApprovalRequests(brokerUrl, uid, hostToken) {
+  const res = await fetchWithLog('approval_requests', `${brokerUrl}/approval-requests/${uid}`, {
+    headers: hostToken ? { 'x-host-token': hostToken } : {},
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    logSessionEvent('broker_approval_fetch_failed', { uid, status: res.status, error: data.error || 'unknown' }, 'error');
+    throw new Error(data.error || `HTTP ${res.status}`);
+  }
+  return res.json();
+}
+
+export async function decideApprovalRequest(brokerUrl, uid, requestId, decision, hostToken) {
+  const res = await fetchWithLog('approval_decision', `${brokerUrl}/approval-requests/${uid}/${requestId}/${decision}`, {
+    method: 'POST',
+    headers: hostToken ? { 'x-host-token': hostToken } : {},
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    logSessionEvent('broker_approval_decision_failed', { uid, requestId, decision, status: res.status, error: data.error || 'unknown' }, 'error');
+    throw new Error(data.error || `HTTP ${res.status}`);
+  }
+  logSessionEvent('approval_decision_sent', { uid, requestId, decision });
+  return res.json();
+}
+
+export async function revokeUID(brokerUrl, uid, hostToken) {
+  try {
+    await fetchWithLog('revoke', `${brokerUrl}/revoke/${uid}`, {
+      method: 'DELETE',
+      headers: hostToken ? { 'x-host-token': hostToken } : {},
+    });
+  } catch (err) {
+    logSessionEvent('broker_revoke_failed', { uid, broker: brokerUrl, error: err.message }, 'warn');
+  }
+}
+
+export async function resolveUID(brokerUrl, uid, password, silent = false, requestId = null) {
   const spinner = !silent ? createSpinner(`Resolving UID ${chalk.cyan(uid)}...`, networkSpinner).start() : null;
 
   try {
-    const res = await fetch(`${brokerUrl}/resolve/${uid}`);
+    const suffix = requestId ? `?requestId=${encodeURIComponent(requestId)}` : '';
+    const res = await fetchWithLog('resolve', `${brokerUrl}/resolve/${uid}${suffix}`);
 
     if (res.status === 404) {
       if (spinner) spinner.fail('UID not found — the host may not be online or the session expired');
       else console.error(chalk.red('  ❌ UID not found or expired.'));
+      logSessionEvent('broker_resolve_missing', { uid, status: 404 }, 'warn');
       return null;
     }
     if (res.status === 410) {
       if (spinner) spinner.fail('UID has expired — ask the host for a new session');
       else console.error(chalk.red('  ❌ UID expired.'));
+      logSessionEvent('broker_resolve_expired', { uid, status: 410 }, 'warn');
       return null;
     }
+    if (res.status === 423) {
+      if (spinner) spinner.info('Host approval is required — submitting access request...');
+      else console.log(chalk.yellow('  ⏳ Host approval required.'));
+      logSessionEvent('broker_resolve_needs_approval', { uid, status: 423 }, 'warn');
+      return { needsApproval: true };
+    }
     if (!res.ok) {
       const data = await res.json().catch(() => ({}));
+      logSessionEvent('broker_resolve_failed', { uid, status: res.status, error: data.error || 'unknown' }, 'error');
       throw new Error(data.error || `HTTP ${res.status}`);
     }
 
@@ -77,6 +197,7 @@ export async function resolveUID(brokerUrl, uid, password, silent = false) {
 
     if (!data.iv || !data.ciphertext || !data.salt) {
       if (spinner) spinner.fail('Broker returned invalid response — missing encrypted data or salt');
+      logSessionEvent('broker_resolve_invalid', { uid }, 'error');
       return null;
     }
 
@@ -89,6 +210,7 @@ export async function resolveUID(brokerUrl, uid, password, silent = false) {
     } catch {
       if (spinner) spinner.fail('Decryption failed — incorrect password or corrupted data');
       if (!spinner) console.error(chalk.red('  ❌ Error: Could not decrypt tunnel data. Incorrect password.'));
+      logSessionEvent('broker_decrypt_failed', { uid }, 'warn');
       return null;
     }
 
@@ -104,18 +226,21 @@ export async function resolveUID(brokerUrl, uid, password, silent = false) {
 
     if (!payloadConfig.url.startsWith('https://')) {
       if (spinner) spinner.fail('Decrypted data is not a valid tunnel URL (incorrect password)');
+      logSessionEvent('broker_decrypt_invalid_url', { uid }, 'warn');
       return null;
     }
 
     if (spinner) spinner.succeed(`Resolved: ${chalk.dim(payloadConfig.url)} ${chalk.green('[decrypted locally]')}`);
+    logSessionEvent('broker_resolve_success', { uid, type: payloadConfig.type || 'ssh' });
     return payloadConfig;
   } catch (err) {
     if (spinner) spinner.fail(`Broker lookup failed: ${err.message}`);
+    logSessionEvent('broker_resolve_error', { uid, error: err.message }, 'error');
     return null;
   }
 }
 
-export async function pushTelemetry(brokerUrl, uid, password, username) {
+export async function pushTelemetry(brokerUrl, uid, password, username, action = 'connected') {
   try {
     let publicIp = 'Unknown';
     try {
@@ -128,17 +253,18 @@ export async function pushTelemetry(brokerUrl, uid, password, username) {
       os: `${os.type()} ${os.release()} (${os.arch()})`,
       cpu: os.cpus()[0]?.model || 'Unknown CPU',
       ram: `${Math.round(os.totalmem() / 1024 / 1024 / 1024)} GB`,
+      action,
       time: new Date().toLocaleTimeString()
     };
 
     const { iv, ciphertext, salt } = encrypt(JSON.stringify(telemetry), password);
 
-    await fetch(`${brokerUrl}/client-info/${uid}`, {
+    await fetchWithLog('telemetry', `${brokerUrl}/client-info/${uid}`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ iv, ciphertext, salt }),
     });
-  } catch {
-    // Telemetry is optional.
+  } catch (err) {
+    logSessionEvent('telemetry_failed', { uid, error: err.message }, 'warn');
   }
 }

package/src/lib/cleanup.js

@@ -24,6 +24,9 @@ let _revokeUID = null;
 /** @type {string|null} — Broker URL for revocation */
 let _brokerUrl = null;
 
+/** @type {(() => string|null)|null} — Getter for host auth token */
+let _getHostToken = null;
+
 /** @type {Array<() => Promise<void>|void>} — Custom cleanup hooks */
 const _cleanupHooks = [];
 let cleanedUp = false;
@@ -56,10 +59,12 @@ export function untrackPID(pid) {
  * Set UID + broker URL for automatic revocation on shutdown.
  * @param {string} uid
  * @param {string} brokerUrl
+ * @param {() => string|null} [getHostToken]
  */
-export function setRevokeOnExit(uid, brokerUrl) {
+export function setRevokeOnExit(uid, brokerUrl, getHostToken = null) {
   _revokeUID = uid;
   _brokerUrl = brokerUrl;
+  _getHostToken = getHostToken;
 }
 
 /**
@@ -110,7 +115,14 @@ export async function cleanupAll() {
   // Revoke UID from broker
   if (_revokeUID && _brokerUrl) {
     try {
-      const res = await fetch(`${_brokerUrl}/revoke/${_revokeUID}`, { method: 'DELETE' });
+      const headers = {};
+      const token = _getHostToken ? _getHostToken() : null;
+      if (token) headers['x-host-token'] = token;
+      
+      const res = await fetch(`${_brokerUrl}/revoke/${_revokeUID}`, { 
+        method: 'DELETE',
+        headers 
+      });
       if (res.ok) {
         console.log(chalk.dim(`     Revoked UID ${_revokeUID} from broker`));
       }
@@ -164,10 +176,6 @@ export function installShutdownHandlers() {
  * Get count of tracked PIDs.
  * @returns {number}
  */
-export function getTrackedCount() {
-  return trackedPIDs.size;
-}
-
 /**
  * Execute Panic Mode (Self-Destruct)
  * Wipes all configs, keys, and forcefully kills associated processes.

package/src/lib/config.js

@@ -7,10 +7,14 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
 function ensureConfig() {
   if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  } else {
+    try { fs.chmodSync(CONFIG_DIR, 0o700); } catch { }
   }
   if (!fs.existsSync(CONFIG_FILE)) {
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ aliases: {}, settings: {} }, null, 2));
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ aliases: {}, settings: {} }, null, 2), { mode: 0o600 });
+  } else {
+    try { fs.chmodSync(CONFIG_FILE, 0o600); } catch { }
   }
 }
 
@@ -26,7 +30,8 @@ export function getConfig() {
 export function saveConfig(config) {
   try {
     ensureConfig();
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+    try { fs.chmodSync(CONFIG_FILE, 0o600); } catch { }
   } catch (err) {
     throw new Error(`Could not save config: ${err.message}`);
   }

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);
@@ -136,7 +146,7 @@ async function listRemoteDirectory(username, hostname, privateKeyPath, remoteDir
   return { pwd, entries };
 }
 
-export async function promptRemotePath(username, hostname, privateKeyPath, purpose) {
+export async function promptRemotePath(username, hostname, privateKeyPath, purpose, startDir = '~') {
   const browseLabel = purpose === 'source'
     ? 'Browse host files interactively'
     : 'Browse host folders interactively';
@@ -169,13 +179,25 @@ export async function promptRemotePath(username, hostname, privateKeyPath, purpo
     return remotePath.trim();
   }
 
-  let currentDir = '~';
+  let currentDir = startDir || '~';
   while (true) {
     let listing;
     try {
       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/platform.js

@@ -410,37 +410,6 @@ async function installOpenSSH(osInfo) {
 
 // ─── Main Dependency Check ───────────────────────────────────
 
-/**
- * Install a dependency on the current platform.
- * @param {string} pkg — package name (e.g. 'openssh-server', 'cloudflared')
- * @param {'debian'|'arch'|'fedora'|'mac'|'windows'} distro
- */
-export async function installDependency(pkg, distro) {
-  const spinner = ora(`Installing ${chalk.cyan(pkg)}...`).start();
-
-  const commands = {
-    debian: `sudo apt-get install -y ${pkg}`,
-    arch: `sudo pacman -S --noconfirm ${pkg}`,
-    fedora: `sudo dnf install -y ${pkg}`,
-    mac: `brew install ${pkg}`,
-  };
-
-  const cmd = commands[distro];
-  if (!cmd) {
-    spinner.fail(`No auto-install command for ${distro}. Please install ${pkg} manually.`);
-    return false;
-  }
-
-  try {
-    await execaCommand(cmd, { stdio: 'inherit' });
-    spinner.succeed(`${chalk.green(pkg)} installed successfully`);
-    return true;
-  } catch (err) {
-    spinner.fail(`Failed to install ${pkg}: ${err.message}`);
-    return false;
-  }
-}
-
 /**
  * Run full dependency check with auto-bootstrap.
  *

package/src/lib/session-log.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { redactSensitive } from './ai/safety.js';
+
+const LOG_DIR = path.join(os.homedir(), '.ipingyou', 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'session-events.jsonl');
+const SESSION_LOG_DIR = path.join(os.tmpdir(), 'ipingyou-session-logs');
+
+let sessionLogPath = null;
+let sessionLogDisabled = false;
+let cleanupRegistered = false;
+
+function sanitize(value) {
+  if (typeof value === 'string') return redactSensitive(value);
+  if (Array.isArray(value)) return value.map(sanitize);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .filter(([key]) => !/(password|privateKey|tunnelUrl|url|secret|token|apiKey)/i.test(key))
+        .map(([key, item]) => [key, sanitize(item)])
+    );
+  }
+  return value;
+}
+
+export function initSessionLog(scope = 'session') {
+  if (sessionLogPath || sessionLogDisabled) return sessionLogPath;
+  try {
+    fs.mkdirSync(SESSION_LOG_DIR, { recursive: true, mode: 0o700 });
+    sessionLogPath = path.join(
+      SESSION_LOG_DIR,
+      `ipingyou-${scope}-${Date.now()}-${process.pid}.log`
+    );
+    fs.writeFileSync(sessionLogPath, '', { mode: 0o600 });
+    if (!cleanupRegistered) {
+      process.on('exit', () => cleanupSessionLog());
+      cleanupRegistered = true;
+    }
+    logSessionEvent('session_start', { scope, pid: process.pid, node: process.version });
+    return sessionLogPath;
+  } catch (err) {
+    sessionLogDisabled = true;
+    console.error(`Session log setup failed: ${err.message}`);
+    return null;
+  }
+}
+
+export function getSessionLogPath() {
+  return sessionLogPath;
+}
+
+export function logSessionEvent(type, details = {}, level = 'info') {
+  if (!sessionLogPath || sessionLogDisabled) return;
+  const entry = {
+    time: new Date().toISOString(),
+    level,
+    type,
+    details: sanitize(details),
+  };
+  try {
+    fs.appendFileSync(sessionLogPath, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+  } catch (err) {
+    sessionLogDisabled = true;
+    console.error(`Session log write failed: ${err.message}`);
+  }
+}
+
+export function cleanupSessionLog() {
+  if (!sessionLogPath) return;
+  const target = sessionLogPath;
+  sessionLogPath = null;
+  try {
+    if (fs.existsSync(target)) fs.unlinkSync(target);
+  } catch (err) {
+    console.error(`Session log cleanup failed: ${err.message}`);
+  }
+}
+
+export function recordEvent(type, details = {}) {
+  try {
+    fs.mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
+    const event = {
+      time: new Date().toISOString(),
+      type,
+      details: sanitize(details),
+    };
+    fs.appendFileSync(LOG_FILE, `${JSON.stringify(event)}\n`, { mode: 0o600 });
+    logSessionEvent(type, details);
+  } catch {
+    // Session recording is best-effort.
+  }
+}