@zonease/happy 0.6.38 → 0.6.40

package/dist/ssh-q5uZhqBf.mjs

@@ -0,0 +1,359 @@
+import { io } from 'socket.io-client';
+import { c as configuration, e as decrypt, f as decodeBase64, g as encodeBase64, h as encrypt } from './persistence-DKfF81pd.mjs';
+import { e as ensureDeviceKey, l as listDevices, r as readCachedDeviceNames, a as readCachedDeviceKey, p as pruneDeviceAliases, d as deviceExec } from './deviceKeys-BTdo34Uz.mjs';
+import { execOnDeviceViaDaemon } from './controlClient-DB5tDU7V.mjs';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'chalk';
+import 'fs';
+import 'axios';
+import './auth-DxJ3VvrX.mjs';
+import 'qrcode-terminal';
+import './time-DgsBLJA_.mjs';
+import './browser-AoVGRX7y.mjs';
+import 'open';
+import 'react';
+import 'ink';
+import './projectPath-BTBIMB57.mjs';
+import 'path';
+import 'url';
+
+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;
+  let stream = false;
+  for (let i = 0; i < head.length; i++) {
+    if (head[i] === "--stream" || head[i] === "-s") {
+      stream = true;
+      continue;
+    }
+    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, stream };
+}
+async function resolveFromCache(query) {
+  const names = await readCachedDeviceNames();
+  const id = pickCachedDeviceId(names, query);
+  if (!id) return null;
+  const material = await readCachedDeviceKey(id);
+  return material ? { device: { id, name: names[id] }, ...material } : null;
+}
+function pickCachedDeviceId(names, query) {
+  if (names[query]) return query;
+  const lowered = query.trim().toLowerCase();
+  for (const test of [
+    (name) => name === lowered,
+    (name) => name.startsWith(lowered),
+    (name) => name.includes(lowered)
+  ]) {
+    const matches = Object.keys(names).filter((id) => test(names[id].toLowerCase()));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) return null;
+  }
+  return null;
+}
+async function resolveFromServer(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 null;
+  }
+  if (!device.active) {
+    console.error(`Device "${device.name}" is offline.`);
+    return null;
+  }
+  const { key, variant } = await ensureDeviceKey(credentials, device.id, () => {
+    console.error("Waiting for approval in the Happy app (Devices \u2192 pending request)...");
+  });
+  await pruneDeviceAliases(device.id, device.name);
+  return { device, key, variant };
+}
+async function runOnDevice(credentials, query, command, options = {}) {
+  const cached = await resolveFromCache(query);
+  const resolved = cached ?? await resolveFromServer(credentials, query);
+  if (!resolved) return 1;
+  if (options.stream) {
+    return await streamOnResolved(credentials, resolved, command, options);
+  }
+  const viaDaemon = await execOnDeviceViaDaemon(
+    resolved.device.id,
+    command,
+    options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS
+  ).catch(() => null);
+  if (viaDaemon) {
+    return reportResult(viaDaemon);
+  }
+  try {
+    return await execOnResolved(credentials, resolved, command, options);
+  } catch (error) {
+    if (!cached) throw error;
+    const fresh = await resolveFromServer(credentials, query);
+    if (!fresh) return 1;
+    return await execOnResolved(credentials, fresh, command, options);
+  }
+}
+function reportResult(result) {
+  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);
+}
+async function streamOnResolved(credentials, { device, key, variant }, command, options) {
+  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 timeoutMs = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+  try {
+    const answer = await socket.timeout(3e4).emitWithAck("rpc-call", {
+      method: `${device.id}:pty-start`,
+      params: encodeBase64(encrypt(key, variant, {
+        cols: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+        exec: { command, timeoutMs }
+      }))
+    });
+    if (!answer?.ok) throw new Error(answer?.error || "pty-start failed");
+    const started = decrypt(key, variant, decodeBase64(answer.result));
+    if (!started?.ok || !started.ptyId) {
+      throw new Error(started?.error ?? "Device refused to start the command");
+    }
+    return await new Promise((resolve) => {
+      const execId = started.ptyId;
+      const guard = setTimeout(() => resolve(1), timeoutMs + 3e4);
+      socket.on("pty-output", (envelope) => {
+        if (envelope?.sessionId !== device.id || envelope?.ptyId !== execId) return;
+        try {
+          const frame = decrypt(key, variant, decodeBase64(envelope.data));
+          if (typeof frame?.chunk !== "string") return;
+          const target = frame.stream === "stderr" ? process.stderr : process.stdout;
+          target.write(Buffer.from(frame.chunk, "base64"));
+        } catch {
+        }
+      });
+      socket.on("pty-exit", (envelope) => {
+        if (envelope?.sessionId !== device.id || envelope?.ptyId !== execId) return;
+        clearTimeout(guard);
+        resolve(typeof envelope.exitCode === "number" ? envelope.exitCode : 1);
+      });
+      socket.on("disconnect", () => {
+        clearTimeout(guard);
+        resolve(1);
+      });
+    });
+  } finally {
+    socket.close();
+  }
+}
+async function execOnResolved(credentials, { device, key, variant }, command, options) {
+  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
+    });
+    return reportResult(result);
+  } 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, pickCachedDeviceId, runOnDevice, sshDevice, sshPickAndConnect };