@zonease/happy 0.6.38 → 0.6.39

package/dist/auth-0VnlXT9f.mjs

@@ -0,0 +1,181 @@
+import chalk from 'chalk';
+import { r as readCredentials, a as readSettings, c as configuration, l as logger, b as clearCredentials, d as clearMachineId } from './persistence-BFjvtUad.mjs';
+import { authAndSetupMachineIfNeeded } from './auth-BE8dD20T.mjs';
+import { existsSync, rmSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { checkIfDaemonRunningAndCleanupStaleState, stopDaemon } from './controlClient-CM_QcJnB.mjs';
+import os from 'node:os';
+import 'node:fs/promises';
+import 'node:path';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'fs';
+import 'axios';
+import 'qrcode-terminal';
+import './time-DgsBLJA_.mjs';
+import './browser-Dll5hxOV.mjs';
+import 'open';
+import 'react';
+import 'ink';
+import './projectPath-BTBIMB57.mjs';
+import 'path';
+import 'url';
+
+async function handleAuthCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    showAuthHelp();
+    return;
+  }
+  switch (subcommand) {
+    case "login":
+      await handleAuthLogin(args.slice(1));
+      break;
+    case "logout":
+      await handleAuthLogout();
+      break;
+    case "status":
+      await handleAuthStatus();
+      break;
+    default:
+      console.error(chalk.red(`Unknown auth subcommand: ${subcommand}`));
+      showAuthHelp();
+      process.exit(1);
+  }
+}
+function showAuthHelp() {
+  console.log(`
+${chalk.bold("happy auth")} - Authentication management
+
+${chalk.bold("Usage:")}
+  happy auth login [--force]    Authenticate with Happy
+  happy auth logout             Remove authentication and machine data
+  happy auth status             Show authentication status
+  happy auth help               Show this help message
+
+${chalk.bold("Options:")}
+  --force    Clear credentials, machine ID, and stop daemon before re-auth
+
+${chalk.gray("PS: Your master secret never leaves your mobile/web device. Each CLI machine")}
+${chalk.gray("receives only a derived key for per-machine encryption, so backup codes")}
+${chalk.gray("cannot be displayed from the CLI.")}
+`);
+}
+async function handleAuthLogin(args) {
+  const forceAuth = args.includes("--force") || args.includes("-f");
+  if (forceAuth) {
+    console.log(chalk.yellow("Force authentication requested."));
+    console.log(chalk.gray("This will:"));
+    console.log(chalk.gray("  \u2022 Clear existing credentials"));
+    console.log(chalk.gray("  \u2022 Clear machine ID"));
+    console.log(chalk.gray("  \u2022 Stop daemon if running"));
+    console.log(chalk.gray("  \u2022 Re-authenticate and register machine\n"));
+    try {
+      logger.debug("Stopping daemon for force auth...");
+      await stopDaemon();
+      console.log(chalk.gray("\u2713 Stopped daemon"));
+    } catch (error) {
+      logger.debug("Daemon was not running or failed to stop:", error);
+    }
+    await clearCredentials();
+    console.log(chalk.gray("\u2713 Cleared credentials"));
+    await clearMachineId();
+    console.log(chalk.gray("\u2713 Cleared machine ID"));
+    console.log("");
+  }
+  if (!forceAuth) {
+    const existingCreds = await readCredentials();
+    const settings = await readSettings();
+    if (existingCreds && settings?.machineId) {
+      console.log(chalk.green("\u2713 Already authenticated"));
+      console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
+      console.log(chalk.gray(`  Host: ${os.hostname()}`));
+      console.log(chalk.gray(`  Use 'happy auth login --force' to re-authenticate`));
+      return;
+    } else if (existingCreds && !settings?.machineId) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Credentials exist but machine ID is missing"));
+      console.log(chalk.gray("  This can happen if --auth flag was used previously"));
+      console.log(chalk.gray("  Fixing by setting up machine...\n"));
+    }
+  }
+  try {
+    const result = await authAndSetupMachineIfNeeded();
+    console.log(chalk.green("\n\u2713 Authentication successful"));
+    console.log(chalk.gray(`  Machine ID: ${result.machineId}`));
+  } catch (error) {
+    console.error(chalk.red("Authentication failed:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function handleAuthLogout() {
+  const happyDir = configuration.happyHomeDir;
+  const credentials = await readCredentials();
+  if (!credentials) {
+    console.log(chalk.yellow("Not currently authenticated"));
+    return;
+  }
+  console.log(chalk.blue("This will log you out of Happy"));
+  console.log(chalk.yellow("\u26A0\uFE0F  You will need to re-authenticate to use Happy again"));
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await new Promise((resolve) => {
+    rl.question(chalk.yellow("Are you sure you want to log out? (y/N): "), resolve);
+  });
+  rl.close();
+  if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+    try {
+      try {
+        await stopDaemon();
+        console.log(chalk.gray("Stopped daemon"));
+      } catch {
+      }
+      if (existsSync(happyDir)) {
+        rmSync(happyDir, { recursive: true, force: true });
+      }
+      console.log(chalk.green("\u2713 Successfully logged out"));
+      console.log(chalk.gray('  Run "happy auth login" to authenticate again'));
+    } catch (error) {
+      throw new Error(`Failed to logout: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else {
+    console.log(chalk.blue("Logout cancelled"));
+  }
+}
+async function handleAuthStatus() {
+  const credentials = await readCredentials();
+  const settings = await readSettings();
+  console.log(chalk.bold("\nAuthentication Status\n"));
+  if (!credentials) {
+    console.log(chalk.red("\u2717 Not authenticated"));
+    console.log(chalk.gray('  Run "happy auth login" to authenticate'));
+    return;
+  }
+  console.log(chalk.green("\u2713 Authenticated"));
+  const tokenPreview = credentials.token.substring(0, 30) + "...";
+  console.log(chalk.gray(`  Token: ${tokenPreview}`));
+  if (settings?.machineId) {
+    console.log(chalk.green("\u2713 Machine registered"));
+    console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
+    console.log(chalk.gray(`  Host: ${os.hostname()}`));
+  } else {
+    console.log(chalk.yellow("\u26A0\uFE0F  Machine not registered"));
+    console.log(chalk.gray('  Run "happy auth login --force" to fix this'));
+  }
+  console.log(chalk.gray(`
+  Data directory: ${configuration.happyHomeDir}`));
+  try {
+    const running = await checkIfDaemonRunningAndCleanupStaleState();
+    if (running) {
+      console.log(chalk.green("\u2713 Daemon running"));
+    } else {
+      console.log(chalk.gray("\u2717 Daemon not running"));
+    }
+  } catch {
+    console.log(chalk.gray("\u2717 Daemon not running"));
+  }
+}
+
+export { handleAuthCommand };

package/dist/auth-BE8dD20T.mjs

@@ -0,0 +1,270 @@
+import { f as encodeBase64, c as configuration, l as logger, r as readCredentials, u as updateSettings, i as isDebug, s as encodeBase64Url, e as decodeBase64, t as writeCredentialsLegacy, w as writeCredentialsDataKey } from './persistence-BFjvtUad.mjs';
+import { randomBytes, randomUUID } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import axios from 'axios';
+import qrcode from 'qrcode-terminal';
+import { d as delay } from './time-DgsBLJA_.mjs';
+import { o as openBrowser } from './browser-Dll5hxOV.mjs';
+import React, { useState } from 'react';
+import { useInput, Box, Text, render } from 'ink';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'zod';
+import 'chalk';
+import 'fs';
+import 'open';
+
+function displayQRCode(url) {
+  console.log("=".repeat(80));
+  console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
+  console.log("=".repeat(80));
+  qrcode.generate(url, { small: true }, (qr) => {
+    for (let l of qr.split("\n")) {
+      console.log(" ".repeat(10) + l);
+    }
+  });
+  console.log("=".repeat(80));
+}
+
+function generateWebAuthUrl(publicKey) {
+  const publicKeyBase64 = encodeBase64(publicKey, "base64url");
+  return `${configuration.webappUrl}/terminal/connect#key=${publicKeyBase64}`;
+}
+
+const AuthSelector = ({ onSelect, onCancel }) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const options = [
+    {
+      method: "mobile",
+      label: "Mobile App"
+    },
+    {
+      method: "web",
+      label: "Web Browser"
+    }
+  ];
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(options.length - 1, prev + 1));
+    } else if (key.return) {
+      onSelect(options[selectedIndex].method);
+    } else if (key.escape || key.ctrl && input === "c") {
+      onCancel();
+    } else if (input === "1") {
+      setSelectedIndex(0);
+      onSelect("mobile");
+    } else if (input === "2") {
+      setSelectedIndex(1);
+      onSelect("web");
+    }
+  });
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingY: 1 }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "How would you like to authenticate?")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => {
+    const isSelected = selectedIndex === index;
+    return /* @__PURE__ */ React.createElement(Box, { key: option.method, marginY: 0 }, /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "cyan" : "gray" }, isSelected ? "\u203A " : "  ", index + 1, ". ", option.label));
+  })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Use arrows or 1-2 to select, Enter to confirm")));
+};
+
+async function doAuth() {
+  console.clear();
+  const authMethod = await selectAuthenticationMethod();
+  if (!authMethod) {
+    console.log("\nAuthentication cancelled.\n");
+    process.exit(0);
+  }
+  const secret = new Uint8Array(randomBytes(32));
+  const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
+  try {
+    if (isDebug()) {
+      console.log(`[AUTH DEBUG] Sending auth request to: ${configuration.serverUrl}/v1/auth/request`);
+      console.log(`[AUTH DEBUG] Public key: ${encodeBase64(keypair.publicKey).substring(0, 20)}...`);
+    }
+    await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
+      publicKey: encodeBase64(keypair.publicKey),
+      supportsV2: true
+    });
+    if (isDebug()) {
+      console.log(`[AUTH DEBUG] Auth request sent successfully`);
+    }
+  } catch (error) {
+    if (isDebug()) {
+      console.log(`[AUTH DEBUG] Failed to send auth request:`, error);
+    }
+    console.log("Failed to create authentication request, please try again later.");
+    return null;
+  }
+  if (authMethod === "mobile") {
+    return await doMobileAuth(keypair);
+  } else {
+    return await doWebAuth(keypair);
+  }
+}
+function selectAuthenticationMethod() {
+  return new Promise((resolve) => {
+    let hasResolved = false;
+    const onSelect = (method) => {
+      if (!hasResolved) {
+        hasResolved = true;
+        app.unmount();
+        resolve(method);
+      }
+    };
+    const onCancel = () => {
+      if (!hasResolved) {
+        hasResolved = true;
+        app.unmount();
+        resolve(null);
+      }
+    };
+    const app = render(React.createElement(AuthSelector, { onSelect, onCancel }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  });
+}
+async function doMobileAuth(keypair) {
+  console.clear();
+  console.log("\nMobile Authentication\n");
+  console.log("Scan this QR code with your Happy mobile app:\n");
+  const authUrl = "happy://terminal?" + encodeBase64Url(keypair.publicKey);
+  displayQRCode(authUrl);
+  console.log("\nOr manually enter this URL:");
+  console.log(authUrl);
+  console.log("");
+  return await waitForAuthentication(keypair);
+}
+async function doWebAuth(keypair) {
+  console.clear();
+  console.log("\nWeb Authentication\n");
+  const webUrl = generateWebAuthUrl(keypair.publicKey);
+  console.log("Opening your browser...");
+  const browserOpened = await openBrowser(webUrl);
+  if (browserOpened) {
+    console.log("\u2713 Browser opened\n");
+    console.log("Complete authentication in your browser window.");
+  } else {
+    console.log("Could not open browser automatically.");
+  }
+  console.log("\nIf the browser did not open, please copy and paste this URL:");
+  console.log(webUrl);
+  console.log("");
+  return await waitForAuthentication(keypair);
+}
+async function waitForAuthentication(keypair) {
+  process.stdout.write("Waiting for authentication");
+  let dots = 0;
+  let cancelled = false;
+  const handleInterrupt = () => {
+    cancelled = true;
+    console.log("\n\nAuthentication cancelled.");
+    process.exit(0);
+  };
+  process.on("SIGINT", handleInterrupt);
+  try {
+    while (!cancelled) {
+      try {
+        const response = await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
+          publicKey: encodeBase64(keypair.publicKey),
+          supportsV2: true
+        });
+        if (response.data.state === "authorized") {
+          let token = response.data.token;
+          let r = decodeBase64(response.data.response);
+          let decrypted = decryptWithEphemeralKey(r, keypair.secretKey);
+          if (decrypted) {
+            if (decrypted.length === 32) {
+              const credentials = {
+                secret: decrypted,
+                token
+              };
+              await writeCredentialsLegacy(credentials);
+              console.log("\n\n\u2713 Authentication successful\n");
+              return {
+                encryption: {
+                  type: "legacy",
+                  secret: decrypted
+                },
+                token
+              };
+            } else {
+              if (decrypted[0] === 0) {
+                const credentials = {
+                  publicKey: decrypted.slice(1, 33),
+                  machineKey: randomBytes(32),
+                  token
+                };
+                await writeCredentialsDataKey(credentials);
+                console.log("\n\n\u2713 Authentication successful\n");
+                return {
+                  encryption: {
+                    type: "dataKey",
+                    publicKey: credentials.publicKey,
+                    machineKey: credentials.machineKey
+                  },
+                  token
+                };
+              } else {
+                console.log("\n\nFailed to decrypt response. Please try again.");
+                return null;
+              }
+            }
+          } else {
+            console.log("\n\nFailed to decrypt response. Please try again.");
+            return null;
+          }
+        }
+      } catch (error) {
+        console.log("\n\nFailed to check authentication status. Please try again.");
+        return null;
+      }
+      process.stdout.write("\rWaiting for authentication" + ".".repeat(dots % 3 + 1) + "   ");
+      dots++;
+      await delay(1e3);
+    }
+  } finally {
+    process.off("SIGINT", handleInterrupt);
+  }
+  return null;
+}
+function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
+  const ephemeralPublicKey = encryptedBundle.slice(0, 32);
+  const nonce = encryptedBundle.slice(32, 32 + tweetnacl.box.nonceLength);
+  const encrypted = encryptedBundle.slice(32 + tweetnacl.box.nonceLength);
+  const decrypted = tweetnacl.box.open(encrypted, nonce, ephemeralPublicKey, recipientSecretKey);
+  if (!decrypted) {
+    return null;
+  }
+  return decrypted;
+}
+async function authAndSetupMachineIfNeeded() {
+  logger.debug("[AUTH] Starting auth and machine setup...");
+  let credentials = await readCredentials();
+  let newAuth = false;
+  if (!credentials) {
+    logger.debug("[AUTH] No credentials found, starting authentication flow...");
+    const authResult = await doAuth();
+    if (!authResult) {
+      throw new Error("Authentication failed or was cancelled");
+    }
+    credentials = authResult;
+    newAuth = true;
+  } else {
+    logger.debug("[AUTH] Using existing credentials");
+  }
+  const settings = await updateSettings(async (s) => {
+    if (newAuth || !s.machineId) {
+      return {
+        ...s,
+        machineId: randomUUID()
+      };
+    }
+    return s;
+  });
+  logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
+  return { credentials, machineId: settings.machineId };
+}
+
+export { authAndSetupMachineIfNeeded, decryptWithEphemeralKey, doAuth };