cli-setu 0.1.0

package/src/pair.js

@@ -0,0 +1,83 @@
+// The one-time pairing flow, exactly as proven in supervisor-qr.js's
+// ensurePaired() - same real HTTP calls, same QR + typed-code dual path
+// (either wins, whichever the phone actually uses). What changes here:
+// the device name comes from config.js's auto-detected hostname instead
+// of a hand-typed argv, and the result is saved to ~/.cli-setu/config.json
+// instead of a per-device-name file in the install folder.
+const qrcode = require('qrcode-terminal');
+const { loadOrCreateConfig, writeConfig } = require('./config');
+
+async function pair(authServer, authServerPublic) {
+  const config = loadOrCreateConfig();
+
+  if (config.deviceToken) {
+    console.log(`[setu] "${config.deviceName}" is already paired.`);
+    return config;
+  }
+
+  console.log(`[setu] Pairing as "${config.deviceName}"...`);
+  console.log('[setu] (This is your computer\'s name. Rename it in ~/.cli-setu/config.json before pairing if you want something else.)');
+
+  // qr-start also needs a sessionId up front (mirrors supervisor-qr.js's
+  // "the QR both pairs it AND jumps the phone straight to watching THIS
+  // session" behavior) - 'pairing' is a placeholder id here since `setu
+  // pair` itself never streams a terminal; the real per-run session id is
+  // generated fresh by supervisor.js on every `setu` (bare) invocation.
+  const startRes = await fetch(`${authServer}/device/pair/qr-start`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ deviceName: config.deviceName, sessionId: 'pairing' }),
+  });
+  const { qrToken } = await startRes.json();
+
+  const scanUrl = `${authServerPublic}/scan.html?token=${qrToken}&session=pairing&device=${encodeURIComponent(config.deviceName)}`;
+
+  console.log('');
+  qrcode.generate(scanUrl, { small: true });
+  console.log('[setu] Scan this with your phone camera.');
+  console.log(`[setu] (Testing on one PC? Paste this URL into a browser tab instead: ${scanUrl})`);
+
+  const codeRes = await fetch(`${authServer}/device/pair/start`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ deviceName: config.deviceName }),
+  });
+  const { code: typedCode, pairId: typedPairId } = await codeRes.json();
+  console.log(`[setu] Or type this code in the app's Devices tab: ${typedCode}`);
+  console.log('[setu] Waiting for scan or code entry...');
+
+  let confirmed = false;
+  while (!confirmed) {
+    await new Promise((r) => setTimeout(r, 2000));
+    const statusRes = await fetch(`${authServer}/device/pair/qr-status?token=${qrToken}`);
+    const status = await statusRes.json();
+
+    if (status.status === 'CONFIRMED') {
+      confirmed = true;
+      config.deviceToken = status.deviceToken;
+      writeConfig(config);
+      console.log(`[setu] ✓ Paired via QR and saved to ~/.cli-setu/config.json`);
+      break;
+    } else if (status.status === 'EXPIRED') {
+      console.error('[setu] QR code expired. Run `setu pair` again to get a new one.');
+      process.exit(1);
+    } else if (status.status === 'REJECTED') {
+      console.error(`[setu] Pairing rejected: ${status.rejectReason || 'the server declined this pairing.'}`);
+      process.exit(1);
+    }
+
+    const typedStatusRes = await fetch(`${authServer}/device/pair/status?pairId=${typedPairId}`);
+    const typedStatus = await typedStatusRes.json();
+    if (typedStatus.status === 'CONFIRMED') {
+      confirmed = true;
+      config.deviceToken = typedStatus.deviceToken;
+      writeConfig(config);
+      console.log(`[setu] ✓ Paired via typed code and saved to ~/.cli-setu/config.json`);
+      break;
+    }
+  }
+
+  return config;
+}
+
+module.exports = { pair };

package/src/status.js

