very-happy-cli 0.2.158 → 0.2.160

package/dist/{config-BtPArqRH.mjs → config-CTx_jb-C.mjs}

@@ -2,50 +2,17 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { execSync } from 'child_process';
-import { l as logger } from './limits-D2uN090G.mjs';
-import { D as DEFAULT_GEMINI_MODEL, G as GEMINI_MODEL_ENV } from './index-CVCt3kSt.mjs';
-import 'zod';
-import '@paralleldrive/cuid2';
-import 'node:fs/promises';
-import 'node:fs';
-import 'node:crypto';
-import 'tweetnacl';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { D as DEFAULT_GEMINI_MODEL, G as GEMINI_MODEL_ENV } from './constants-BC4St0xd.mjs';
 import 'chalk';
 import 'node:util';
+import './configuration-RfeNjFmd.mjs';
+import 'node:fs';
 import 'node:os';
 import 'node:path';
-import './types-DIBF4U0Y.mjs';
-import 'axios';
-import 'node:events';
-import 'socket.io-client';
-import 'util';
-import 'fs/promises';
-import 'crypto';
-import 'cross-spawn';
-import './terminalTitleSuggest-DKgX3osW.mjs';
-import 'url';
-import 'node:child_process';
-import 'node-pty';
-import 'node:readline';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
-import './agentGuidance-CrR9l62U.mjs';
-import 'ink';
-import 'react';
-import '@anthropic-ai/claude-agent-sdk';
-import 'ps-list';
-import 'tmp';
-import 'open';
-import 'fastify';
-import 'fastify-type-provider-zod';
-import 'node:module';
-import '@modelcontextprotocol/sdk/server/mcp.js';
-import 'node:http';
-import '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import 'http';
-import 'inquirer';
-import 'node:url';
-import 'node:readline/promises';
+import './package-BhaKlnxz.mjs';
+import 'node:fs/promises';
+import './trimIdent-BAjmv_TG.mjs';
 
 function readGeminiLocalConfig() {
   let token = null;

package/dist/{config-DG84bjwF.cjs → config-Ci9Kpgwa.cjs}

@@ -4,50 +4,17 @@ var fs = require('fs');
 var path = require('path');
 var os = require('os');
 var child_process = require('child_process');
-var persistence = require('./limits-kqFqhfsh.cjs');
-var index = require('./index-BG932eCh.cjs');
-require('zod');
-require('@paralleldrive/cuid2');
-require('node:fs/promises');
-require('node:fs');
-require('node:crypto');
-require('tweetnacl');
+var logger = require('./logger-CS0mw3fa.cjs');
+var constants = require('./constants-VJ0N6WuG.cjs');
 require('chalk');
 require('node:util');
+require('./configuration-BSYpcPwE.cjs');
+require('node:fs');
 require('node:os');
 require('node:path');
-require('./types-DnrPeN80.cjs');
-require('axios');
-require('node:events');
-require('socket.io-client');
-require('util');
-require('fs/promises');
-require('crypto');
-require('cross-spawn');
-require('./terminalTitleSuggest-Dji8I0Jy.cjs');
-require('url');
-require('node:child_process');
-require('node-pty');
-require('node:readline');
-require('@anthropic-ai/sandbox-runtime');
-require('expo-server-sdk');
-require('./agentGuidance-DwOWbX55.cjs');
-require('ink');
-require('react');
-require('@anthropic-ai/claude-agent-sdk');
-require('ps-list');
-require('tmp');
-require('open');
-require('fastify');
-require('fastify-type-provider-zod');
-require('node:module');
-require('@modelcontextprotocol/sdk/server/mcp.js');
-require('node:http');
-require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-require('http');
-require('inquirer');
-require('node:url');
-require('node:readline/promises');
+require('./package-BwMrPwqH.cjs');
+require('node:fs/promises');
+require('./trimIdent-4gvk9Wk6.cjs');
 
 function readGeminiLocalConfig() {
   let token = null;
@@ -70,14 +37,14 @@ function readGeminiLocalConfig() {
           const foundToken = config.access_token || config.token || config.apiKey || config.GEMINI_API_KEY;
           if (foundToken && typeof foundToken === "string") {
             token = foundToken;
-            persistence.logger.debug(`[Gemini] Found token in ${configPath}`);
+            logger.logger.debug(`[Gemini] Found token in ${configPath}`);
           }
         }
         if (!model) {
           const foundModel = config.model || config.GEMINI_MODEL;
           if (foundModel && typeof foundModel === "string") {
             model = foundModel;
-            persistence.logger.debug(`[Gemini] Found model in ${configPath}: ${model}`);
+            logger.logger.debug(`[Gemini] Found model in ${configPath}: ${model}`);
           }
         }
         if (!googleCloudProject) {
@@ -87,11 +54,11 @@ function readGeminiLocalConfig() {
             if (config.googleCloudProjectEmail && typeof config.googleCloudProjectEmail === "string") {
               googleCloudProjectEmail = config.googleCloudProjectEmail;
             }
-            persistence.logger.debug(`[Gemini] Found Google Cloud Project in ${configPath}: ${googleCloudProject}${googleCloudProjectEmail ? ` (for ${googleCloudProjectEmail})` : ""}`);
+            logger.logger.debug(`[Gemini] Found Google Cloud Project in ${configPath}: ${googleCloudProject}${googleCloudProjectEmail ? ` (for ${googleCloudProjectEmail})` : ""}`);
           }
         }
       } catch (error) {
-        persistence.logger.debug(`[Gemini] Failed to read config from ${configPath}:`, error);
+        logger.logger.debug(`[Gemini] Failed to read config from ${configPath}:`, error);
       }
     }
   }
