groove-dev 0.27.86 → 0.27.88

package/node_modules/@groove-dev/cli/src/commands/connect.js

@@ -1,278 +1,189 @@
-// GROOVE CLI — connect command (SSH tunnel to remote daemon)
+// GROOVE CLI — connect command (SSH tunnel via daemon TunnelManager)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { execFileSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { resolve } from 'path';
-import { createConnection } from 'net';
+import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 
-const REMOTE_PORT = 31415;
-const DEFAULT_LOCAL_PORT = 31416;
-const MAX_PORT_ATTEMPTS = 10;
+const API = 'http://localhost:31415/api';
 
-// Allow user@host OR plain hostname (SSH config aliases like "groove-ai")
-const SSH_TARGET_PATTERN = /^([a-zA-Z0-9._-]+@)?[a-zA-Z0-9._-]+$/;
-
-function validateTarget(target) {
+function parseTarget(target) {
   if (!target || typeof target !== 'string') {
-    throw new Error('SSH target is required (e.g., user@host or ssh-config-alias)');
+    throw new Error('SSH target is required (e.g., user@host)');
   }
-  // Block injection characters
   if (/[;|&`$(){}[\]<>!#\n\r\\]/.test(target)) {
     throw new Error('Invalid characters in SSH target');
   }
-  if (!SSH_TARGET_PATTERN.test(target)) {
-    throw new Error('Invalid SSH target format. Expected: user@hostname or ssh-config-alias');
-  }
   if (target.length > 253) {
     throw new Error('SSH target too long');
   }
-}
-
-function grooveDir() {
-  const dir = resolve(process.cwd(), '.groove');
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-function pidFile() {
-  return resolve(grooveDir(), 'tunnel.pid');
-}
-
-function tunnelInfoFile() {
-  return resolve(grooveDir(), 'tunnel.json');
-}
-
-function isPortInUse(port) {
-  return new Promise((resolve) => {
-    const conn = createConnection({ host: '127.0.0.1', port });
-    conn.setTimeout(3000);
-    conn.on('connect', () => { conn.destroy(); resolve(true); });
-    conn.on('error', () => resolve(false));
-    conn.on('timeout', () => { conn.destroy(); resolve(false); });
-  });
-}
-
-async function findAvailablePort() {
-  for (let port = DEFAULT_LOCAL_PORT; port < DEFAULT_LOCAL_PORT + MAX_PORT_ATTEMPTS; port++) {
-    if (!(await isPortInUse(port))) return port;
-  }
-  throw new Error(`No available local port found (tried ${DEFAULT_LOCAL_PORT}-${DEFAULT_LOCAL_PORT + MAX_PORT_ATTEMPTS - 1})`);
-}
-
-function preflight(target, keyFile) {
-  // SSH in and check if daemon is listening on remote
-  // Use curl to health endpoint — works on both Linux and macOS
-  const args = [
-    ...(keyFile ? ['-i', keyFile] : []),
-    '-o', 'ConnectTimeout=10',
-    '-o', 'StrictHostKeyChecking=accept-new',
-    '-o', 'BatchMode=yes',
-    target,
-    `curl -sf http://localhost:${REMOTE_PORT}/api/health >/dev/null 2>&1 || echo __GROOVE_NOT_RUNNING__`,
-  ];
-
-  try {
-    const result = execFileSync('ssh', args, {
-      encoding: 'utf8',
-      timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    if (result.includes('__GROOVE_NOT_RUNNING__')) {
-      return { running: false };
-    }
-    return { running: true };
-  } catch (err) {
-    const stderr = err.stderr?.toString() || '';
-    if (stderr.includes('Permission denied')) {
-      throw new Error('SSH authentication failed. Check your key or credentials.');
-    }
-    if (stderr.includes('Connection refused') || stderr.includes('Connection timed out') || stderr.includes('No route to host')) {
-      throw new Error(`Cannot reach ${target}. Check the hostname and that SSH is running.`);
-    }
-    throw new Error(`SSH preflight failed: ${stderr.trim() || err.message}`);
+  const atIdx = target.indexOf('@');
+  if (atIdx === -1) {
+    return { user: null, host: target };
   }
+  return { user: target.slice(0, atIdx), host: target.slice(atIdx + 1) };
 }
 
-function isSshProcess(pid) {
-  // Verify the PID belongs to an SSH process (not a random reused PID)
+async function daemonRunning() {
   try {
-    const cmd = execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
-      encoding: 'utf8',
-      timeout: 3000,
-    }).trim();
-    return cmd.includes('ssh');
+    const res = await fetch(`${API}/health`, { signal: AbortSignal.timeout(3000) });
+    return res.ok;
   } catch {
     return false;
   }
 }
 
-function existingTunnel() {
-  const pf = pidFile();
-  if (!existsSync(pf)) return null;
-  const pid = parseInt(readFileSync(pf, 'utf8').trim(), 10);
-  if (isNaN(pid)) return null;
-  // Check if process is still alive AND is an SSH process
-  try {
-    process.kill(pid, 0);
-    if (!isSshProcess(pid)) {
-      // PID was reused by a different process — stale tunnel files
-      return null;
-    }
-    // Read tunnel info if available
-    const infoPath = tunnelInfoFile();
-    if (existsSync(infoPath)) {
-      const info = JSON.parse(readFileSync(infoPath, 'utf8'));
-      return { pid, ...info };
-    }
-    return { pid };
-  } catch {
-    return null;
-  }
-}
-
 function openBrowser(url) {
-  const platform = process.platform;
   try {
-    if (platform === 'darwin') {
+    if (process.platform === 'darwin') {
       execFileSync('open', [url], { stdio: 'ignore' });
-    } else if (platform === 'win32') {
+    } else if (process.platform === 'win32') {
       execFileSync('cmd', ['/c', 'start', '', url], { stdio: 'ignore' });
     } else {
       execFileSync('xdg-open', [url], { stdio: 'ignore' });
     }
   } catch {
-    // Browser open is best-effort
+    // best-effort
   }
 }
 
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
 export async function connect(target, options) {
   console.log('');
 
-  // Validate SSH target
+  let user, host;
   try {
-    validateTarget(target);
+    ({ user, host } = parseTarget(target));
   } catch (err) {
     console.log(chalk.red('  Error: ') + err.message);
     console.log('');
     return;
   }
 
-  // Check for existing tunnel
-  const existing = existingTunnel();
-  if (existing) {
-    console.log(chalk.yellow('  Tunnel already active') + ` (PID ${existing.pid})`);
-    if (existing.target) {
-      console.log(`  Target:  ${existing.target}`);
-    }
-    if (existing.localPort) {
-      console.log(`  GUI:     ${chalk.cyan(`http://localhost:${existing.localPort}`)}`);
-    }
-    console.log('');
-    console.log(`  Run ${chalk.bold('groove disconnect')} first to close it.`);
+  if (!(await daemonRunning())) {
+    console.log(chalk.red('  Local daemon is not running.'));
+    console.log(`  Run ${chalk.bold('groove start')} first.`);
     console.log('');
     return;
   }
 
-  // Preflight — check daemon is running on remote
-  console.log(chalk.dim('  Checking remote daemon...'));
+  // Check for existing saved remote matching this host+user
+  let tunnelId;
+  let tunnels;
   try {
-    const check = preflight(target, options.identity);
-    if (!check.running) {
-      console.log(chalk.red('  Daemon not running on remote.'));
-      console.log(`  SSH into ${chalk.bold(target)} and run ${chalk.bold('groove start')} first.`);
-      console.log('');
-      return;
-    }
+    const res = await fetch(`${API}/tunnels`);
+    tunnels = await res.json();
   } catch (err) {
-    console.log(chalk.red('  ' + err.message));
+    console.log(chalk.red('  Failed to query tunnels: ') + err.message);
     console.log('');
     return;
   }
 
-  console.log(chalk.dim('  Remote daemon is running.'));
+  const match = tunnels.find(t =>
+    t.host === host && (user ? t.user === user : true)
+  );
 
-  // Find available local port
-  let localPort;
-  try {
-    localPort = await findAvailablePort();
-  } catch (err) {
-    console.log(chalk.red('  ' + err.message));
-    console.log('');
-    return;
-  }
-
-  if (localPort !== DEFAULT_LOCAL_PORT) {
-    console.log(chalk.yellow(`  Port ${DEFAULT_LOCAL_PORT} in use, using ${localPort} instead.`));
+  if (match) {
+    if (match.active) {
+      console.log(chalk.yellow('  Tunnel already active') + ` to ${match.name}`);
+      if (match.localPort) {
+        console.log(`  GUI:     ${chalk.cyan(`http://localhost:${match.localPort}`)}`);
+      }
+      console.log('');
+      console.log(`  Run ${chalk.bold('groove disconnect')} first to close it.`);
+      console.log('');
+      return;
+    }
+    tunnelId = match.id;
+    console.log(chalk.dim(`  Using saved remote: ${match.name}`));
+  }
+
+  // Save new tunnel config if none found
+  if (!tunnelId) {
+    try {
+      const body = {
+        name: target,
+        host,
+        user: user || process.env.USER || 'root',
+        port: options.port ? parseInt(options.port, 10) : 22,
+        sshKeyPath: options.identity || null,
+        autoConnect: options.autoConnect || false,
+        projectDir: options.projectDir || null,
+      };
+      const res = await fetch(`${API}/tunnels`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || 'Failed to save tunnel');
+      tunnelId = data.id;
+      console.log(chalk.dim(`  Saved remote: ${data.name} (${data.id})`));
+    } catch (err) {
+      console.log(chalk.red('  ' + err.message));
+      console.log('');
+      return;
+    }
   }
 
-  // Spawn SSH tunnel
-  const sshArgs = [
-    '-N',                                            // No remote command
-    '-L', `127.0.0.1:${localPort}:localhost:${REMOTE_PORT}`,  // Local bind to 127.0.0.1 only
-    '-o', 'ServerAliveInterval=30',                  // Keepalive every 30s
-    '-o', 'ServerAliveCountMax=3',                   // Die after 3 missed keepalives
-    '-o', 'ExitOnForwardFailure=yes',                // Fail if port forward fails
-    '-o', 'StrictHostKeyChecking=accept-new',
-    ...(options.identity ? ['-i', options.identity] : []),
-    target,
-  ];
-
-  const tunnel = spawn('ssh', sshArgs, {
-    stdio: ['ignore', 'ignore', 'pipe'],
-    detached: true,
-  });
-
-  // Capture stderr for early errors
-  let stderrBuf = '';
-  tunnel.stderr.on('data', (chunk) => { stderrBuf += chunk.toString(); });
-
-  // Wait a moment to catch immediate failures (bad key, connection refused)
-  await new Promise((resolve) => setTimeout(resolve, 2000));
-
-  // Check if tunnel is still alive
-  if (tunnel.exitCode !== null) {
-    console.log(chalk.red('  Tunnel failed to start.'));
-    if (stderrBuf.trim()) {
-      console.log(chalk.dim('  ' + stderrBuf.trim()));
+  // Fire connect — the daemon handles test, install, upgrade, start, port-forward
+  console.log(chalk.dim('  Connecting...'));
+
+  let connectDone = false;
+  let connectResult = null;
+  let connectError = null;
+
+  const connectPromise = fetch(`${API}/tunnels/${tunnelId}/connect`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({}),
+  }).then(async r => {
+    const data = await r.json();
+    if (!r.ok) throw new Error(data.error || 'Connection failed');
+    return data;
+  }).then(data => { connectResult = data; })
+    .catch(err => { connectError = err; })
+    .finally(() => { connectDone = true; });
+
+  // Poll status every 2s while connect is in progress
+  let dots = 0;
+  while (!connectDone) {
+    await sleep(2000);
+    if (connectDone) break;
+    try {
+      const res = await fetch(`${API}/tunnels/${tunnelId}/status`, {
+        signal: AbortSignal.timeout(2000),
+      });
+      const status = await res.json();
+      if (status.active) break;
+    } catch {
+      // status poll failure is non-fatal
     }
-    console.log('');
-    return;
+    dots++;
+    process.stdout.write(`\r  ${chalk.dim('Connecting' + '.'.repeat((dots % 3) + 1).padEnd(3))}   `);
   }
 
-  // Verify the tunnel is actually forwarding
-  const tunnelUp = await isPortInUse(localPort);
-  if (!tunnelUp) {
-    console.log(chalk.red('  Tunnel started but port forward not active.'));
-    try { process.kill(tunnel.pid); } catch { /* ignore */ }
+  // Ensure connect promise resolves
+  await connectPromise;
+  process.stdout.write('\r' + ' '.repeat(40) + '\r');
+
+  if (connectError) {
+    console.log(chalk.red('  Connection failed: ') + connectError.message);
     console.log('');
     return;
   }
 
-  // Detach and save PID
-  tunnel.unref();
-  writeFileSync(pidFile(), String(tunnel.pid), { mode: 0o600 });
-  writeFileSync(tunnelInfoFile(), JSON.stringify({
-    target,
-    localPort,
-    remotePort: REMOTE_PORT,
-    startedAt: new Date().toISOString(),
-  }), { mode: 0o600 });
-
-  const url = `http://localhost:${localPort}`;
+  const url = connectResult.url || `http://localhost:${connectResult.localPort}`;
 
-  console.log('');
   console.log(chalk.green('  Connected!'));
   console.log('');
   console.log(`  Target:  ${chalk.bold(target)}`);
-  console.log(`  Tunnel:  localhost:${localPort} → ${target}:${REMOTE_PORT}`);
+  console.log(`  Tunnel:  localhost:${connectResult.localPort} → ${target}:31415`);
   console.log(`  GUI:     ${chalk.cyan(url)}`);
-  console.log(`  PID:     ${tunnel.pid}`);
   console.log('');
 
-  // Open browser (Commander: --no-browser sets options.browser = false)
   if (options.browser !== false) {
     openBrowser(url);
   }

package/node_modules/@groove-dev/cli/src/commands/disconnect.js

@@ -1,91 +1,67 @@
-// GROOVE CLI — disconnect command (kill SSH tunnel)
+// GROOVE CLI — disconnect command (close SSH tunnel via daemon)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { execFileSync } from 'child_process';
-import { existsSync, readFileSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
 import chalk from 'chalk';
 
-function pidFile() {
-  return resolve(process.cwd(), '.groove', 'tunnel.pid');
-}
-
-function tunnelInfoFile() {
-  return resolve(process.cwd(), '.groove', 'tunnel.json');
-}
+const API = 'http://localhost:31415/api';
 
-function cleanup() {
-  try { if (existsSync(pidFile())) unlinkSync(pidFile()); } catch { /* ignore */ }
-  try { if (existsSync(tunnelInfoFile())) unlinkSync(tunnelInfoFile()); } catch { /* ignore */ }
+async function daemonRunning() {
+  try {
+    const res = await fetch(`${API}/health`, { signal: AbortSignal.timeout(3000) });
+    return res.ok;
+  } catch {
+    return false;
+  }
 }
 
-export async function disconnect() {
+export async function disconnect(target) {
   console.log('');
 
-  const pf = pidFile();
-  if (!existsSync(pf)) {
-    console.log(chalk.yellow('  No active tunnel found.'));
+  if (!(await daemonRunning())) {
+    console.log(chalk.yellow('  No daemon running.'));
     console.log('');
     return;
   }
 
-  const pid = parseInt(readFileSync(pf, 'utf8').trim(), 10);
-  if (isNaN(pid)) {
-    console.log(chalk.yellow('  Invalid tunnel PID file. Cleaning up.'));
-    cleanup();
-    console.log('');
-    return;
-  }
-
-  // Read tunnel info for display
-  let info = {};
-  try {
-    const infoPath = tunnelInfoFile();
-    if (existsSync(infoPath)) {
-      info = JSON.parse(readFileSync(infoPath, 'utf8'));
-    }
-  } catch { /* ignore */ }
-
-  // Check if process is alive
+  let tunnels;
   try {
-    process.kill(pid, 0);
-  } catch {
-    console.log(chalk.yellow('  Tunnel process already dead. Cleaning up.'));
-    cleanup();
+    const res = await fetch(`${API}/tunnels`);
+    tunnels = await res.json();
+  } catch (err) {
+    console.log(chalk.red('  Failed to query tunnels: ') + err.message);
     console.log('');
     return;
   }
 
-  // Verify the PID belongs to an SSH process (not a random reused PID after reboot)
-  try {
-    const cmd = execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
-      encoding: 'utf8', timeout: 3000,
-    }).trim();
-    if (!cmd.includes('ssh')) {
-      console.log(chalk.yellow('  PID no longer belongs to an SSH tunnel. Cleaning up stale files.'));
-      cleanup();
+  // Find the tunnel to disconnect
+  let tunnel;
+  if (target) {
+    tunnel = tunnels.find(t => t.active && (t.name === target || t.host === target || t.id === target));
+    if (!tunnel) {
+      console.log(chalk.yellow(`  No active tunnel matching "${target}".`));
+      console.log('');
+      return;
+    }
+  } else {
+    tunnel = tunnels.find(t => t.active);
+    if (!tunnel) {
+      console.log(chalk.yellow('  No active tunnel found.'));
       console.log('');
       return;
     }
-  } catch {
-    // ps failed — proceed cautiously, don't kill
-    console.log(chalk.yellow('  Cannot verify tunnel process. Cleaning up stale files.'));
-    cleanup();
-    console.log('');
-    return;
   }
 
-  // Kill the tunnel
   try {
-    process.kill(pid, 'SIGTERM');
-    console.log(chalk.green('  Tunnel disconnected.'));
-    if (info.target) {
-      console.log(`  Was connected to: ${chalk.dim(info.target)}`);
-    }
+    const res = await fetch(`${API}/tunnels/${tunnel.id}/disconnect`, { method: 'POST' });
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.error || 'Disconnect failed');
   } catch (err) {
-    console.log(chalk.red('  Failed to kill tunnel: ') + err.message);
+    console.log(chalk.red('  Disconnect failed: ') + err.message);
+    console.log('');
+    return;
   }
 
-  cleanup();
+  console.log(chalk.green('  Tunnel disconnected.'));
+  console.log(`  Was connected to: ${chalk.dim(tunnel.name)}`);
   console.log('');
 }

package/node_modules/@groove-dev/cli/src/commands/remotes.js

@@ -0,0 +1,75 @@
+// GROOVE CLI — remotes command (list saved SSH tunnels)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import chalk from 'chalk';
+
+const API = 'http://localhost:31415/api';
+
+async function daemonRunning() {
+  try {
+    const res = await fetch(`${API}/health`, { signal: AbortSignal.timeout(3000) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function remotes() {
+  console.log('');
+
+  if (!(await daemonRunning())) {
+    console.log(chalk.yellow('  Daemon is not running.'));
+    console.log(`  Run ${chalk.bold('groove start')} first.`);
+    console.log('');
+    return;
+  }
+
+  let tunnels;
+  try {
+    const res = await fetch(`${API}/tunnels`);
+    tunnels = await res.json();
+  } catch (err) {
+    console.log(chalk.red('  Failed to query tunnels: ') + err.message);
+    console.log('');
+    return;
+  }
+
+  if (!tunnels.length) {
+    console.log(chalk.dim('  No saved remotes.'));
+    console.log(`  Use ${chalk.bold('groove connect user@host')} to add one.`);
+    console.log('');
+    return;
+  }
+
+  // Column headers
+  const nameW = Math.max(6, ...tunnels.map(t => t.name.length)) + 2;
+  const hostW = Math.max(6, ...tunnels.map(t => t.host.length)) + 2;
+  const userW = Math.max(6, ...tunnels.map(t => t.user.length)) + 2;
+
+  const header =
+    chalk.dim('  ' +
+      'NAME'.padEnd(nameW) +
+      'HOST'.padEnd(hostW) +
+      'USER'.padEnd(userW) +
+      'STATUS'.padEnd(12) +
+      'PORT');
+  console.log(header);
+  console.log(chalk.dim('  ' + '─'.repeat(nameW + hostW + userW + 12 + 6)));
+
+  for (const t of tunnels) {
+    const statusRaw = t.active ? 'active' : 'inactive';
+    const statusCol = t.active ? chalk.green(statusRaw) : chalk.dim(statusRaw);
+    const portRaw = t.active && t.localPort ? String(t.localPort) : '—';
+    const portCol = t.active && t.localPort ? chalk.cyan(portRaw) : chalk.dim(portRaw);
+    console.log(
+      '  ' +
+      t.name.padEnd(nameW) +
+      t.host.padEnd(hostW) +
+      t.user.padEnd(userW) +
+      statusCol + ' '.repeat(Math.max(1, 12 - statusRaw.length)) +
+      portCol
+    );
+  }
+
+  console.log('');
+}

package/node_modules/@groove-dev/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.86",
+  "version": "0.27.88",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",