very-happy-cli 0.2.159 → 0.2.160

package/dist/server-CZTP_iOn.cjs

@@ -0,0 +1,407 @@
+'use strict';
+
+var chalk = require('chalk');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var node_url = require('node:url');
+var module$1 = require('node:module');
+var node_crypto = require('node:crypto');
+var node_child_process = require('node:child_process');
+var promises = require('node:readline/promises');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+require('node:os');
+require('./package-BwMrPwqH.cjs');
+require('node:fs/promises');
+require('zod');
+require('./authRelay-BdYkC1Po.cjs');
+require('tweetnacl');
+require('./logger-CS0mw3fa.cjs');
+require('node:util');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, generatedInviteCode) {
+  const signupMode = configuredMode?.trim() || "invite";
+  const inviteCodes = configuredInviteCodes?.trim();
+  if (signupMode !== "invite" || inviteCodes) {
+    return { signupMode, signupInviteCodes: inviteCodes || void 0 };
+  }
+  return {
+    signupMode,
+    signupInviteCodes: generatedInviteCode,
+    generatedInviteCode
+  };
+}
+
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('server-CZTP_iOn.cjs', document.baseURI).href)));
+const __dirname$1 = path.dirname(__filename$1);
+const require_ = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('server-CZTP_iOn.cjs', document.baseURI).href)));
+const PRISMA_QUERY_ENGINE_FILES = {
+  "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
+  "x64-darwin": "libquery_engine-darwin.dylib.node",
+  "arm64-linux": "libquery_engine-linux-arm64-openssl-3.0.x.so.node",
+  "x64-linux": "libquery_engine-debian-openssl-3.0.x.so.node",
+  "x64-win32": "query_engine-windows.dll.node"
+};
+const SERVER_PACKAGE_NAME = "very-happy-server";
+const SETTINGS_WRITE_CONFIRM_FLAG = "--i-understand-this-will-modify-default-happy-settings";
+async function handleServerCommand(args) {
+  const opts = parseArgs(args);
+  if (opts === null) return;
+  const serverUrl = `http://${opts.host === "0.0.0.0" ? "127.0.0.1" : opts.host}:${opts.port}`;
+  await ensureSettingsWriteAllowed(opts, serverUrl);
+  const dataDir = path.join(configuration.configuration.happyHomeDir, "server-data");
+  const pgliteDir = path.join(dataDir, "pglite");
+  const secretFile = path.join(dataDir, "master-secret");
+  const bootstrapCodeFile = path.join(dataDir, "bootstrap-invite-code");
+  if (opts.reset && node_fs.existsSync(dataDir)) {
+    console.log(chalk.yellow(`Wiping ${dataDir}...`));
+    node_fs.rmSync(dataDir, { recursive: true, force: true });
+  }
+  node_fs.mkdirSync(dataDir, { recursive: true });
+  const masterSecret = opts.masterSecret ?? loadOrCreateMasterSecret(secretFile);
+  const signup = resolveLocalSignupBootstrap(
+    process.env.SIGNUP_MODE,
+    process.env.SIGNUP_INVITE_CODES,
+    loadOrCreateBootstrapInviteCode(bootstrapCodeFile)
+  );
+  const artifacts = resolveServerArtifacts();
+  if (!artifacts) {
+    console.error(chalk.red("Could not locate happy-server."));
+    console.error(chalk.gray("  Expected one of:"));
+    console.error(chalk.gray(`    - installed ${SERVER_PACKAGE_NAME} package`));
+    console.error(chalk.gray(`    - legacy bundled binary at ${path.join(__dirname$1, "..", "..", "tools", "server", currentPlatform(), bundledBinaryName())}`));
+    console.error(chalk.gray("    - sibling packages/happy-server/sources/standalone.ts in the monorepo"));
+    console.error(chalk.gray(`  The fork-owned ${SERVER_PACKAGE_NAME} artifact may not be published yet.`));
+    console.error(chalk.gray("  Use Dockerfile.server from the repository for the supported self-host path."));
+    process.exit(1);
+  }
+  const staticDir = artifacts.webappDir ?? findWebappDir();
+  console.log(chalk.cyan(`
+  very-happy server`));
+  console.log(chalk.gray(`  data dir:   ${dataDir}`));
+  console.log(chalk.gray(`  server url: ${serverUrl}`));
+  console.log(chalk.gray(`  mode:       ${serverArtifactMode(artifacts)}`));
+  if (staticDir) {
+    console.log(chalk.gray(`  webapp:     ${staticDir}`));
+  } else {
+    console.log(chalk.yellow("  webapp:     (no production Web V2 build) \u2014 API only. Run `pnpm bundle:webapp` to build."));
+  }
+  console.log();
+  const env = {
+    ...process.env,
+    DB_PROVIDER: "pglite",
+    DATA_DIR: dataDir,
+    PGLITE_DIR: pgliteDir,
+    HANDY_MASTER_SECRET: masterSecret,
+    PORT: String(opts.port),
+    HOST: opts.host,
+    SIGNUP_MODE: signup.signupMode
+  };
+  if (signup.signupInviteCodes) env.SIGNUP_INVITE_CODES = signup.signupInviteCodes;
+  if (staticDir) env.HAPPY_STATIC_DIR = staticDir;
+  env.HAPPY_INJECT_HTML_CONFIG = JSON.stringify({
+    serverUrl,
+    disableAnalytics: true
+  });
+  if (signup.generatedInviteCode) {
+    console.log(chalk.yellow.bold("  First-account bootstrap"));
+    console.log(chalk.yellow(`  Invite code: ${signup.generatedInviteCode}`));
+    console.log(chalk.gray("  Register the first operator, stop this server, then restart with:"));
+    console.log(chalk.cyan("    SIGNUP_MODE=closed very-happy server"));
+    console.log(chalk.gray("  The code remains valid until the server is restarted in closed mode."));
+    console.log();
+  }
+  if (artifacts.bundled) {
+    const prismaEngine = artifacts.prismaQueryEngineLibrary ?? resolvePrismaQueryEngineLibrary(artifacts.cwd);
+    if (!prismaEngine) {
+      console.error(chalk.red("Could not locate the Prisma query engine for this platform."));
+      if (artifacts.source === "package") {
+        console.error(chalk.gray(`  Expected ${SERVER_PACKAGE_NAME} to install @prisma/engines.`));
+        console.error(chalk.gray(`  Try reinstalling ${SERVER_PACKAGE_NAME}, then run \`very-happy server\` again.`));
+      } else {
+        console.error(chalk.gray("  Expected @prisma/engines to be available near the happy package."));
+        console.error(chalk.gray("  Try reinstalling happy, then run `very-happy server` again."));
+      }
+      process.exit(1);
+    }
+    env.PRISMA_QUERY_ENGINE_LIBRARY = prismaEngine;
+  }
+  console.log(chalk.gray("Running migrations..."));
+  await spawnAndWait(artifacts, env, ["migrate"]);
+  if (opts.persistServerUrl) {
+    await persistence.updateSettings((current) => ({ ...current, serverUrl, webappUrl: serverUrl }));
+    console.log(chalk.gray(`Wrote serverUrl + webappUrl=${serverUrl} to ${configuration.configuration.settingsFile}`));
+  }
+  console.log(chalk.gray("Starting server..."));
+  const child = spawnBackground(artifacts, env, ["serve"]);
+  console.log();
+  console.log(chalk.green.bold(`\u2713 happy-server starting at ${serverUrl}`));
+  if (staticDir) {
+    console.log(chalk.green(`  Open ${serverUrl} in your browser.`));
+  }
+  if (opts.persistServerUrl) {
+    console.log(chalk.gray("  happy CLI + daemon will use this server automatically (settings.serverUrl)."));
+  }
+  console.log(chalk.gray("  Press Ctrl-C to stop."));
+  console.log();
+  const forwardSignal = (sig) => {
+    if (!child.killed) child.kill(sig);
+  };
+  process.on("SIGINT", () => forwardSignal("SIGINT"));
+  process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+  const exitCode = await new Promise((resolve) => {
+    child.on("exit", (code) => {
+      console.log(chalk.gray(`
+happy-server exited (code ${code ?? 0})`));
+      resolve(code ?? 0);
+    });
+  });
+  process.exit(exitCode);
+}
+function parseArgs(args) {
+  let port = 3005;
+  let host = "127.0.0.1";
+  let reset = false;
+  let persistServerUrl = true;
+  let allowSettingsWrite = false;
+  let masterSecret;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      showHelp();
+      return null;
+    } else if (arg === "--port" || arg === "-p") {
+      port = parseInt(args[++i], 10);
+      if (Number.isNaN(port)) {
+        console.error(chalk.red("Invalid --port"));
+        process.exit(1);
+      }
+    } else if (arg === "--host") {
+      host = args[++i];
+    } else if (arg === "--reset") {
+      reset = true;
+    } else if (arg === "--no-persist") {
+      persistServerUrl = false;
+    } else if (arg === SETTINGS_WRITE_CONFIRM_FLAG) {
+      allowSettingsWrite = true;
+    } else if (arg === "--master-secret") {
+      masterSecret = args[++i];
+    } else {
+      console.error(chalk.red(`Unknown arg: ${arg}`));
+      showHelp();
+      process.exit(1);
+    }
+  }
+  return { port, host, reset, persistServerUrl, allowSettingsWrite, masterSecret };
+}
+function showHelp() {
+  console.log(`
+${chalk.bold("very-happy server")} - Run Happy sync server + web app locally (self-host)
+
+${chalk.bold("Usage:")}
+  very-happy server [--port 3005] [--host 127.0.0.1] [--reset] [--no-persist]
+
+${chalk.bold("Options:")}
+  --port, -p <n>        Port to listen on (default: 3005)
+  --host <ip>           Host to bind (default: 127.0.0.1)
+  --reset               Wipe local server data before starting
+  --no-persist          Don't write serverUrl into settings.json
+  ${SETTINGS_WRITE_CONFIRM_FLAG}
+                        Write settings.serverUrl/settings.webappUrl without prompting
+  --master-secret <hex> Use a specific master secret (default: auto-generated)
+
+${chalk.bold("Notes:")}
+  - Stores data in ${chalk.cyan("$HAPPY_HOME_DIR/server-data/")}
+  - Packaged installs require ${chalk.cyan(SERVER_PACKAGE_NAME)} once that fork-owned artifact is published
+  - Until then, use the repository's ${chalk.cyan("Dockerfile.server")} self-host path
+  - By default, asks before writing ${chalk.cyan("settings.serverUrl")} and ${chalk.cyan("settings.webappUrl")}
+  - Use ${chalk.cyan("--no-persist")} to run without modifying default Happy settings
+  - Fresh installs start in invite mode and print a persisted bootstrap code
+  - After the first account, restart with ${chalk.cyan("SIGNUP_MODE=closed")} to disable signup
+  - Open ${chalk.cyan("http://127.0.0.1:<port>")} for the web app (if bundled)
+`);
+}
+async function ensureSettingsWriteAllowed(opts, serverUrl) {
+  if (!opts.persistServerUrl || opts.allowSettingsWrite) {
+    return;
+  }
+  const message = `very-happy server will write settings.serverUrl and settings.webappUrl to ${serverUrl} in ${configuration.configuration.settingsFile}.`;
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    console.error(chalk.red("Refusing to modify default Happy settings from a non-interactive run."));
+    console.error(chalk.gray(message));
+    console.error(chalk.gray(`Re-run with --no-persist, or pass ${SETTINGS_WRITE_CONFIRM_FLAG}.`));
+    process.exit(1);
+  }
+  const rl = promises.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(`${chalk.yellow(message)} Continue? ${chalk.gray("[y/N]")} `);
+    const normalized = answer.trim().toLowerCase();
+    if (normalized !== "y" && normalized !== "yes") {
+      console.error(chalk.gray("Cancelled. Re-run with --no-persist to start without changing settings."));
+      process.exit(1);
+    }
+  } finally {
+    rl.close();
+  }
+}
+function loadOrCreateMasterSecret(file) {
+  if (node_fs.existsSync(file)) {
+    return node_fs.readFileSync(file, "utf8").trim();
+  }
+  const secret = node_crypto.randomBytes(32).toString("hex");
+  node_fs.writeFileSync(file, secret, { mode: 384 });
+  return secret;
+}
+function loadOrCreateBootstrapInviteCode(file) {
+  if (node_fs.existsSync(file)) {
+    return node_fs.readFileSync(file, "utf8").trim();
+  }
+  const code = `vh-bootstrap-${node_crypto.randomBytes(18).toString("base64url")}`;
+  node_fs.writeFileSync(file, code, { mode: 384 });
+  return code;
+}
+function currentPlatform() {
+  return `${process.arch}-${process.platform}`;
+}
+function resolvePrismaQueryEngineLibrary(bundledServerDir) {
+  const fromDependency = findPrismaEngineFromDependency();
+  if (fromDependency) {
+    return fromDependency;
+  }
+  const legacyBundledEngine = path.join(bundledServerDir, "libquery_engine.node");
+  return node_fs.existsSync(legacyBundledEngine) ? legacyBundledEngine : void 0;
+}
+function findPrismaEngineFromDependency() {
+  const engineFile = PRISMA_QUERY_ENGINE_FILES[currentPlatform()];
+  if (!engineFile) {
+    return void 0;
+  }
+  try {
+    const enginesPackage = require_.resolve("@prisma/engines/package.json");
+    const candidate = path.join(path.dirname(enginesPackage), engineFile);
+    return node_fs.existsSync(candidate) ? candidate : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveToolsPath(name) {
+  let dir = __dirname$1;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "tools", name);
+    if (node_fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path.resolve(__dirname$1, "..", "tools", name);
+}
+function bundledBinaryName() {
+  return process.platform === "win32" ? "happy-server.exe" : "happy-server";
+}
+function ensureExecutable(file) {
+  if (process.platform === "win32") return;
+  try {
+    const mode = node_fs.statSync(file).mode;
+    if ((mode & 73) === 0) node_fs.chmodSync(file, mode | 493);
+  } catch {
+  }
+}
+function serverArtifactMode(artifacts) {
+  if (artifacts.source === "package") return SERVER_PACKAGE_NAME;
+  if (artifacts.source === "legacy-bundled") return "legacy bundled";
+  return "source (dev)";
+}
+function resolveServerArtifacts() {
+  const packageArtifact = resolveInstalledServerPackage();
+  if (packageArtifact) return packageArtifact;
+  const toolsRoot = resolveToolsPath("server");
+  const binDir = path.join(toolsRoot, currentPlatform());
+  const binary = path.join(binDir, bundledBinaryName());
+  if (node_fs.existsSync(binary)) {
+    ensureExecutable(binary);
+    return { command: binary, prefixArgs: [], cwd: binDir, bundled: true, source: "legacy-bundled" };
+  }
+  const sourceEntry = findSourceStandalone();
+  if (sourceEntry) {
+    const tsx = findTsxBinary(path.dirname(path.dirname(sourceEntry)));
+    const useNode = tsx !== "tsx";
+    return {
+      command: useNode ? process.execPath : "tsx",
+      prefixArgs: useNode ? [tsx, sourceEntry] : [sourceEntry],
+      cwd: path.dirname(path.dirname(sourceEntry)),
+      bundled: false,
+      source: "source"
+    };
+  }
+  return void 0;
+}
+function resolveInstalledServerPackage() {
+  try {
+    const serverPackage = require_(SERVER_PACKAGE_NAME);
+    const artifact = serverPackage.resolveServerArtifact?.();
+    if (!artifact || !artifact.command || !node_fs.existsSync(artifact.command)) {
+      return void 0;
+    }
+    return {
+      command: artifact.command,
+      prefixArgs: artifact.prefixArgs ?? [],
+      cwd: artifact.cwd,
+      bundled: artifact.bundled ?? true,
+      source: "package",
+      prismaQueryEngineLibrary: artifact.prismaQueryEngineLibrary,
+      webappDir: artifact.webappDir
+    };
+  } catch {
+    return void 0;
+  }
+}
+function findSourceStandalone() {
+  const candidates = [
+    path.resolve(__dirname$1, "../../../happy-server/sources/standalone.ts"),
+    path.resolve(__dirname$1, "../../happy-server/sources/standalone.ts"),
+    path.resolve(process.cwd(), "packages/happy-server/sources/standalone.ts"),
+    path.resolve(process.cwd(), "../happy-server/sources/standalone.ts")
+  ];
+  for (const c of candidates) {
+    if (node_fs.existsSync(c)) return c;
+  }
+  return void 0;
+}
+function findWebappDir() {
+  const bundled = resolveToolsPath("webapp");
+  if (node_fs.existsSync(path.join(bundled, "index.html"))) return bundled;
+  const candidates = [
+    path.resolve(__dirname$1, "../../../happy-web-v2/dist"),
+    path.resolve(__dirname$1, "../../happy-web-v2/dist"),
+    path.resolve(process.cwd(), "packages/happy-web-v2/dist")
+  ];
+  for (const c of candidates) {
+    if (node_fs.existsSync(path.join(c, "index.html"))) return c;
+  }
+  return void 0;
+}
+function findTsxBinary(cwd) {
+  try {
+    return require_.resolve("tsx/cli", { paths: [cwd] });
+  } catch {
+    return "tsx";
+  }
+}
+async function spawnAndWait(art, env, args) {
+  const cmdArgs = [...art.prefixArgs, ...args];
+  await new Promise((resolve, reject) => {
+    const child = node_child_process.spawn(art.command, cmdArgs, { cwd: art.cwd, env, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`happy-server ${args[0]} exited with code ${code}`));
+    });
+  });
+}
+function spawnBackground(art, env, args) {
+  const cmdArgs = [...art.prefixArgs, ...args];
+  return node_child_process.spawn(art.command, cmdArgs, { cwd: art.cwd, env, stdio: "inherit" });
+}
+
+exports.handleServerCommand = handleServerCommand;