@zonease/happy 0.6.38 → 0.6.39

package/dist/auth-BIleVCw0.cjs

@@ -0,0 +1,274 @@
+'use strict';
+
+var logger = require('./persistence-JLUn_Nou.cjs');
+var node_crypto = require('node:crypto');
+var tweetnacl = require('tweetnacl');
+var axios = require('axios');
+var qrcode = require('qrcode-terminal');
+var time = require('./time-Bj2HRkKH.cjs');
+var browser = require('./browser-Cc08m7of.cjs');
+var React = require('react');
+var ink = require('ink');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('zod');
+require('chalk');
+require('fs');
+require('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 = logger.encodeBase64(publicKey, "base64url");
+  return `${logger.configuration.webappUrl}/terminal/connect#key=${publicKeyBase64}`;
+}
+
+const AuthSelector = ({ onSelect, onCancel }) => {
+  const [selectedIndex, setSelectedIndex] = React.useState(0);
+  const options = [
+    {
+      method: "mobile",
+      label: "Mobile App"
+    },
+    {
+      method: "web",
+      label: "Web Browser"
+    }
+  ];
+  ink.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(ink.Box, { flexDirection: "column", paddingY: 1 }, /* @__PURE__ */ React.createElement(ink.Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, null, "How would you like to authenticate?")), /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column" }, options.map((option, index) => {
+    const isSelected = selectedIndex === index;
+    return /* @__PURE__ */ React.createElement(ink.Box, { key: option.method, marginY: 0 }, /* @__PURE__ */ React.createElement(ink.Text, { color: isSelected ? "cyan" : "gray" }, isSelected ? "\u203A " : "  ", index + 1, ". ", option.label));
+  })), /* @__PURE__ */ React.createElement(ink.Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(ink.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(node_crypto.randomBytes(32));
+  const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
+  try {
+    if (logger.isDebug()) {
+      console.log(`[AUTH DEBUG] Sending auth request to: ${logger.configuration.serverUrl}/v1/auth/request`);
+      console.log(`[AUTH DEBUG] Public key: ${logger.encodeBase64(keypair.publicKey).substring(0, 20)}...`);
+    }
+    await axios.post(`${logger.configuration.serverUrl}/v1/auth/request`, {
+      publicKey: logger.encodeBase64(keypair.publicKey),
+      supportsV2: true
+    });
+    if (logger.isDebug()) {
+      console.log(`[AUTH DEBUG] Auth request sent successfully`);
+    }
+  } catch (error) {
+    if (logger.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 = ink.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?" + logger.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 browser.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(`${logger.configuration.serverUrl}/v1/auth/request`, {
+          publicKey: logger.encodeBase64(keypair.publicKey),
+          supportsV2: true
+        });
+        if (response.data.state === "authorized") {
+          let token = response.data.token;
+          let r = logger.decodeBase64(response.data.response);
+          let decrypted = decryptWithEphemeralKey(r, keypair.secretKey);
+          if (decrypted) {
+            if (decrypted.length === 32) {
+              const credentials = {
+                secret: decrypted,
+                token
+              };
+              await logger.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: node_crypto.randomBytes(32),
+                  token
+                };
+                await logger.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 time.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.logger.debug("[AUTH] Starting auth and machine setup...");
+  let credentials = await logger.readCredentials();
+  let newAuth = false;
+  if (!credentials) {
+    logger.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.logger.debug("[AUTH] Using existing credentials");
+  }
+  const settings = await logger.updateSettings(async (s) => {
+    if (newAuth || !s.machineId) {
+      return {
+        ...s,
+        machineId: node_crypto.randomUUID()
+      };
+    }
+    return s;
+  });
+  logger.logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
+  return { credentials, machineId: settings.machineId };
+}
+
+exports.authAndSetupMachineIfNeeded = authAndSetupMachineIfNeeded;
+exports.decryptWithEphemeralKey = decryptWithEphemeralKey;
+exports.doAuth = doAuth;

package/dist/auth-Cas9DR3b.cjs

@@ -0,0 +1,183 @@
+'use strict';
+
+var chalk = require('chalk');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var auth = require('./auth-BIleVCw0.cjs');
+var fs = require('node:fs');
+var node_readline = require('node:readline');
+var controlClient = require('./controlClient-DZMIsKsT.cjs');
+var os = require('node:os');
+require('node:fs/promises');
+require('node:path');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('fs');
+require('axios');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-Cc08m7of.cjs');
+require('open');
+require('react');
+require('ink');
+require('./projectPath-ChLhdOyt.cjs');
+require('path');
+require('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.logger.debug("Stopping daemon for force auth...");
+      await controlClient.stopDaemon();
+      console.log(chalk.gray("\u2713 Stopped daemon"));
+    } catch (error) {
+      logger.logger.debug("Daemon was not running or failed to stop:", error);
+    }
+    await logger.clearCredentials();
+    console.log(chalk.gray("\u2713 Cleared credentials"));
+    await logger.clearMachineId();
+    console.log(chalk.gray("\u2713 Cleared machine ID"));
+    console.log("");
+  }
+  if (!forceAuth) {
+    const existingCreds = await logger.readCredentials();
+    const settings = await logger.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 auth.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 = logger.configuration.happyHomeDir;
+  const credentials = await logger.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 = node_readline.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 controlClient.stopDaemon();
+        console.log(chalk.gray("Stopped daemon"));
+      } catch {
+      }
+      if (fs.existsSync(happyDir)) {
+        fs.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 logger.readCredentials();
+  const settings = await logger.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: ${logger.configuration.happyHomeDir}`));
+  try {
+    const running = await controlClient.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"));
+  }
+}
+
+exports.handleAuthCommand = handleAuthCommand;

package/dist/browser-Cc08m7of.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var open = require('open');
+var logger = require('./persistence-JLUn_Nou.cjs');
+
+async function openBrowser(url) {
+  try {
+    if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
+      logger.logger.debug("[browser] Headless environment detected, skipping browser open");
+      return false;
+    }
+    logger.logger.debug(`[browser] Attempting to open URL: ${url}`);
+    await open(url);
+    logger.logger.debug("[browser] Browser opened successfully");
+    return true;
+  } catch (error) {
+    logger.logger.debug("[browser] Failed to open browser:", error);
+    return false;
+  }
+}
+
+exports.openBrowser = openBrowser;

package/dist/browser-Dll5hxOV.mjs

@@ -0,0 +1,20 @@
+import open from 'open';
+import { l as logger } from './persistence-BFjvtUad.mjs';
+
+async function openBrowser(url) {
+  try {
+    if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
+      logger.debug("[browser] Headless environment detected, skipping browser open");
+      return false;
+    }
+    logger.debug(`[browser] Attempting to open URL: ${url}`);
+    await open(url);
+    logger.debug("[browser] Browser opened successfully");
+    return true;
+  } catch (error) {
+    logger.debug("[browser] Failed to open browser:", error);
+    return false;
+  }
+}
+
+export { openBrowser as o };