very-happy-cli 0.2.159 → 0.2.161

package/dist/server-m2b5pamZ.mjs

@@ -0,0 +1,404 @@
+import chalk from 'chalk';
+import { existsSync, rmSync, mkdirSync, readFileSync, writeFileSync, statSync, chmodSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { updateSettings } from './persistence-oET5n61f.mjs';
+import 'node:os';
+import './package-uOg9SCKi.mjs';
+import 'node:fs/promises';
+import 'zod';
+import './authRelay-DSAvg1uv.mjs';
+import 'tweetnacl';
+import './logger-fXoNzNuB.mjs';
+import 'node:util';
+
+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 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const require_ = createRequire(import.meta.url);
+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.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 && existsSync(dataDir)) {
+    console.log(chalk.yellow(`Wiping ${dataDir}...`));
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+  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 updateSettings((current) => ({ ...current, serverUrl, webappUrl: serverUrl }));
+    console.log(chalk.gray(`Wrote serverUrl + webappUrl=${serverUrl} to ${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.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 = 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 (existsSync(file)) {
+    return readFileSync(file, "utf8").trim();
+  }
+  const secret = randomBytes(32).toString("hex");
+  writeFileSync(file, secret, { mode: 384 });
+  return secret;
+}
+function loadOrCreateBootstrapInviteCode(file) {
+  if (existsSync(file)) {
+    return readFileSync(file, "utf8").trim();
+  }
+  const code = `vh-bootstrap-${randomBytes(18).toString("base64url")}`;
+  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 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 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 (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 = statSync(file).mode;
+    if ((mode & 73) === 0) 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 (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 || !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 (existsSync(c)) return c;
+  }
+  return void 0;
+}
+function findWebappDir() {
+  const bundled = resolveToolsPath("webapp");
+  if (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 (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 = 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 spawn(art.command, cmdArgs, { cwd: art.cwd, env, stdio: "inherit" });
+}
+
+export { handleServerCommand };

package/dist/sessionLock-7ePAYDOg.cjs

@@ -0,0 +1,205 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var path = require('node:path');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var logger = require('./logger-Bc8-u1w0.cjs');
+
+const PROCESS_IDENTITY_FIELDS = [
+  "hostPid",
+  "version",
+  "startedBy",
+  "startedFromDaemon",
+  "happyHomeDir",
+  "happyLibDir",
+  "happyToolsDir",
+  "capabilities",
+  "attachmentKinds",
+  "queueCancellation",
+  "sandbox",
+  "dangerouslySkipPermissions",
+  "os",
+  "host",
+  "homeDir",
+  "permissionMode"
+];
+function processIdentityFields(local) {
+  const out = {};
+  for (const key of PROCESS_IDENTITY_FIELDS) {
+    const value = local[key];
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function mergeReconnectMetadata(server, local, now) {
+  return {
+    ...server,
+    ...processIdentityFields(local),
+    lifecycleState: "running",
+    lifecycleStateSince: now,
+    archivedBy: void 0,
+    archiveReason: void 0
+  };
+}
+function applyServerSnapshot(response, snapshot) {
+  return {
+    ...response,
+    seq: snapshot.seq,
+    metadata: snapshot.metadata,
+    metadataVersion: snapshot.metadataVersion,
+    agentState: snapshot.agentState,
+    agentStateVersion: snapshot.agentStateVersion
+  };
+}
+function withoutServerSnapshot(response) {
+  return { ...response, metadataVersion: 0, agentStateVersion: 0 };
+}
+
+const runtime = {
+  signal: (pid, signal) => process.kill(pid, signal),
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  schedule: (callback, delayMs) => {
+    setTimeout(callback, delayMs);
+  }
+};
+function terminateProcess(pid, onSettled, impl = runtime, graceMs = 2e3) {
+  if (!impl.isAlive(pid)) {
+    onSettled(true);
+    return true;
+  }
+  try {
+    impl.signal(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  impl.schedule(() => {
+    if (impl.isAlive(pid)) {
+      try {
+        impl.signal(pid, "SIGKILL");
+      } catch {
+        onSettled(!impl.isAlive(pid));
+        return;
+      }
+    }
+    impl.schedule(() => onSettled(!impl.isAlive(pid)), 100);
+  }, graceMs);
+  return true;
+}
+
+const SESSION_LOCK_DIR = "session-locks";
+const defaultRuntime = () => ({
+  dir: path.join(configuration.configuration.happyHomeDir, SESSION_LOCK_DIR),
+  selfPid: process.pid,
+  now: () => Date.now(),
+  signal: (pid, signal) => process.kill(pid, signal),
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  schedule: (callback, delayMs) => {
+    setTimeout(callback, delayMs);
+  }
+});
+function sessionLockPath(happySessionId, dir = path.join(configuration.configuration.happyHomeDir, SESSION_LOCK_DIR)) {
+  return path.join(dir, `${happySessionId}.json`);
+}
+function readSessionLock(happySessionId, dir) {
+  try {
+    const path = sessionLockPath(happySessionId, dir);
+    if (!node_fs.existsSync(path)) return null;
+    const parsed = JSON.parse(node_fs.readFileSync(path, "utf-8"));
+    if (typeof parsed?.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+    return {
+      pid: parsed.pid,
+      startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0,
+      version: typeof parsed.version === "string" ? parsed.version : "",
+      ...typeof parsed.flavor === "string" ? { flavor: parsed.flavor } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function liveSessionLockHolder(happySessionId, runtime = defaultRuntime()) {
+  const record = readSessionLock(happySessionId, runtime.dir);
+  if (!record || record.pid === runtime.selfPid) return null;
+  return runtime.isAlive(record.pid) ? record : null;
+}
+function writeSessionLock(happySessionId, record, dir) {
+  node_fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  const path = sessionLockPath(happySessionId, dir);
+  const tmp = `${path}.${record.pid}.tmp`;
+  configuration.writePrivateFileSync(tmp, JSON.stringify(record));
+  node_fs.renameSync(tmp, path);
+}
+function acquireSessionLock(happySessionId, options, runtime = defaultRuntime()) {
+  const record = () => ({
+    pid: runtime.selfPid,
+    startedAt: runtime.now(),
+    version: options.version,
+    ...options.flavor ? { flavor: options.flavor } : {}
+  });
+  const holder = liveSessionLockHolder(happySessionId, runtime);
+  if (!holder) {
+    writeSessionLock(happySessionId, record(), runtime.dir);
+    return Promise.resolve({ ok: true, replaced: null });
+  }
+  if (!options.takeover) {
+    return Promise.resolve({ ok: false, holder });
+  }
+  return new Promise((resolve) => {
+    const requested = terminateProcess(holder.pid, (stopped) => {
+      if (!stopped) {
+        resolve({ ok: false, holder });
+        return;
+      }
+      writeSessionLock(happySessionId, record(), runtime.dir);
+      resolve({ ok: true, replaced: holder });
+    }, runtime, options.graceMs ?? 2e3);
+    if (!requested) resolve({ ok: false, holder });
+  });
+}
+function releaseSessionLock(happySessionId, runtime = defaultRuntime()) {
+  try {
+    const record = readSessionLock(happySessionId, runtime.dir);
+    if (record && record.pid === runtime.selfPid) {
+      node_fs.unlinkSync(sessionLockPath(happySessionId, runtime.dir));
+    }
+  } catch {
+  }
+}
+async function claimSessionOrExit(happySessionId, options) {
+  const result = await acquireSessionLock(happySessionId, {
+    takeover: options.takeover,
+    version: configuration.configuration.currentCliVersion,
+    flavor: options.flavor
+  });
+  if (!result.ok) {
+    const message = `Session ${happySessionId} is already run by very-happy pid ${result.holder.pid} (v${result.holder.version || "?"}); this process yields.`;
+    logger.logger.debug(`[SESSION LOCK] ${message}`);
+    console.error(message);
+    process.exit(0);
+  }
+  if (result.replaced) {
+    logger.logger.debug(`[SESSION LOCK] Took over session ${happySessionId} from pid ${result.replaced.pid} (v${result.replaced.version || "?"})`);
+  }
+  process.on("exit", () => releaseSessionLock(happySessionId));
+}
+
+exports.applyServerSnapshot = applyServerSnapshot;
+exports.claimSessionOrExit = claimSessionOrExit;
+exports.mergeReconnectMetadata = mergeReconnectMetadata;
+exports.processIdentityFields = processIdentityFields;
+exports.readSessionLock = readSessionLock;
+exports.terminateProcess = terminateProcess;
+exports.withoutServerSnapshot = withoutServerSnapshot;