@jlongo78/agent-spaces 1.0.0 → 1.0.2

package/bin/spaces.js

@@ -198,6 +198,9 @@ if (cliFlags.help) {
                                  update it when it is older than this machine's
     spaces --remote you@host --yes
                                  The same, installing or updating without asking
+    spaces open --remote you@host
+                                 The web app for Spaces on another machine, in your
+                                 browser, through an SSH tunnel (Ctrl+C closes it)
     spaces start                 Start the server in the background, if it is not running
     spaces open                  Open the web app in your browser, signed in
     spaces signout               Sign out every browser and terminal client
@@ -244,8 +247,8 @@ if (cliFlags.help) {
 const subcommand = args[0];
 // `--remote` means "the terminal client, over there". With any other command
 // it would be silently ignored and the command would run here instead.
-if (cliFlags.remote && subcommand && subcommand !== 'tui' && !subcommand.startsWith('-')) {
-  console.error(`  --remote works with "spaces" and "spaces tui", not "spaces ${subcommand}".`);
+if (cliFlags.remote && subcommand && subcommand !== 'tui' && subcommand !== 'open' && !subcommand.startsWith('-')) {
+  console.error(`  --remote works with "spaces", "spaces tui" and "spaces open", not "spaces ${subcommand}".`);
   console.error(`  To run that on the other machine: ssh ${cliFlags.remote} spaces ${subcommand}`);
   process.exit(2);
 }
@@ -298,7 +301,7 @@ if (subcommand === 'service') {
 }
 
 // ─── Route tui to the platform terminal-client binary ─────
-if (subcommand === 'tui' || cliFlags.remote) {
+if (subcommand === 'tui' || (cliFlags.remote && subcommand !== 'open')) {
   // Explicit `spaces tui` never silently opens a browser: the user asked
   // for the terminal client by name, so a failure is reported as one. Bare
   // `spaces --remote host` asks for the same thing.
@@ -322,7 +325,11 @@ if (subcommand === 'signout') {
 }
 
 // ─── Open the web app, signed in / setup wizard / server ──
-if (subcommand === 'open') {
+if (subcommand === 'open' && cliFlags.remote) {
+  // Waits for the tunnel on the event loop: part of this chain for the
+  // same reason as `open` below.
+  openRemote(cliFlags.remote);
+} else if (subcommand === 'open') {
   // Exits by itself: at once, or on Linux once the timer that removes the
   // sign-in redirect page fires. Part of this chain so it no longer falls
   // through to "Unknown command" while that timer is pending.
@@ -591,6 +598,19 @@ function startDetached(startArgs) {
     const session = desktopSessionToken();
     if (session) console.log(`SPACES_TOKEN=${session}`);
   }
+  // `spaces open --remote` asks for this: a browser sign-in code, the kind
+  // `spaces open` puts in its link (one use, two minutes), and the path the
+  // web app is served under. The secret itself never leaves this machine.
+  if (!multiuser && startArgs.includes('--print-login')) {
+    if (!listenerIsMine(port)) refuseForeignListener(port);
+    const secret = require('./lib/desktop-auth').readSecret(SPACES_DIR);
+    if (secret) {
+      const { createLoginCodes } = require('./lib/desktop-auth');
+      console.log(`SPACES_LOGIN=${createLoginCodes(() => secret).mint()}`);
+      const basePath = process.env.SPACES_BASE_PATH || readSavedConfig().basePath || '';
+      if (basePath) console.log(`SPACES_BASE_PATH=${basePath}`);
+    }
+  }
   process.exit(0);
 }
 
@@ -783,16 +803,55 @@ function launchRemote(dest, tuiArgs) {
     process.exit(1);
   }
 
+  const { start: r, localPort, closeTunnel } = connectRemote(dest);
+
+  // 3. The client, through the tunnel. The remote trusts it as local,
+  // because over there that is what it is.
+  const { token, rest } = splitToken(clientArgs);
+  const env = { ...process.env };
+  // The remote's own session token, handed back over SSH by
+  // `spaces start --print-token`; the remote's secret never leaves it.
+  const remoteToken = token || remote.parseStartToken(r.stdout);
+  if (!remoteToken) {
+    closeTunnel();
+    console.error(`  Spaces on ${dest} did not hand back a sign-in token. It may be an older`);
+    console.error(`  version; update it there (ssh ${dest} 'npm install -g @jlongo78/agent-spaces').`);
+    process.exit(1);
+  }
+  env.SPACES_TOKEN = remoteToken;
+  const status = runTuiBinary(tuiBin, buildTuiArgs(rest, localPort), { env });
+  closeTunnel();
+  console.log(`  Spaces is still running on ${dest} — "ssh ${dest} spaces stop" shuts it down.`);
+  process.exit(status);
+}
+
+/**
+ * What `spaces --remote` and `spaces open --remote` share: Spaces running on
+ * `dest` (installed or updated first, with the user's say-so) and an SSH
+ * tunnel to it from a local port. `login` also asks for a browser sign-in
+ * code; `localPort` is tried before any free port. Returns what `spaces
+ * start` printed over there, the local end of the tunnel, and ways to ask
+ * after it and close it. Exits, with the reason, when any step fails.
+ */
+function connectRemote(dest, { login = false, localPort: wantedPort = null } = {}) {
+  const remote = require('./lib/remote');
+  const { tailLines } = require('./spaces-tui');
+  const { spawnSync } = require('child_process');
+
   // 1. Make sure Spaces is running over there, and learn its port —
   // installing or updating it first, with the user's say-so.
   console.log(`  Connecting to ${dest}...`);
-  ensureRemoteInstall(dest);
-  const runStart = (loginShell) => spawnSync('ssh', remote.sshStartArgs(dest, { loginShell }), {
+  const prepared = ensureRemoteInstall(dest, { login });
+  const runStart = (loginShell) => spawnSync('ssh', sshWithKey(remote.sshStartArgs(dest, { loginShell, login })), {
     // No stdin, as for the probe in ensureRemoteInstall: nothing reads it.
     stdio: ['ignore', 'pipe', 'pipe'],
     encoding: 'utf-8',
   });
-  let r = runStart(false);
+  // An install already started it. Otherwise start it, through the login
+  // shell first when the probe showed the remote has one: one SSH session
+  // rather than two, and each can mean another password prompt.
+  if (!prepared.started) console.log(`  Starting Spaces on ${dest}...`);
+  let r = prepared.started || runStart(prepared.shell);
   if (r.error) {
     console.error(r.error.code === 'ENOENT'
       ? '  --remote needs the ssh client, and none was found on the PATH.'
@@ -800,8 +859,8 @@ function launchRemote(dest, tuiArgs) {
     process.exit(1);
   }
   let remotePort = r.status === 0 ? remote.parseStartOutput(r.stdout) : null;
-  if (remotePort === null && remote.classifyStartFailure(r.status, r.stderr) === 'missing') {
-    r = runStart(true);
+  if (remotePort === null && !prepared.started && remote.classifyStartFailure(r.status, r.stderr) === 'missing') {
+    r = runStart(!prepared.shell);
     remotePort = r.status === 0 ? remote.parseStartOutput(r.stdout) : null;
   }
   const relay = (text) => {
@@ -816,6 +875,12 @@ function launchRemote(dest, tuiArgs) {
       process.exit(1);
     }
     const kind = remote.classifyStartFailure(r.status, r.stderr);
+    if (login && /Unknown option: --print-login/.test(`${r.stdout}\n${r.stderr}`)) {
+      console.error(`  Spaces on ${dest} is too old to sign a browser in; that needs 1.0.1 or newer there.`);
+      console.error(`  Update it there:  ssh ${dest} 'npm install -g @jlongo78/agent-spaces'`);
+      console.error('  (spaces --remote offers to, once this machine has a newer version than that one).');
+      process.exit(1);
+    }
     if (kind === 'missing') {
       console.error(remote.installHint(dest));
     } else if (kind === 'ssh') {
@@ -828,8 +893,8 @@ function launchRemote(dest, tuiArgs) {
     process.exit(1);
   }
 
-  // 2. Tunnel a free local port to it.
-  const localPort = freeLocalPort();
+  // 2. Tunnel a local port to it.
+  const localPort = (wantedPort && localPortIsFree(wantedPort)) ? wantedPort : freeLocalPort();
   if (!localPort) {
     console.error('  Could not find a free local port for the tunnel.');
     process.exit(1);
@@ -837,45 +902,113 @@ function launchRemote(dest, tuiArgs) {
   fs.mkdirSync(SPACES_DIR, { recursive: true });
   const logPath = path.join(SPACES_DIR, 'remote-tunnel.log');
   const log = fs.openSync(logPath, 'w');
-  const tunnel = spawn('ssh', remote.sshTunnelArgs(dest, localPort, remotePort), {
+  // Its own SSH session, which may ask for the password again: say so,
+  // or a third prompt arrives with no explanation after two that looked
+  // like the whole sign-in.
+  console.log(`  Opening an SSH tunnel to Spaces on ${dest}...`);
+  const tunnel = spawn('ssh', sshWithKey(remote.sshTunnelArgs(dest, localPort, remotePort)), {
     stdio: ['ignore', log, log],
   });
   fs.closeSync(log);
   const closeTunnel = () => { try { tunnel.kill(); } catch { /* already gone */ } };
-  const outcome = waitForServer({
-    timeoutMs: 30000,
-    probe: () => portIsListening(localPort, 1000),
-    alive: () => { try { process.kill(tunnel.pid, 0); return true; } catch (e) { return e.code === 'EPERM'; } },
-  });
-  if (outcome !== 'up') {
+  // Waits on ssh's own log, starting no process meanwhile: on Windows each
+  // process that exits resets the shared console, and that garbles a
+  // password being typed into the tunnel's prompt. Minutes to type one;
+  // thirty seconds for the forward once signed in.
+  const readLog = () => { try { return fs.readFileSync(logPath, 'utf-8'); } catch { return ''; } };
+  const tunnelAlive = () => { try { process.kill(tunnel.pid, 0); return true; } catch (e) { return e.code === 'EPERM'; } };
+  const nap = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  let deadline = Date.now() + 5 * 60 * 1000;
+  let signedIn = false;
+  let up = false;
+  for (;;) {
+    const text = readLog();
+    if (remote.tunnelReady(text, localPort)) { up = true; break; }
+    if (!signedIn && remote.tunnelAuthenticated(text)) {
+      signedIn = true;
+      deadline = Math.min(deadline, Date.now() + 30000);
+    }
+    if (!tunnelAlive() || Date.now() > deadline) break;
+    nap(100);
+  }
+  if (!up) {
     closeTunnel();
     console.error(`  Could not open the SSH tunnel to ${dest}:`);
-    let output = '';
-    try { output = fs.readFileSync(logPath, 'utf-8'); } catch { /* nothing logged */ }
-    relay(output);
+    relay(remote.withoutDebug(readLog()));
     process.exit(1);
   }
+  return { start: r, localPort, tunnel, closeTunnel, tunnelAlive };
+}
 
-  // 3. The client, through the tunnel. The remote trusts it as local,
-  // because over there that is what it is.
-  const { token, rest } = splitToken(clientArgs);
-  const env = { ...process.env };
-  // The remote's own session token, handed back over SSH by
-  // `spaces start --print-token`; the remote's secret never leaves it.
-  const remoteToken = token || remote.parseStartToken(r.stdout);
-  if (!remoteToken) {
+/** True when nothing on this machine listens on 127.0.0.1:`port`. */
+function localPortIsFree(port) {
+  const { spawnSync } = require('child_process');
+  const r = spawnSync(process.execPath, ['-e', `
+    const s = require('net').createServer();
+    s.on('error', () => process.exit(1));
+    s.listen(${Number(port)}, '127.0.0.1', () => s.close(() => process.exit(0)));
+  `], { stdio: 'ignore', timeout: 5000 });
+  return r.status === 0;
+}
+
+/**
+ * `spaces open --remote <dest>`: the web app for Spaces on another machine.
+ * Connects as `spaces --remote` does, then signs the browser in through
+ * the tunnel with a one-time code made over there, and keeps the tunnel up
+ * until Ctrl+C.
+ *
+ * 127.0.0.1 rather than localhost: browsers keep cookies per host name, not
+ * per port, so a remote signed in at localhost would replace the sign-in to
+ * this machine's own Spaces at localhost:3457, and back again.
+ */
+function openRemote(dest) {
+  const remote = require('./lib/remote');
+  try {
+    remote.validateDestination(dest);
+  } catch (e) {
+    console.error(`  ${e.message}`);
+    process.exit(2);
+  }
+  if (cliFlags.port || cliFlags.basePath) {
+    console.error('  --port and --base-path describe this machine\'s server, not the remote\'s.');
+    process.exit(2);
+  }
+  const { start, localPort, closeTunnel, tunnel } = connectRemote(dest, {
+    login: true,
+    localPort: remote.preferredLocalPort(dest),
+  });
+  const code = remote.parseStartLogin(start.stdout);
+  if (!code) {
     closeTunnel();
-    console.error(`  Spaces on ${dest} did not hand back a sign-in token. It may be an older`);
-    console.error(`  version; update it there (ssh ${dest} 'npm install -g @jlongo78/agent-spaces').`);
+    console.error(`  Spaces on ${dest} did not hand back a browser sign-in. It needs Spaces 1.0.1 or`);
+    console.error(`  newer there; "spaces --remote ${dest}" offers to update it.`);
     process.exit(1);
   }
-  env.SPACES_TOKEN = remoteToken;
-  const status = runTuiBinary(tuiBin, buildTuiArgs(rest, localPort), { env });
-  closeTunnel();
-  console.log(`  Spaces is still running on ${dest} — "ssh ${dest} spaces stop" shuts it down.`);
-  process.exit(status);
+  const home = `http://127.0.0.1:${localPort}${remote.parseStartBasePath(start.stdout)}`;
+  const url = `${home}/auth/desktop?code=${code}`;
+  if (!openSignInLink(url)) {
+    console.log('  Open this link in your browser within two minutes (it works once):');
+    console.log(`    ${url}`);
+  }
+  console.log(`  Spaces on ${dest} is at ${home} while this runs. Ctrl+C closes the tunnel.`);
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+    closeTunnel();
+    console.log(`\n  Closed the tunnel to ${dest}; Spaces keeps running there.`);
+    process.exit(0);
+  };
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+  // Ctrl+C reaches ssh too, so it may exit before the handler above runs.
+  tunnel.on('exit', () => {
+    if (stopping) return;
+    console.error(`  The SSH tunnel to ${dest} closed; run this again to reconnect.`);
+    process.exit(1);
+  });
 }
 
+
 // ─── TLS certificate ────────────────────────────────────────
 // Uses a real cert if configured in server.json (tlsCert, tlsKey, optional
 // tlsCa for the full chain), otherwise generates a self-signed cert so
@@ -1678,29 +1811,171 @@ async function printStatus(porcelain) {
   process.exit(0);
 }
 
+/**
+ * `args` for an ssh that `--remote` runs, signing in with SPACES_SSH_KEY
+ * when it names a key. Only tests set it: everyone else signs in with the
+ * keys plain `ssh` uses, which is what the key offer below sets up.
+ */
+function sshWithKey(args) {
+  const key = process.env.SPACES_SSH_KEY;
+  return key ? ['-i', key, ...args] : args;
+}
+
+/**
+ * Where the destinations whose key offer was declined are kept. A function,
+ * not a constant: `--remote` runs while this file is still being read, and
+ * a constant declared down here would not exist yet.
+ */
+function keyOfferDeclinedPath() {
+  return path.join(SPACES_DIR, 'remote-key-declined.json');
+}
+
+function keyOfferDeclined(dest) {
+  try { return JSON.parse(fs.readFileSync(keyOfferDeclinedPath(), 'utf-8')).includes(dest); } catch { return false; }
+}
+
+function declineKeyOffer(dest) {
+  let list = [];
+  try { list = JSON.parse(fs.readFileSync(keyOfferDeclinedPath(), 'utf-8')); } catch { /* none yet */ }
+  if (!Array.isArray(list)) list = [];
+  if (!list.includes(dest)) list.push(dest);
+  try {
+    fs.mkdirSync(SPACES_DIR, { recursive: true });
+    fs.writeFileSync(keyOfferDeclinedPath(), JSON.stringify(list, null, 2));
+  } catch { /* asked again next time, then */ }
+}
+
+/**
+ * The key to sign in with: SPACES_SSH_KEY, else the first of ssh's default
+ * keys that has a public half, else a new ~/.ssh/id_ed25519. A new key has
+ * no passphrase (the account's file permissions protect it, as with any
+ * key ssh-keygen makes by default); on Windows its permissions are narrowed
+ * to this user, since OpenSSH there ignores a private key anyone else can
+ * read. Null, with the reason printed, when no key could be had.
+ */
+function localSshKey() {
+  const remote = require('./lib/remote');
+  const { spawnSync } = require('child_process');
+  const sshDir = path.join(os.homedir(), '.ssh');
+  const wanted = process.env.SPACES_SSH_KEY;
+  if (!wanted) {
+    for (const name of remote.DEFAULT_KEYS) {
+      const key = path.join(sshDir, name);
+      if (fs.existsSync(key) && fs.existsSync(`${key}.pub`)) return { key, created: false };
+    }
+  }
+  const key = wanted || path.join(sshDir, 'id_ed25519');
+  if (fs.existsSync(key) && fs.existsSync(`${key}.pub`)) return { key, created: false };
+  if (fs.existsSync(key)) {
+    console.error(`  ${key} exists without its .pub; not overwriting it.`);
+    return null;
+  }
+  fs.mkdirSync(path.dirname(key), { recursive: true, mode: 0o700 });
+  const comment = `${os.userInfo().username}@${os.hostname()}`.replace(/\s+/g, '-');
+  const r = spawnSync('ssh-keygen', ['-q', '-t', 'ed25519', '-N', '', '-C', comment, '-f', key], {
+    stdio: ['ignore', 'ignore', 'pipe'], encoding: 'utf-8',
+  });
+  if (r.error || r.status !== 0 || !fs.existsSync(`${key}.pub`)) {
+    console.error(`  Could not create an SSH key with ssh-keygen: ${r.error ? r.error.message : (r.stderr || '').trim()}`);
+    return null;
+  }
+  if (process.platform === 'win32') {
+    spawnSync('icacls', [key, '/inheritance:r', '/grant:r', `${os.userInfo().username}:F`], { stdio: 'ignore' });
+  }
+  return { key, created: true };
+}
+
+/**
+ * When `dest` wants a password: offers to set up key sign-in, once per
+ * destination (a "no" is remembered). Adds this machine's public key to
+ * ~/.ssh/authorized_keys there — the last password prompt — then checks
+ * the key works. True when it does.
+ */
+function offerSshKey(dest) {
+  const remote = require('./lib/remote');
+  const { ask } = require('./lib/prompt');
+  const { spawnSync } = require('child_process');
+  if (keyOfferDeclined(dest)) return false;
+
+  console.log(`  ${dest} asks for your password on every connection, and --remote makes three.`);
+  if (ask('  Set up an SSH key so it stops asking? [Y/n] ', ['y', 'n'], 'y') !== 'y') {
+    declineKeyOffer(dest);
+    console.log(`  Not asking again for ${dest}; delete ${keyOfferDeclinedPath()} to be asked again.`);
+    return false;
+  }
+
+  const local = localSshKey();
+  if (!local) return false;
+  let pub = null;
+  try { pub = remote.publicKeyLine(fs.readFileSync(`${local.key}.pub`, 'utf-8')); } catch { /* reported below */ }
+  if (!pub) {
+    console.error(`  ${local.key}.pub is not a public key ssh can use.`);
+    return false;
+  }
+  if (local.created) console.log(`  Created ${local.key} (and .pub).`);
+  console.log(`  Adding it to ~/.ssh/authorized_keys on ${dest}. Your password, one last time:`);
+  const add = spawnSync('ssh', sshWithKey(remote.sshAuthorizeKeyArgs(dest)), {
+    input: `${pub}\n`, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8',
+  });
+  if (add.error || add.status !== 0) {
+    console.error(`  Could not add the key on ${dest}:`);
+    for (const line of require('./spaces-tui').tailLines(`${add.stderr || ''}`, 4)) console.error(`    ${line.trim()}`);
+    return false;
+  }
+
+  const check = spawnSync('ssh', sshWithKey(['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=15', '--', dest, 'true']), {
+    stdio: ['ignore', 'ignore', 'pipe'], encoding: 'utf-8',
+  });
+  if (check.status !== 0) {
+    console.error(`  The key is on ${dest}, but signing in with it still failed.`);
+    if (process.platform === 'win32') {
+      console.error('  OpenSSH on Windows ignores a private key others can read; to make it yours alone:');
+      console.error(`    icacls "${local.key}" /inheritance:r /grant:r "%USERNAME%":F`);
+    }
+    return false;
+  }
+  console.log(`  Done: ${dest} now signs you in with ${path.basename(local.key)}, here and with plain ssh.`);
+  return true;
+}
+
 /**
  * Before `--remote` connects: installs Spaces on `dest` when it is missing,
  * or updates it when it is older than this machine's — asking first unless
  * `--yes`, and saying how many agents an update would stop. A remote that
  * cannot be asked (an ssh failure, a shell that is not sh-like) is left to
  * the connection step, which reports it as it always has.
+ *
+ * Returns `shell` (the remote answered through an sh-like login shell) and
+ * `started` (the install's ssh result, which already started the server),
+ * so the connection step does not open sessions it needs no longer.
  */
-function ensureRemoteInstall(dest) {
+function ensureRemoteInstall(dest, { login = false } = {}) {
   const remote = require('./lib/remote');
   const { spawnSync } = require('child_process');
   const local = require('../package.json').version;
-  // No stdin: neither command reads it, and a session holding the terminal
-  // open can outlive its command. ssh asks for passwords on /dev/tty anyway.
-  const probe = spawnSync('ssh', remote.sshProbeArgs(dest), {
-    stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8',
-  });
-  if (probe.error || probe.status === 255) return;
-  const plan = remote.planRemote(remote.parseProbe(probe.stdout), local);
   // isatty, not process.stdin.isTTY: touching process.stdin hands the
-  // terminal to Node's own reader, and the question below would never be
+  // terminal to Node's own reader, and the questions below would never be
   // answered (see lib/prompt.js).
   const interactive = require('tty').isatty(0) && Boolean(process.stdout.isTTY);
   const { ask } = require('./lib/prompt');
+  // No stdin: neither command reads it, and a session holding the terminal
+  // open can outlive its command. ssh asks for passwords on the console.
+  const runProbe = (batch) => spawnSync('ssh', sshWithKey(remote.sshProbeArgs(dest, { batch })), {
+    stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8',
+  });
+  // First without prompts: a key that works needs nothing more. A server
+  // that wants a password gets the offer of a key instead; anything else
+  // (an unknown host key, say) goes to ssh's own questions, as before.
+  let probe = runProbe(true);
+  if (!probe.error && probe.status === 255) {
+    const why = remote.classifySshFailure(probe.stderr);
+    if (why === 'password' && interactive && offerSshKey(dest)) probe = runProbe(true);
+    if (probe.status === 255) probe = runProbe(false);
+  }
+  if (probe.error || probe.status === 255) return { shell: false, started: null };
+  const probed = remote.parseProbe(probe.stdout);
+  const plan = remote.planRemote(probed, local);
+  const done = { shell: probed !== null, started: null };
 
   let spec;
   try {
@@ -1711,12 +1986,12 @@ function ensureRemoteInstall(dest) {
   }
   const install = ({ restart }) => {
     console.log(`  Installing ${spec} on ${dest}. Compiling the terminal library can take a minute...`);
-    const r = spawnSync('ssh', remote.sshInstallArgs(dest, spec, { restart }), {
+    const r = spawnSync('ssh', sshWithKey(remote.sshInstallArgs(dest, spec, { restart, login })), {
       stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8',
     });
     if (r.status === 0) {
       console.log(`  Spaces ${local} is installed on ${dest}.`);
-      return;
+      return r;
     }
     const output = `${r.stdout || ''}\n${r.stderr || ''}`;
     for (const line of require('./spaces-tui').tailLines(output, 8)) console.error(`    ${line.trim()}`);
@@ -1726,11 +2001,11 @@ function ensureRemoteInstall(dest) {
 
   switch (plan.action) {
     case 'connect':
-      return;
+      return done;
     case 'newer':
       console.log(`  Spaces on ${dest} is ${plan.remote}, newer than this machine's ${local}.`);
       console.log(`  To update this machine: npm install -g ${remote.PACKAGE}`);
-      return;
+      return done;
     case 'no-node':
       console.error(`  Spaces is not installed on ${dest}, and neither is Node.js, which it needs (20.9 or newer).`);
       console.error('  Install Node.js there first; nvm is the easiest way: https://github.com/nvm-sh/nvm');
@@ -1752,20 +2027,19 @@ function ensureRemoteInstall(dest) {
           process.exit(1);
         }
       }
-      install({ restart: false });
-      return;
+      return { ...done, started: install({ restart: false }) };
     }
     case 'update': {
       const stops = plan.running === false ? 0 : plan.liveAgents;
       if (!cliFlags.yes) {
         if (!interactive) {
           console.log(`  Spaces on ${dest} is ${plan.from}, older than this machine's ${local}; run with --yes to update it.`);
-          return;
+          return done;
         }
         if (stops === 0) {
           const restarting = plan.running ? ' It restarts Spaces there; no agents are running.' : '';
           if (ask(`  Spaces on ${dest} is ${plan.from}, older than this machine's ${local}. Update it?${restarting} [Y/n] `, ['y', 'n'], 'y') !== 'y') {
-            return;
+            return done;
           }
         } else {
           console.log(`  Spaces on ${dest} is ${plan.from}, older than this machine's ${local}.`);
@@ -1774,14 +2048,13 @@ function ensureRemoteInstall(dest) {
             : `  Updating restarts Spaces on ${dest} and stops its ${stops} running ${stops === 1 ? 'agent' : 'agents'}.`);
           const choice = ask(`  [u]pdate now, [c]onnect to ${plan.from} as it is, or [q]uit? [u/c/q] `, ['u', 'c', 'q'], null);
           if (choice === 'q') process.exit(0);
-          if (choice !== 'u') return;
+          if (choice !== 'u') return done;
         }
       }
-      install({ restart: plan.running !== false });
-      return;
+      return { ...done, started: install({ restart: plan.running !== false }) };
     }
     default:
-      return;
+      return done;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jlongo78/agent-spaces",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Agent workspace manager for Claude, Codex, Gemini, and more",
   "bin": {
     "spaces": "./bin/spaces.js",
@@ -122,11 +122,11 @@
     "xterm": "^5.3.0"
   },
   "optionalDependencies": {
-    "@jlongo78/agent-spaces-tui-darwin-arm64": "1.0.0",
-    "@jlongo78/agent-spaces-tui-darwin-x64": "1.0.0",
-    "@jlongo78/agent-spaces-tui-linux-arm64": "1.0.0",
-    "@jlongo78/agent-spaces-tui-linux-x64": "1.0.0",
-    "@jlongo78/agent-spaces-tui-win32-x64": "1.0.0",
+    "@jlongo78/agent-spaces-tui-darwin-arm64": "1.0.2",
+    "@jlongo78/agent-spaces-tui-darwin-x64": "1.0.2",
+    "@jlongo78/agent-spaces-tui-linux-arm64": "1.0.2",
+    "@jlongo78/agent-spaces-tui-linux-x64": "1.0.2",
+    "@jlongo78/agent-spaces-tui-win32-x64": "1.0.2",
     "otpauth": "^9.5.0",
     "qrcode": "^1.5.4"
   }