@@ -0,0 +1,65 @@
+// `setu status` - reports whether this computer is paired, and which
+// sessions (if any) currently have a `setu` process running, using the
+// PID files supervisor.js writes/removes around its own lifetime (see
+// its own comment on why - there was no way to answer this question at
+// all before those existed).
+const fs = require('fs');
+const { readConfig, CONFIG_DIR } = require('./config');
+
+function isProcessAlive(pid) {
+  try {
+    // Signal 0 sends nothing - it only checks whether the PID exists and
+    // is one this user can signal. Throws if it doesn't (already exited,
+    // e.g. the process crashed without reaching its own cleanup code).
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function status(authServer) {
+  const config = readConfig();
+  if (!config || !config.deviceToken) {
+    console.log('[setu] Not paired. Run `setu pair` to get started.');
+    return;
+  }
+  console.log(`[setu] Paired as "${config.deviceName}".`);
+
+  let files;
+  try {
+    files = fs.readdirSync(CONFIG_DIR).filter((f) => f.startsWith('session.') && f.endsWith('.pid'));
+  } catch {
+    files = [];
+  }
+
+  const running = [];
+  for (const file of files) {
+    let info;
+    try {
+      info = JSON.parse(fs.readFileSync(`${CONFIG_DIR}/${file}`, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (isProcessAlive(info.pid)) {
+      running.push(info);
+    } else {
+      // Stale PID file from a process that crashed/was killed without
+      // reaching its own SIGINT/exit cleanup - clean it up now rather
+      // than reporting a dead session as running forever.
+      try { fs.unlinkSync(`${CONFIG_DIR}/${file}`); } catch {}
+    }
+  }
+
+  if (running.length === 0) {
+    console.log('[setu] No sessions currently running. Run `setu` in a project folder to start one.');
+    return;
+  }
+
+  console.log(`[setu] ${running.length} session(s) running:`);
+  for (const s of running) {
+    console.log(`  - ${s.sessionId} · ${s.cwd} · started ${s.startedAt} (pid ${s.pid})`);
+  }
+}
+
+module.exports = { status };

package/src/stop.js

@@ -0,0 +1,51 @@
+// `setu stop` - cleanly disconnects every session currently running on
+// this computer. Real gap in the PoC this replaces: the only way to stop
+// a supervisor was closing its terminal window (or Ctrl+C, which only
+// reaches the one you're actually looking at) - this reaches every
+// running session at once via the same PID files status.js reads.
+const fs = require('fs');
+const { CONFIG_DIR } = require('./config');
+
+async function stop() {
+  let files;
+  try {
+    files = fs.readdirSync(CONFIG_DIR).filter((f) => f.startsWith('session.') && f.endsWith('.pid'));
+  } catch {
+    files = [];
+  }
+
+  if (files.length === 0) {
+    console.log('[setu] No sessions currently running.');
+    return;
+  }
+
+  let stopped = 0;
+  for (const file of files) {
+    const pidFile = `${CONFIG_DIR}/${file}`;
+    let info;
+    try {
+      info = JSON.parse(fs.readFileSync(pidFile, 'utf8'));
+    } catch {
+      continue;
+    }
+    try {
+      // SIGINT (not SIGKILL) - the same signal Ctrl+C sends, so the
+      // process's own handler (supervisor.js's process.on('SIGINT', ...))
+      // runs: kills the PTY cleanly, closes the WebSocket, removes its own
+      // PID file. A hard kill would skip all of that and leave the CLI
+      // process and the Azure connection to time out on their own.
+      process.kill(info.pid, 'SIGINT');
+      console.log(`[setu] Stopped ${info.sessionId} (${info.cwd})`);
+      stopped++;
+    } catch {
+      // Already dead - just clean up the stale file.
+      try { fs.unlinkSync(pidFile); } catch {}
+    }
+  }
+
+  if (stopped === 0) {
+    console.log('[setu] Sessions were already stopped (stale state cleaned up).');
+  }
+}
+
+module.exports = { stop };