@zonease/happy 0.6.37 → 0.6.39

package/dist/ssh-BTOlhhxi.cjs

@@ -0,0 +1,333 @@
+'use strict';
+
+var socket_ioClient = require('socket.io-client');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var deviceExec = require('./deviceExec-CU1R9CRb.cjs');
+var axios = require('axios');
+var tweetnacl = require('tweetnacl');
+var fs = require('node:fs');
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var os = require('node:os');
+var auth = require('./auth-BIleVCw0.cjs');
+require('zod');
+require('node:crypto');
+require('chalk');
+require('fs');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-Cc08m7of.cjs');
+require('open');
+require('react');
+require('ink');
+
+const POLL_INTERVAL_MS = 2e3;
+const POLL_TIMEOUT_MS = 10 * 60 * 1e3;
+function deviceKeysFile() {
+  return path.join(logger.configuration.happyHomeDir, "device-keys.json");
+}
+async function readDeviceKeys() {
+  const file = deviceKeysFile();
+  if (!fs.existsSync(file)) return {};
+  try {
+    const parsed = JSON.parse(await promises.readFile(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeDeviceDirectory(entries) {
+  const file = deviceKeysFile();
+  await promises.mkdir(path.dirname(file), { recursive: true });
+  const keys = await readDeviceKeys();
+  for (const entry of entries) {
+    keys[entry.id] = { name: entry.name, key: entry.key, variant: entry.variant ?? "dataKey" };
+  }
+  await promises.writeFile(file, JSON.stringify(keys, null, 2), { mode: 384 });
+}
+async function readCachedDeviceKey(machineId) {
+  const keys = await readDeviceKeys();
+  const stored = keys[machineId];
+  if (!stored?.key) return null;
+  return { key: logger.decodeBase64(stored.key), variant: stored.variant ?? "dataKey" };
+}
+async function readCachedDeviceNames() {
+  const keys = await readDeviceKeys();
+  return Object.fromEntries(Object.entries(keys).map(([id, entry]) => [id, entry.name]));
+}
+async function ensureDeviceKey(credentials, machineId, onPending) {
+  const cached = await readCachedDeviceKey(machineId);
+  if (cached) return cached;
+  const seed = tweetnacl.randomBytes(32);
+  const secretKey = tweetnacl.hash(seed).slice(0, 32);
+  const publicKey = tweetnacl.box.keyPair.fromSecretKey(secretKey).publicKey;
+  const created = await axios.post(
+    `${logger.configuration.serverUrl}/v1/devices/key-requests`,
+    { machineId, publicKey: logger.encodeBase64(publicKey), label: `happy ssh from ${os.hostname()}` },
+    { headers: { Authorization: `Bearer ${credentials.token}` }, timeout: 15e3 }
+  );
+  onPending?.({ id: created.data.id });
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    const status = await axios.get(
+      `${logger.configuration.serverUrl}/v1/devices/key-requests/${created.data.id}`,
+      { headers: { Authorization: `Bearer ${credentials.token}` }, timeout: 15e3 }
+    );
+    if (status.data.expired) {
+      throw new Error("Authorization request expired. Run the command again.");
+    }
+    if (status.data.approved && status.data.response) {
+      const opened = auth.decryptWithEphemeralKey(logger.decodeBase64(status.data.response), secretKey);
+      if (!opened) {
+        throw new Error("Could not open the device directory returned by the app");
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(Buffer.from(opened).toString("utf8"));
+      } catch {
+        throw new Error("Device directory from the app was malformed");
+      }
+      const devices = parsed.devices ?? [];
+      if (devices.length === 0) {
+        throw new Error("The app returned an empty device directory");
+      }
+      await writeDeviceDirectory(devices);
+      const target = devices.find((device) => device.id === machineId);
+      if (!target) {
+        throw new Error("The app did not include this device in the directory");
+      }
+      return { key: logger.decodeBase64(target.key), variant: target.variant ?? "dataKey" };
+    }
+  }
+  throw new Error("Timed out waiting for approval in the Happy app");
+}
+
+function matchDevice(devices, query) {
+  const lowered = query.trim().toLowerCase();
+  return devices.find((device) => device.id === query) ?? devices.find((device) => device.name.toLowerCase() === lowered) ?? devices.find((device) => device.name.toLowerCase().startsWith(lowered)) ?? devices.find((device) => device.name.toLowerCase().includes(lowered)) ?? null;
+}
+const DEFAULT_COMMAND_TIMEOUT_MS = 3e5;
+function parseSshArgs(args) {
+  const separator = args.indexOf("--");
+  const head = separator >= 0 ? args.slice(0, separator) : args;
+  const command = separator >= 0 ? args.slice(separator + 1).join(" ") : null;
+  let target = null;
+  let timeoutMs = DEFAULT_COMMAND_TIMEOUT_MS;
+  for (let i = 0; i < head.length; i++) {
+    if (head[i] === "--timeout" || head[i] === "-t") {
+      const seconds = Number(head[++i]);
+      if (Number.isFinite(seconds) && seconds > 0) timeoutMs = seconds * 1e3;
+      continue;
+    }
+    if (!target && !head[i].startsWith("-")) target = head[i];
+  }
+  return { target, command: command && command.trim() ? command : null, timeoutMs };
+}
+async function runOnDevice(credentials, query, command, options = {}) {
+  const { devices } = await listDevicesWithNames(credentials);
+  const device = matchDevice(devices, query);
+  if (!device) {
+    console.error(`No enrolled device matches "${query}". Run "happy ssh" with no arguments to list devices.`);
+    return 1;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return 1;
+  }
+  const { key, variant } = await ensureDeviceKey(credentials, device.id, () => {
+    console.error("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  const socket = socket_ioClient.io(logger.configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  try {
+    const result = await deviceExec.deviceExec(socket, credentials, device.id, command, {
+      deviceKeyBase64: logger.encodeBase64(key),
+      deviceKeyVariant: variant,
+      timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
+      // matchDevice already read the listing and rejected offline devices.
+      skipMachineLookup: true
+    });
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    if (result.error && !result.error.startsWith("Command failed:")) {
+      console.error(result.error);
+    }
+    return result.exitCode ?? (result.success ? 0 : 1);
+  } finally {
+    socket.close();
+  }
+}
+async function sshDevice(credentials, query) {
+  const { devices } = await listDevicesWithNames(credentials);
+  const device = matchDevice(devices, query);
+  if (!device) {
+    console.error(`No enrolled device matches "${query}". Run "happy ssh" with no arguments to list devices.`);
+    return 1;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return 1;
+  }
+  const { key, variant } = await ensureDeviceKey(credentials, device.id, () => {
+    console.log("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  const socket = socket_ioClient.io(logger.configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  const rpc = async (method, params) => {
+    const answer = await socket.timeout(3e4).emitWithAck("rpc-call", {
+      method: `${device.id}:${method}`,
+      params: logger.encodeBase64(logger.encrypt(key, variant, params))
+    });
+    if (!answer?.ok) throw new Error(answer?.error || `${method} failed`);
+    return logger.decrypt(key, variant, logger.decodeBase64(answer.result));
+  };
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const started = await rpc("pty-start", { cols, rows });
+  if (!started?.ok || !started.ptyId) {
+    socket.close();
+    console.error(`Could not open a shell on "${device.name}": ${started?.error ?? "unknown error"}`);
+    return 1;
+  }
+  const ptyId = started.ptyId;
+  let exitCode = 0;
+  const cleanup = () => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+    socket.close();
+  };
+  await new Promise((resolve) => {
+    socket.on("pty-output", (envelope) => {
+      if (envelope?.sessionId !== device.id || envelope?.ptyId !== ptyId) return;
+      try {
+        const data = logger.decrypt(key, variant, logger.decodeBase64(envelope.data));
+        if (typeof data === "string") process.stdout.write(Buffer.from(data, "base64"));
+      } catch {
+      }
+    });
+    socket.on("pty-exit", (envelope) => {
+      if (envelope?.sessionId !== device.id || envelope?.ptyId !== ptyId) return;
+      exitCode = typeof envelope.exitCode === "number" ? envelope.exitCode : 0;
+      resolve();
+    });
+    socket.on("disconnect", () => resolve());
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => {
+      socket.volatile.emit("pty-input", {
+        sessionId: device.id,
+        ptyId,
+        data: logger.encodeBase64(logger.encrypt(key, variant, chunk.toString("utf8")))
+      });
+    });
+    process.stdout.on("resize", () => {
+      void rpc("pty-resize", {
+        ptyId,
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      }).catch(() => {
+      });
+    });
+  });
+  await rpc("pty-close", { ptyId }).catch(() => {
+  });
+  cleanup();
+  return exitCode;
+}
+function pickDevice(devices) {
+  const selectable = devices.filter((device) => device.active);
+  if (selectable.length === 0) {
+    console.log("No devices are online right now.");
+    return Promise.resolve(null);
+  }
+  if (selectable.length === 1) {
+    return Promise.resolve(selectable[0]);
+  }
+  return new Promise((resolve) => {
+    let index = 0;
+    let rendered = 0;
+    const render = () => {
+      if (rendered > 0) process.stdout.write(`\x1B[${rendered}A`);
+      const lines = selectable.map((device, position) => {
+        const marker = position === index ? "\x1B[36m>\x1B[0m" : " ";
+        const name = position === index ? `\x1B[1m${device.name}\x1B[0m` : device.name;
+        return `\x1B[2K ${marker} ${name}${device.platform ? `  \x1B[2m${device.platform}\x1B[0m` : ""}`;
+      });
+      process.stdout.write(lines.join("\n") + "\n");
+      rendered = lines.length;
+    };
+    const finish = (device) => {
+      process.stdin.off("data", onData);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      resolve(device);
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString();
+      if (key === "\x1B[A" || key === "k") {
+        index = (index - 1 + selectable.length) % selectable.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        index = (index + 1) % selectable.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        finish(selectable[index]);
+      } else if (key === "" || key === "\x1B" || key === "q") {
+        console.log("Cancelled.");
+        finish(null);
+      }
+    };
+    console.log("Select a device (\u2191/\u2193, Enter to connect, q to cancel):");
+    render();
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function listDevicesWithNames(credentials) {
+  const [devices, names] = await Promise.all([deviceExec.listDevices(credentials), readCachedDeviceNames()]);
+  let named = false;
+  const withNames = devices.map((device) => {
+    const cached = names[device.id];
+    if (cached) named = true;
+    return cached ? { ...device, name: cached } : device;
+  });
+  return { devices: withNames, named };
+}
+async function sshPickAndConnect(credentials) {
+  const { devices } = await listDevicesWithNames(credentials);
+  if (devices.length === 0) {
+    console.log("No devices enrolled yet. Add one from Happy \u2192 Devices.");
+    return 0;
+  }
+  if (!process.stdin.isTTY) {
+    for (const device of devices) {
+      console.log(`${device.active ? "online " : "offline"}  ${device.name}${device.platform ? `  (${device.platform})` : ""}`);
+    }
+    console.log("\nUsage: happy ssh <device>");
+    return 0;
+  }
+  const chosen = await pickDevice(devices);
+  if (!chosen) return 0;
+  return await sshDevice(credentials, chosen.id);
+}
+
+exports.parseSshArgs = parseSshArgs;
+exports.runOnDevice = runOnDevice;
+exports.sshDevice = sshDevice;
+exports.sshPickAndConnect = sshPickAndConnect;

package/dist/ssh-DL_AkRAD.mjs

@@ -0,0 +1,328 @@
+import { io } from 'socket.io-client';
+import { c as configuration, f as encodeBase64, e as decodeBase64, h as decrypt, g as encrypt } from './persistence-BFjvtUad.mjs';
+import { d as deviceExec, l as listDevices } from './deviceExec-D93AOVV4.mjs';
+import axios from 'axios';
+import tweetnacl from 'tweetnacl';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { hostname } from 'node:os';
+import { decryptWithEphemeralKey } from './auth-BE8dD20T.mjs';
+import 'zod';
+import 'node:crypto';
+import 'chalk';
+import 'fs';
+import 'qrcode-terminal';
+import './time-DgsBLJA_.mjs';
+import './browser-Dll5hxOV.mjs';
+import 'open';
+import 'react';
+import 'ink';
+
+const POLL_INTERVAL_MS = 2e3;
+const POLL_TIMEOUT_MS = 10 * 60 * 1e3;
+function deviceKeysFile() {
+  return join(configuration.happyHomeDir, "device-keys.json");
+}
+async function readDeviceKeys() {
+  const file = deviceKeysFile();
+  if (!existsSync(file)) return {};
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function writeDeviceDirectory(entries) {
+  const file = deviceKeysFile();
+  await mkdir(dirname(file), { recursive: true });
+  const keys = await readDeviceKeys();
+  for (const entry of entries) {
+    keys[entry.id] = { name: entry.name, key: entry.key, variant: entry.variant ?? "dataKey" };
+  }
+  await writeFile(file, JSON.stringify(keys, null, 2), { mode: 384 });
+}
+async function readCachedDeviceKey(machineId) {
+  const keys = await readDeviceKeys();
+  const stored = keys[machineId];
+  if (!stored?.key) return null;
+  return { key: decodeBase64(stored.key), variant: stored.variant ?? "dataKey" };
+}
+async function readCachedDeviceNames() {
+  const keys = await readDeviceKeys();
+  return Object.fromEntries(Object.entries(keys).map(([id, entry]) => [id, entry.name]));
+}
+async function ensureDeviceKey(credentials, machineId, onPending) {
+  const cached = await readCachedDeviceKey(machineId);
+  if (cached) return cached;
+  const seed = tweetnacl.randomBytes(32);
+  const secretKey = tweetnacl.hash(seed).slice(0, 32);
+  const publicKey = tweetnacl.box.keyPair.fromSecretKey(secretKey).publicKey;
+  const created = await axios.post(
+    `${configuration.serverUrl}/v1/devices/key-requests`,
+    { machineId, publicKey: encodeBase64(publicKey), label: `happy ssh from ${hostname()}` },
+    { headers: { Authorization: `Bearer ${credentials.token}` }, timeout: 15e3 }
+  );
+  onPending?.({ id: created.data.id });
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    const status = await axios.get(
+      `${configuration.serverUrl}/v1/devices/key-requests/${created.data.id}`,
+      { headers: { Authorization: `Bearer ${credentials.token}` }, timeout: 15e3 }
+    );
+    if (status.data.expired) {
+      throw new Error("Authorization request expired. Run the command again.");
+    }
+    if (status.data.approved && status.data.response) {
+      const opened = decryptWithEphemeralKey(decodeBase64(status.data.response), secretKey);
+      if (!opened) {
+        throw new Error("Could not open the device directory returned by the app");
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(Buffer.from(opened).toString("utf8"));
+      } catch {
+        throw new Error("Device directory from the app was malformed");
+      }
+      const devices = parsed.devices ?? [];
+      if (devices.length === 0) {
+        throw new Error("The app returned an empty device directory");
+      }
+      await writeDeviceDirectory(devices);
+      const target = devices.find((device) => device.id === machineId);
+      if (!target) {
+        throw new Error("The app did not include this device in the directory");
+      }
+      return { key: decodeBase64(target.key), variant: target.variant ?? "dataKey" };
+    }
+  }
+  throw new Error("Timed out waiting for approval in the Happy app");
+}
+
+function matchDevice(devices, query) {
+  const lowered = query.trim().toLowerCase();
+  return devices.find((device) => device.id === query) ?? devices.find((device) => device.name.toLowerCase() === lowered) ?? devices.find((device) => device.name.toLowerCase().startsWith(lowered)) ?? devices.find((device) => device.name.toLowerCase().includes(lowered)) ?? null;
+}
+const DEFAULT_COMMAND_TIMEOUT_MS = 3e5;
+function parseSshArgs(args) {
+  const separator = args.indexOf("--");
+  const head = separator >= 0 ? args.slice(0, separator) : args;
+  const command = separator >= 0 ? args.slice(separator + 1).join(" ") : null;
+  let target = null;
+  let timeoutMs = DEFAULT_COMMAND_TIMEOUT_MS;
+  for (let i = 0; i < head.length; i++) {
+    if (head[i] === "--timeout" || head[i] === "-t") {
+      const seconds = Number(head[++i]);
+      if (Number.isFinite(seconds) && seconds > 0) timeoutMs = seconds * 1e3;
+      continue;
+    }
+    if (!target && !head[i].startsWith("-")) target = head[i];
+  }
+  return { target, command: command && command.trim() ? command : null, timeoutMs };
+}
+async function runOnDevice(credentials, query, command, options = {}) {
+  const { devices } = await listDevicesWithNames(credentials);
+  const device = matchDevice(devices, query);
+  if (!device) {
+    console.error(`No enrolled device matches "${query}". Run "happy ssh" with no arguments to list devices.`);
+    return 1;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return 1;
+  }
+  const { key, variant } = await ensureDeviceKey(credentials, device.id, () => {
+    console.error("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  const socket = io(configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  try {
+    const result = await deviceExec(socket, credentials, device.id, command, {
+      deviceKeyBase64: encodeBase64(key),
+      deviceKeyVariant: variant,
+      timeout: options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS,
+      // matchDevice already read the listing and rejected offline devices.
+      skipMachineLookup: true
+    });
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    if (result.error && !result.error.startsWith("Command failed:")) {
+      console.error(result.error);
+    }
+    return result.exitCode ?? (result.success ? 0 : 1);
+  } finally {
+    socket.close();
+  }
+}
+async function sshDevice(credentials, query) {
+  const { devices } = await listDevicesWithNames(credentials);
+  const device = matchDevice(devices, query);
+  if (!device) {
+    console.error(`No enrolled device matches "${query}". Run "happy ssh" with no arguments to list devices.`);
+    return 1;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return 1;
+  }
+  const { key, variant } = await ensureDeviceKey(credentials, device.id, () => {
+    console.log("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  const socket = io(configuration.serverUrl, {
+    auth: { token: credentials.token, clientType: "user-scoped" },
+    path: "/v1/updates",
+    transports: ["websocket"]
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("connect", () => resolve());
+    socket.once("connect_error", reject);
+  });
+  const rpc = async (method, params) => {
+    const answer = await socket.timeout(3e4).emitWithAck("rpc-call", {
+      method: `${device.id}:${method}`,
+      params: encodeBase64(encrypt(key, variant, params))
+    });
+    if (!answer?.ok) throw new Error(answer?.error || `${method} failed`);
+    return decrypt(key, variant, decodeBase64(answer.result));
+  };
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const started = await rpc("pty-start", { cols, rows });
+  if (!started?.ok || !started.ptyId) {
+    socket.close();
+    console.error(`Could not open a shell on "${device.name}": ${started?.error ?? "unknown error"}`);
+    return 1;
+  }
+  const ptyId = started.ptyId;
+  let exitCode = 0;
+  const cleanup = () => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+    socket.close();
+  };
+  await new Promise((resolve) => {
+    socket.on("pty-output", (envelope) => {
+      if (envelope?.sessionId !== device.id || envelope?.ptyId !== ptyId) return;
+      try {
+        const data = decrypt(key, variant, decodeBase64(envelope.data));
+        if (typeof data === "string") process.stdout.write(Buffer.from(data, "base64"));
+      } catch {
+      }
+    });
+    socket.on("pty-exit", (envelope) => {
+      if (envelope?.sessionId !== device.id || envelope?.ptyId !== ptyId) return;
+      exitCode = typeof envelope.exitCode === "number" ? envelope.exitCode : 0;
+      resolve();
+    });
+    socket.on("disconnect", () => resolve());
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => {
+      socket.volatile.emit("pty-input", {
+        sessionId: device.id,
+        ptyId,
+        data: encodeBase64(encrypt(key, variant, chunk.toString("utf8")))
+      });
+    });
+    process.stdout.on("resize", () => {
+      void rpc("pty-resize", {
+        ptyId,
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      }).catch(() => {
+      });
+    });
+  });
+  await rpc("pty-close", { ptyId }).catch(() => {
+  });
+  cleanup();
+  return exitCode;
+}
+function pickDevice(devices) {
+  const selectable = devices.filter((device) => device.active);
+  if (selectable.length === 0) {
+    console.log("No devices are online right now.");
+    return Promise.resolve(null);
+  }
+  if (selectable.length === 1) {
+    return Promise.resolve(selectable[0]);
+  }
+  return new Promise((resolve) => {
+    let index = 0;
+    let rendered = 0;
+    const render = () => {
+      if (rendered > 0) process.stdout.write(`\x1B[${rendered}A`);
+      const lines = selectable.map((device, position) => {
+        const marker = position === index ? "\x1B[36m>\x1B[0m" : " ";
+        const name = position === index ? `\x1B[1m${device.name}\x1B[0m` : device.name;
+        return `\x1B[2K ${marker} ${name}${device.platform ? `  \x1B[2m${device.platform}\x1B[0m` : ""}`;
+      });
+      process.stdout.write(lines.join("\n") + "\n");
+      rendered = lines.length;
+    };
+    const finish = (device) => {
+      process.stdin.off("data", onData);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      resolve(device);
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString();
+      if (key === "\x1B[A" || key === "k") {
+        index = (index - 1 + selectable.length) % selectable.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        index = (index + 1) % selectable.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        finish(selectable[index]);
+      } else if (key === "" || key === "\x1B" || key === "q") {
+        console.log("Cancelled.");
+        finish(null);
+      }
+    };
+    console.log("Select a device (\u2191/\u2193, Enter to connect, q to cancel):");
+    render();
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function listDevicesWithNames(credentials) {
+  const [devices, names] = await Promise.all([listDevices(credentials), readCachedDeviceNames()]);
+  let named = false;
+  const withNames = devices.map((device) => {
+    const cached = names[device.id];
+    if (cached) named = true;
+    return cached ? { ...device, name: cached } : device;
+  });
+  return { devices: withNames, named };
+}
+async function sshPickAndConnect(credentials) {
+  const { devices } = await listDevicesWithNames(credentials);
+  if (devices.length === 0) {
+    console.log("No devices enrolled yet. Add one from Happy \u2192 Devices.");
+    return 0;
+  }
+  if (!process.stdin.isTTY) {
+    for (const device of devices) {
+      console.log(`${device.active ? "online " : "offline"}  ${device.name}${device.platform ? `  (${device.platform})` : ""}`);
+    }
+    console.log("\nUsage: happy ssh <device>");
+    return 0;
+  }
+  const chosen = await pickDevice(devices);
+  if (!chosen) return 0;
+  return await sshDevice(credentials, chosen.id);
+}
+
+export { parseSshArgs, runOnDevice, sshDevice, sshPickAndConnect };

package/dist/systemdScope-BeOtAkhk.mjs

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import os from 'node:os';
+
+const SERVICE_NAME = "happy-daemon.service";
+function systemdScopeFor(isRoot) {
+  if (isRoot) {
+    return {
+      system: true,
+      unitPath: join("/etc/systemd/system", SERVICE_NAME),
+      systemctlFlag: "",
+      wantedBy: "multi-user.target"
+    };
+  }
+  return {
+    system: false,
+    unitPath: join(os.homedir(), ".config", "systemd", "user", SERVICE_NAME),
+    systemctlFlag: "--user",
+    wantedBy: "default.target"
+  };
+}
+function isRootUser() {
+  return typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+export { SERVICE_NAME as S, isRootUser as i, systemdScopeFor as s };