@@ -105,10 +72,10 @@ function readGeminiLocalConfig() {
       }).trim();
       if (gcloudToken && gcloudToken.length > 0) {
         token = gcloudToken;
-        persistence.logger.debug("[Gemini] Found token via gcloud Application Default Credentials");
+        logger.logger.debug("[Gemini] Found token via gcloud Application Default Credentials");
       }
     } catch (error) {
-      persistence.logger.debug("[Gemini] gcloud Application Default Credentials not available");
+      logger.logger.debug("[Gemini] gcloud Application Default Credentials not available");
     }
   }
   if (!googleCloudProject) {
@@ -116,7 +83,7 @@ function readGeminiLocalConfig() {
     if (envProject) {
       googleCloudProject = envProject;
       googleCloudProjectEmail = null;
-      persistence.logger.debug(`[Gemini] Found Google Cloud Project from env: ${googleCloudProject}`);
+      logger.logger.debug(`[Gemini] Found Google Cloud Project from env: ${googleCloudProject}`);
     }
   }
   return { token, model, googleCloudProject, googleCloudProjectEmail };
@@ -124,15 +91,15 @@ function readGeminiLocalConfig() {
 function determineGeminiModel(explicitModel, localConfig) {
   if (explicitModel !== void 0) {
     if (explicitModel === null) {
-      return process.env[index.GEMINI_MODEL_ENV] || index.DEFAULT_GEMINI_MODEL;
+      return process.env[constants.GEMINI_MODEL_ENV] || constants.DEFAULT_GEMINI_MODEL;
     } else {
       return explicitModel;
     }
   } else {
-    const envModel = process.env[index.GEMINI_MODEL_ENV];
-    persistence.logger.debug(`[Gemini] Model selection: env[GEMINI_MODEL_ENV]=${envModel}, localConfig.model=${localConfig.model}, DEFAULT=${index.DEFAULT_GEMINI_MODEL}`);
-    const model = envModel || localConfig.model || index.DEFAULT_GEMINI_MODEL;
-    persistence.logger.debug(`[Gemini] Selected model: ${model}`);
+    const envModel = process.env[constants.GEMINI_MODEL_ENV];
+    logger.logger.debug(`[Gemini] Model selection: env[GEMINI_MODEL_ENV]=${envModel}, localConfig.model=${localConfig.model}, DEFAULT=${constants.DEFAULT_GEMINI_MODEL}`);
+    const model = envModel || localConfig.model || constants.DEFAULT_GEMINI_MODEL;
+    logger.logger.debug(`[Gemini] Selected model: ${model}`);
     return model;
   }
 }
@@ -148,15 +115,15 @@ function saveGeminiModelToConfig(model) {
       try {
         config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
       } catch (error) {
-        persistence.logger.debug(`[Gemini] Failed to read existing config, creating new one`);
+        logger.logger.debug(`[Gemini] Failed to read existing config, creating new one`);
         config = {};
       }
     }
     config.model = model;
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-    persistence.logger.debug(`[Gemini] Saved model "${model}" to ${configPath}`);
+    logger.logger.debug(`[Gemini] Saved model "${model}" to ${configPath}`);
   } catch (error) {
-    persistence.logger.debug(`[Gemini] Failed to save model to config:`, error);
+    logger.logger.debug(`[Gemini] Failed to save model to config:`, error);
   }
 }
 function saveGoogleCloudProjectToConfig(projectId, email) {
@@ -179,20 +146,20 @@ function saveGoogleCloudProjectToConfig(projectId, email) {
       config.googleCloudProjectEmail = email;
     }
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-    persistence.logger.debug(`[Gemini] Saved Google Cloud Project "${projectId}"${email ? ` for ${email}` : ""} to ${configPath}`);
+    logger.logger.debug(`[Gemini] Saved Google Cloud Project "${projectId}"${email ? ` for ${email}` : ""} to ${configPath}`);
   } catch (error) {
-    persistence.logger.debug(`[Gemini] Failed to save Google Cloud Project to config:`, error);
+    logger.logger.debug(`[Gemini] Failed to save Google Cloud Project to config:`, error);
     throw error;
   }
 }
 function getInitialGeminiModel() {
   const localConfig = readGeminiLocalConfig();
-  return process.env[index.GEMINI_MODEL_ENV] || localConfig.model || index.DEFAULT_GEMINI_MODEL;
+  return process.env[constants.GEMINI_MODEL_ENV] || localConfig.model || constants.DEFAULT_GEMINI_MODEL;
 }
 function getGeminiModelSource(explicitModel, localConfig) {
   if (explicitModel !== void 0 && explicitModel !== null) {
     return "explicit";
-  } else if (process.env[index.GEMINI_MODEL_ENV]) {
+  } else if (process.env[constants.GEMINI_MODEL_ENV]) {
     return "env-var";
   } else if (localConfig.model) {
     return "local-config";

package/dist/configuration-BSYpcPwE.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var os = require('node:os');
+var path = require('node:path');
+var _package = require('./package-BwMrPwqH.cjs');
+var promises = require('node:fs/promises');
+
+const PRIVATE_DIRECTORY_MODE = 448;
+const PRIVATE_FILE_MODE = 384;
+function ignoreUnsupportedPermissions(error) {
+  if (process.platform !== "win32") throw error;
+}
+function ensurePrivateDirectorySync(path) {
+  node_fs.mkdirSync(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  try {
+    node_fs.chmodSync(path, PRIVATE_DIRECTORY_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+async function ensurePrivateDirectory(path) {
+  await promises.mkdir(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  try {
+    await promises.chmod(path, PRIVATE_DIRECTORY_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+function hardenPrivateFileSync(path) {
+  try {
+    node_fs.chmodSync(path, PRIVATE_FILE_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+function hardenPrivateDirectoryFilesSync(path$1) {
+  for (const name of node_fs.readdirSync(path$1)) {
+    const candidate = path.join(path$1, name);
+    try {
+      if (node_fs.statSync(candidate).isFile()) hardenPrivateFileSync(candidate);
+    } catch {
+    }
+  }
+}
+async function hardenPrivateFile(path) {
+  try {
+    await promises.chmod(path, PRIVATE_FILE_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+function writePrivateFileSync(path, data) {
+  node_fs.writeFileSync(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  hardenPrivateFileSync(path);
+}
+async function writePrivateFile(path, data) {
+  await promises.writeFile(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  await hardenPrivateFile(path);
+}
+function appendPrivateFileSync(path, data) {
+  node_fs.appendFileSync(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  hardenPrivateFileSync(path);
+}
+
+const DEFAULT_RELAY_URL = "https://veryhappy.dev";
+function normalizeHttpEndpoint(value, source) {
+  const trimmed = value.trim();
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error(`${source} must be an absolute http(s) origin`);
+  }
+  const onlyOriginPath = /^\/+$/u.test(parsed.pathname);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username.length > 0 || parsed.password.length > 0 || !onlyOriginPath || parsed.search.length > 0 || parsed.hash.length > 0) {
+    throw new Error(`${source} must be an http(s) origin without credentials, path, query, or fragment`);
+  }
+  return parsed.origin;
+}
+function resolveHttpEndpoint(environmentValue, settingsValue, environmentName, settingsName) {
+  if (environmentValue !== void 0) {
+    return normalizeHttpEndpoint(environmentValue, environmentName);
+  }
+  if (settingsValue !== void 0) {
+    return normalizeHttpEndpoint(settingsValue, `settings.${settingsName}`);
+  }
+  return DEFAULT_RELAY_URL;
+}
+class Configuration {
+  serverUrl;
+  webappUrl;
+  isDaemonProcess;
+  // Directories and paths (from persistence)
+  happyHomeDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  daemonStateFile;
+  daemonLockFile;
+  sessionsFile;
+  currentCliVersion;
+  isExperimentalEnabled;
+  disableCaffeinate;
+  constructor() {
+    const args = process.argv.slice(2);
+    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
+    if (process.env.HAPPY_HOME_DIR) {
+      const expandedPath = process.env.HAPPY_HOME_DIR.replace(/^~/, os.homedir());
+      this.happyHomeDir = expandedPath;
+    } else {
+      this.happyHomeDir = path.join(os.homedir(), ".happy");
+    }
+    this.logsDir = path.join(this.happyHomeDir, "logs");
+    this.settingsFile = path.join(this.happyHomeDir, "settings.json");
+    this.privateKeyFile = path.join(this.happyHomeDir, "access.key");
+    this.daemonStateFile = path.join(this.happyHomeDir, "daemon.state.json");
+    this.daemonLockFile = path.join(this.happyHomeDir, "daemon.state.json.lock");
+    this.sessionsFile = path.join(this.happyHomeDir, "sessions.json");
+    try {
+      this.serverUrl = resolveHttpEndpoint(
+        process.env.HAPPY_SERVER_URL,
+        readSettingsStringSync(this.settingsFile, "serverUrl"),
+        "HAPPY_SERVER_URL",
+        "serverUrl"
+      );
+      this.webappUrl = resolveHttpEndpoint(
+        process.env.HAPPY_WEBAPP_URL,
+        readSettingsStringSync(this.settingsFile, "webappUrl"),
+        "HAPPY_WEBAPP_URL",
+        "webappUrl"
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid client endpoint";
+      process.stderr.write(`[very-happy] Configuration error: ${message}
+`);
+      process.exit(1);
+    }
+    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
+    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.HAPPY_DISABLE_CAFFEINATE?.toLowerCase() || "");
+    this.currentCliVersion = _package.packageJson.version;
+    const variant = process.env.HAPPY_VARIANT || "stable";
+    if (!this.isDaemonProcess && variant === "dev") {
+      console.log("\x1B[33m\u{1F527} DEV MODE\x1B[0m - Data: " + this.happyHomeDir);
+    }
+    ensurePrivateDirectorySync(this.happyHomeDir);
+    ensurePrivateDirectorySync(this.logsDir);
+    for (const privateFile of [
+      this.settingsFile,
+      this.privateKeyFile,
+      this.daemonStateFile,
+      this.daemonLockFile,
+      this.sessionsFile
+    ]) {
+      if (node_fs.existsSync(privateFile)) hardenPrivateFileSync(privateFile);
+    }
+    hardenPrivateDirectoryFilesSync(this.logsDir);
+  }
+}
+function readSettingsStringSync(settingsFile, key) {
+  try {
+    if (!node_fs.existsSync(settingsFile)) return void 0;
+    const raw = JSON.parse(node_fs.readFileSync(settingsFile, "utf8"));
+    const value = raw?.[key];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+const configuration = new Configuration();
+
+exports.PRIVATE_FILE_MODE = PRIVATE_FILE_MODE;
+exports.appendPrivateFileSync = appendPrivateFileSync;
+exports.configuration = configuration;
+exports.ensurePrivateDirectory = ensurePrivateDirectory;
+exports.ensurePrivateDirectorySync = ensurePrivateDirectorySync;
+exports.hardenPrivateFile = hardenPrivateFile;
+exports.hardenPrivateFileSync = hardenPrivateFileSync;
+exports.normalizeHttpEndpoint = normalizeHttpEndpoint;
+exports.writePrivateFile = writePrivateFile;
+exports.writePrivateFileSync = writePrivateFileSync;

package/dist/configuration-RfeNjFmd.mjs

@@ -0,0 +1,170 @@
+import { mkdirSync, chmodSync, readdirSync, statSync, appendFileSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { p as packageJson } from './package-BhaKlnxz.mjs';
+import { mkdir, chmod, writeFile } from 'node:fs/promises';
+
+const PRIVATE_DIRECTORY_MODE = 448;
+const PRIVATE_FILE_MODE = 384;
+function ignoreUnsupportedPermissions(error) {
+  if (process.platform !== "win32") throw error;
+}
+function ensurePrivateDirectorySync(path) {
+  mkdirSync(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  try {
+    chmodSync(path, PRIVATE_DIRECTORY_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+async function ensurePrivateDirectory(path) {
+  await mkdir(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  try {
+    await chmod(path, PRIVATE_DIRECTORY_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+function hardenPrivateFileSync(path) {
+  try {
+    chmodSync(path, PRIVATE_FILE_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+function hardenPrivateDirectoryFilesSync(path) {
+  for (const name of readdirSync(path)) {
+    const candidate = join(path, name);
+    try {
+      if (statSync(candidate).isFile()) hardenPrivateFileSync(candidate);
+    } catch {
+    }
+  }
+}
+async function hardenPrivateFile(path) {
+  try {
+    await chmod(path, PRIVATE_FILE_MODE);
+  } catch (error) {
+    ignoreUnsupportedPermissions(error);
+  }
+}
+function writePrivateFileSync(path, data) {
+  writeFileSync(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  hardenPrivateFileSync(path);
+}
+async function writePrivateFile(path, data) {
+  await writeFile(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  await hardenPrivateFile(path);
+}
+function appendPrivateFileSync(path, data) {
+  appendFileSync(path, data, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+  hardenPrivateFileSync(path);
+}
+
+const DEFAULT_RELAY_URL = "https://veryhappy.dev";
+function normalizeHttpEndpoint(value, source) {
+  const trimmed = value.trim();
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error(`${source} must be an absolute http(s) origin`);
+  }
+  const onlyOriginPath = /^\/+$/u.test(parsed.pathname);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username.length > 0 || parsed.password.length > 0 || !onlyOriginPath || parsed.search.length > 0 || parsed.hash.length > 0) {
+    throw new Error(`${source} must be an http(s) origin without credentials, path, query, or fragment`);
+  }
+  return parsed.origin;
+}
+function resolveHttpEndpoint(environmentValue, settingsValue, environmentName, settingsName) {
+  if (environmentValue !== void 0) {
+    return normalizeHttpEndpoint(environmentValue, environmentName);
+  }
+  if (settingsValue !== void 0) {
+    return normalizeHttpEndpoint(settingsValue, `settings.${settingsName}`);
+  }
+  return DEFAULT_RELAY_URL;
+}
+class Configuration {
+  serverUrl;
+  webappUrl;
+  isDaemonProcess;
+  // Directories and paths (from persistence)
+  happyHomeDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  daemonStateFile;
+  daemonLockFile;
+  sessionsFile;
+  currentCliVersion;
+  isExperimentalEnabled;
+  disableCaffeinate;
+  constructor() {
+    const args = process.argv.slice(2);
+    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
+    if (process.env.HAPPY_HOME_DIR) {
+      const expandedPath = process.env.HAPPY_HOME_DIR.replace(/^~/, homedir());
+      this.happyHomeDir = expandedPath;
+    } else {
+      this.happyHomeDir = join(homedir(), ".happy");
+    }
+    this.logsDir = join(this.happyHomeDir, "logs");
+    this.settingsFile = join(this.happyHomeDir, "settings.json");
+    this.privateKeyFile = join(this.happyHomeDir, "access.key");
+    this.daemonStateFile = join(this.happyHomeDir, "daemon.state.json");
+    this.daemonLockFile = join(this.happyHomeDir, "daemon.state.json.lock");
+    this.sessionsFile = join(this.happyHomeDir, "sessions.json");
+    try {
+      this.serverUrl = resolveHttpEndpoint(
+        process.env.HAPPY_SERVER_URL,
+        readSettingsStringSync(this.settingsFile, "serverUrl"),
+        "HAPPY_SERVER_URL",
+        "serverUrl"
+      );
+      this.webappUrl = resolveHttpEndpoint(
+        process.env.HAPPY_WEBAPP_URL,
+        readSettingsStringSync(this.settingsFile, "webappUrl"),
+        "HAPPY_WEBAPP_URL",
+        "webappUrl"
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "invalid client endpoint";
+      process.stderr.write(`[very-happy] Configuration error: ${message}
+`);
+      process.exit(1);
+    }
+    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
+    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.HAPPY_DISABLE_CAFFEINATE?.toLowerCase() || "");
+    this.currentCliVersion = packageJson.version;
+    const variant = process.env.HAPPY_VARIANT || "stable";
+    if (!this.isDaemonProcess && variant === "dev") {
+      console.log("\x1B[33m\u{1F527} DEV MODE\x1B[0m - Data: " + this.happyHomeDir);
+    }
+    ensurePrivateDirectorySync(this.happyHomeDir);
+    ensurePrivateDirectorySync(this.logsDir);
+    for (const privateFile of [
+      this.settingsFile,
+      this.privateKeyFile,
+      this.daemonStateFile,
+      this.daemonLockFile,
+      this.sessionsFile
+    ]) {
+      if (existsSync(privateFile)) hardenPrivateFileSync(privateFile);
+    }
+    hardenPrivateDirectoryFilesSync(this.logsDir);
+  }
+}
+function readSettingsStringSync(settingsFile, key) {
+  try {
+    if (!existsSync(settingsFile)) return void 0;
+    const raw = JSON.parse(readFileSync(settingsFile, "utf8"));
+    const value = raw?.[key];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+const configuration = new Configuration();
+
+export { PRIVATE_FILE_MODE as P, writePrivateFile as a, hardenPrivateFile as b, configuration as c, appendPrivateFileSync as d, ensurePrivateDirectory as e, ensurePrivateDirectorySync as f, hardenPrivateFileSync as h, normalizeHttpEndpoint as n, writePrivateFileSync as w };