very-happy-cli 0.2.123 → 0.2.125

package/dist/limits-DViGHwSj.cjs

@@ -0,0 +1,1198 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_fs = require('node:fs');
+var os = require('node:os');
+var path = require('node:path');
+var z = require('zod');
+var node_crypto = require('node:crypto');
+var tweetnacl = require('tweetnacl');
+var chalk = require('chalk');
+var node_util = require('node:util');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+var name = "very-happy-cli";
+var version = "0.2.125";
+var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
+var author = "Kirill Dubovitskiy";
+var contributors = [
+	"Mereith (very-happy-cli fork)"
+];
+var license = "MIT";
+var engines = {
+	node: "^20.19.0 || ^22.13.0 || >=24.0.0"
+};
+var type = "module";
+var homepage = "https://github.com/Mereithhh/very-happy";
+var bugs = "https://github.com/Mereithhh/very-happy/issues";
+var repository = {
+	type: "git",
+	url: "git+https://github.com/Mereithhh/very-happy.git"
+};
+var bin = {
+	"very-happy": "./bin/very-happy.mjs",
+	"very-happy-mcp": "./bin/very-happy-mcp.mjs"
+};
+var main = "./dist/index.cjs";
+var module$1 = "./dist/index.mjs";
+var types = "./dist/index.d.cts";
+var exports$1 = {
+	".": {
+		require: {
+			types: "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		},
+		"import": {
+			types: "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"./lib": {
+		require: {
+			types: "./dist/lib.d.cts",
+			"default": "./dist/lib.cjs"
+		},
+		"import": {
+			types: "./dist/lib.d.mts",
+			"default": "./dist/lib.mjs"
+		}
+	},
+	"./codex/happyMcpStdioBridge": {
+		require: {
+			types: "./dist/codex/happyMcpStdioBridge.d.cts",
+			"default": "./dist/codex/happyMcpStdioBridge.cjs"
+		},
+		"import": {
+			types: "./dist/codex/happyMcpStdioBridge.d.mts",
+			"default": "./dist/codex/happyMcpStdioBridge.mjs"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"scripts",
+	"tools/licenses",
+	"package.json",
+	"README.md",
+	"LICENSE"
+];
+var scripts = {
+	typecheck: "tsc --noEmit",
+	"bundle:server": "node scripts/bundle-server.cjs",
+	"bundle:server:all": "node scripts/bundle-server.cjs --all-platforms",
+	"bundle:webapp": "node scripts/bundle-webapp.cjs",
+	build: "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc --noEmit && pkgroll",
+	test: "pnpm run build && vitest run --project unit",
+	"test:integration": "pnpm run build && vitest run --project integration-empty --project integration-plan-mode --project integration-authenticated",
+	"cli:install": "node scripts/install-local.cjs",
+	prepublishOnly: "pnpm test",
+	postinstall: "node scripts/unpack-tools.cjs && node scripts/fix-pty-perms.cjs"
+};
+var dependencies = {
+	"@agentclientprotocol/sdk": "^0.14.1",
+	"@anthropic-ai/claude-agent-sdk": "^0.3.232",
+	"@anthropic-ai/sandbox-runtime": "^0.0.37",
+	"@modelcontextprotocol/sdk": "1.30.0",
+	"@noble/ed25519": "^3.0.0",
+	"@noble/hashes": "^2.0.1",
+	"@paralleldrive/cuid2": "^2.2.2",
+	"@stablelib/base64": "^2.0.1",
+	"@stablelib/hex": "^2.0.1",
+	"@types/cross-spawn": "^6.0.6",
+	"@types/http-proxy": "^1.17.17",
+	"@types/react": "^19.2.7",
+	"@types/tmp": "^0.2.6",
+	axios: "^1.13.2",
+	chalk: "^5.6.2",
+	"cross-spawn": "^7.0.6",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "5.8.5",
+	"fastify-type-provider-zod": "^6.1.0",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.7",
+	ink: "^6.5.1",
+	inquirer: "^13.2.2",
+	"node-pty": "^1.0.0",
+	open: "^10.2.0",
+	"ps-list": "^8.1.1",
+	react: "^19.2.0",
+	"socket.io-client": "^4.8.1",
+	tar: "^7.5.22",
+	tmp: "^0.2.7",
+	tweetnacl: "^1.0.3",
+	ws: "^8.21.3",
+	zod: "^4.0.0"
+};
+var optionalDependencies = {
+	"very-happy-tools-arm64-darwin": "0.2.125",
+	"very-happy-tools-x64-darwin": "0.2.125",
+	"very-happy-tools-arm64-linux": "0.2.125",
+	"very-happy-tools-x64-linux": "0.2.125",
+	"very-happy-tools-arm64-win32": "0.2.125",
+	"very-happy-tools-x64-win32": "0.2.125"
+};
+var devDependencies = {
+	"@slopus/happy-wire": "workspace:*",
+	"@xterm/addon-serialize": "0.13.0",
+	"@xterm/headless": "5.5.0",
+	"@types/inquirer": "^9.0.9",
+	"@types/node": ">=20",
+	"@types/ws": "^8.18.1",
+	"cross-env": "^10.1.0",
+	dotenv: "^16.6.1",
+	pkgroll: "^2.14.2",
+	"ts-node": "^10",
+	tsx: "^4.20.6",
+	typescript: "5.9.3",
+	vitest: "3.2.6"
+};
+var publishConfig = {
+	registry: "https://registry.npmjs.org"
+};
+var packageManager = "pnpm@10.11.0";
+var packageJson = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	contributors: contributors,
+	license: license,
+	engines: engines,
+	type: type,
+	homepage: homepage,
+	bugs: bugs,
+	repository: repository,
+	bin: bin,
+	main: main,
+	module: module$1,
+	types: types,
+	exports: exports$1,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	optionalDependencies: optionalDependencies,
+	devDependencies: devDependencies,
+	publishConfig: publishConfig,
+	packageManager: packageManager
+};
+
+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 = 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();
+
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (variant === "base64url") {
+    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
+    return new Uint8Array(Buffer.from(base64Standard, "base64"));
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(node_crypto.randomBytes(size));
+}
+function libsodiumPublicKeyFromSecretKey(seed) {
+  const hashedSeed = new Uint8Array(node_crypto.createHash("sha512").update(seed).digest());
+  const secretKey = hashedSeed.slice(0, 32);
+  return new Uint8Array(tweetnacl.box.keyPair.fromSecretKey(secretKey).publicKey);
+}
+function libsodiumEncryptForPublicKey(data, recipientPublicKey) {
+  const ephemeralKeyPair = tweetnacl.box.keyPair();
+  const nonce = getRandomBytes(tweetnacl.box.nonceLength);
+  const encrypted = tweetnacl.box(data, nonce, recipientPublicKey, ephemeralKeyPair.secretKey);
+  const result = new Uint8Array(ephemeralKeyPair.publicKey.length + nonce.length + encrypted.length);
+  result.set(ephemeralKeyPair.publicKey, 0);
+  result.set(nonce, ephemeralKeyPair.publicKey.length);
+  result.set(encrypted, ephemeralKeyPair.publicKey.length + nonce.length);
+  return result;
+}
+function encryptLegacy(data, secret) {
+  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
+  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
+  const result = new Uint8Array(nonce.length + encrypted.length);
+  result.set(nonce);
+  result.set(encrypted, nonce.length);
+  return result;
+}
+function decryptLegacy(data, secret) {
+  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
+  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
+  if (!decrypted) {
+    return null;
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+function decryptBlob(bundle, key) {
+  if (bundle.length < tweetnacl.secretbox.nonceLength + 16) {
+    return null;
+  }
+  const nonce = bundle.slice(0, tweetnacl.secretbox.nonceLength);
+  const ciphertext = bundle.slice(tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(ciphertext, nonce, key);
+  if (!decrypted) {
+    return null;
+  }
+  return new Uint8Array(decrypted);
+}
+function encryptWithDataKey(data, dataKey) {
+  const nonce = getRandomBytes(12);
+  const cipher = node_crypto.createCipheriv("aes-256-gcm", dataKey, nonce);
+  const plaintext = new TextEncoder().encode(JSON.stringify(data));
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  const bundle = new Uint8Array(12 + encrypted.length + 16 + 1);
+  bundle.set([0], 0);
+  bundle.set(nonce, 1);
+  bundle.set(new Uint8Array(encrypted), 13);
+  bundle.set(new Uint8Array(authTag), 13 + encrypted.length);
+  return bundle;
+}
+function decryptWithDataKey(bundle, dataKey) {
+  if (bundle.length < 1) {
+    return null;
+  }
+  if (bundle[0] !== 0) {
+    return null;
+  }
+  if (bundle.length < 12 + 16 + 1) {
+    return null;
+  }
+  const nonce = bundle.slice(1, 13);
+  const authTag = bundle.slice(bundle.length - 16);
+  const ciphertext = bundle.slice(13, bundle.length - 16);
+  try {
+    const decipher = node_crypto.createDecipheriv("aes-256-gcm", dataKey, nonce);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  } catch (error) {
+    return null;
+  }
+}
+function encrypt(key, variant, data) {
+  if (variant === "legacy") {
+    return encryptLegacy(data, key);
+  } else {
+    return encryptWithDataKey(data, key);
+  }
+}
+function decrypt(key, variant, data) {
+  if (variant === "legacy") {
+    return decryptLegacy(data, key);
+  } else {
+    return decryptWithDataKey(data, key);
+  }
+}
+
+function sensitiveKey(key) {
+  const normalized = key.toLowerCase().replace(/[_\-\s]/g, "");
+  return /(token|secret|password|authorization|cookie|credential|apikey|privatekey|encryptionkey|accesskey|claimsecret)/.test(normalized);
+}
+function redactLogString(value) {
+  return value.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]").replace(/([?&](?:token|secret|password|api[_-]?key)=)[^&#\s]+/gi, "$1[REDACTED]").replace(/((?:token|secret|password|api[_-]?key)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]");
+}
+function redactLogValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") return redactLogString(value);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= 6) return "[TRUNCATED]";
+  if (seen.has(value)) return "[CIRCULAR]";
+  seen.add(value);
+  if (value instanceof Error) {
+    const error = value;
+    return {
+      name: error.name,
+      message: redactLogString(error.message),
+      ...typeof error.code === "string" || typeof error.code === "number" ? { code: error.code } : {},
+      ...typeof (error.status ?? error.response?.status) === "number" ? { status: error.status ?? error.response?.status } : {}
+    };
+  }
+  if (Array.isArray(value)) return value.map((item) => redactLogValue(item, depth + 1, seen));
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (sensitiveKey(key)) {
+      result[key] = "[REDACTED]";
+    } else if (key === "environmentVariables" && child && typeof child === "object") {
+      result[key] = { names: Object.keys(child).sort() };
+    } else {
+      result[key] = redactLogValue(child, depth + 1, seen);
+    }
+  }
+  return result;
+}
+
+function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "") + "-pid-" + process.pid;
+}
+function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleTimeString("en-US", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+}
+function getSessionLogPath() {
+  const timestamp = createTimestampForFilename();
+  const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
+  return path.join(configuration.logsDir, filename);
+}
+function safeRemoteLogUrl(raw) {
+  if (!raw) return void 0;
+  try {
+    const url = new URL(raw);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) return void 0;
+    if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") return void 0;
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+class Logger {
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
+    const remoteUrl = safeRemoteLogUrl(process.env.HAPPY_SERVER_URL);
+    const remoteToken = process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING_TOKEN;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && remoteUrl && remoteToken && Buffer.byteLength(remoteToken) >= 32) {
+      this.dangerouslyUnencryptedServerLoggingUrl = remoteUrl;
+      this.dangerouslyUnencryptedServerLoggingToken = remoteToken;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
+  }
+  dangerouslyUnencryptedServerLoggingUrl;
+  dangerouslyUnencryptedServerLoggingToken;
+  // Use local timezone for simplicity of locating the logs,
+  // in practice you will not need absolute timestamps
+  localTimezoneTimestamp() {
+    return createTimestampForLogEntry();
+  }
+  debug(message, ...args) {
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
+  }
+  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
+    if (!process.env.DEBUG) {
+      this.debug(`In production, skipping message inspection`);
+      return;
+    }
+    const truncateStrings = (obj) => {
+      if (typeof obj === "string") {
+        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
+      }
+      if (Array.isArray(obj)) {
+        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        if (obj.length > maxArrayLength) {
+          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
+        }
+        return truncatedArray;
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === "usage") {
+            continue;
+          }
+          result[key] = truncateStrings(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    const truncatedObject = truncateStrings(redactLogValue(object));
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, redactLogString(message), "\n", json);
+  }
+  info(message, ...args) {
+    this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
+  }
+  infoDeveloper(message, ...args) {
+    this.debug(message, ...args);
+    if (process.env.DEBUG) {
+      this.logToConsole("info", "[DEV]", message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    this.logToConsole("warn", "", message, ...args);
+    this.debug(`[WARN] ${message}`, ...args);
+  }
+  getLogPath() {
+    return this.logFilePath;
+  }
+  logToConsole(level, prefix, message, ...args) {
+    message = redactLogString(message);
+    args = args.map((arg) => redactLogValue(arg));
+    switch (level) {
+      case "debug": {
+        console.log(chalk.gray(prefix), message, ...args);
+        break;
+      }
+      case "error": {
+        console.error(chalk.red(prefix), message, ...args);
+        break;
+      }
+      case "info": {
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+      case "warn": {
+        console.log(chalk.yellow(prefix), message, ...args);
+        break;
+      }
+      default: {
+        this.debug("Unknown log level:", level);
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+    }
+  }
+  async sendToRemoteServer(level, message, ...args) {
+    if (!this.dangerouslyUnencryptedServerLoggingUrl) return;
+    try {
+      await fetch(this.dangerouslyUnencryptedServerLoggingUrl + "/logs-combined-from-cli-and-mobile-for-simple-ai-debugging", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.dangerouslyUnencryptedServerLoggingToken}`
+        },
+        body: JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level,
+          message: `${redactLogString(message)} ${args.map((raw) => {
+            const safe = redactLogValue(raw);
+            return typeof safe === "object" ? JSON.stringify(safe, null, 2) : String(safe);
+          }).join(" ")}`,
+          source: "cli",
+          platform: process.platform
+        })
+      });
+    } catch (error) {
+    }
+  }
+  logToFile(prefix, message, ...args) {
+    const safeMessage = redactLogString(message);
+    const safeArgs = args.map((arg) => redactLogValue(arg));
+    const logLine = `${prefix} ${safeMessage} ${safeArgs.map(
+      (arg) => typeof arg === "string" ? arg : node_util.inspect(arg, { depth: 5, breakLength: 120 })
+    ).join(" ")}
+`;
+    if (this.dangerouslyUnencryptedServerLoggingUrl) {
+      let level = "info";
+      if (prefix.includes(this.localTimezoneTimestamp())) {
+        level = "debug";
+      }
+      this.sendToRemoteServer(level, safeMessage, ...safeArgs).catch(() => {
+      });
+    }
+    try {
+      appendPrivateFileSync(this.logFilePath, logLine);
+    } catch (appendError) {
+      if (process.env.DEBUG) {
+        console.error("[DEV MODE ONLY THROWING] Failed to append to log file:", appendError);
+        throw appendError;
+      }
+    }
+  }
+}
+let logger = new Logger();
+async function listDaemonLogFiles(limit = 50) {
+  try {
+    const logsDir = configuration.logsDir;
+    if (!node_fs.existsSync(logsDir)) {
+      return [];
+    }
+    const logs = node_fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = path.join(logsDir, file);
+      const stats = node_fs.statSync(fullPath);
+      return { file, path: fullPath, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    try {
+      const { readDaemonState } = await Promise.resolve().then(function () { return persistence; });
+      const state = await readDaemonState();
+      if (!state) {
+        return logs;
+      }
+      if (state.daemonLogPath && node_fs.existsSync(state.daemonLogPath)) {
+        const stats = node_fs.statSync(state.daemonLogPath);
+        const persisted = {
+          file: path.basename(state.daemonLogPath),
+          path: state.daemonLogPath,
+          modified: stats.mtime
+        };
+        const idx = logs.findIndex((l) => l.path === persisted.path);
+        if (idx >= 0) {
+          const [found] = logs.splice(idx, 1);
+          logs.unshift(found);
+        } else {
+          logs.unshift(persisted);
+        }
+      }
+    } catch {
+    }
+    return logs.slice(0, Math.max(0, limit));
+  } catch {
+    return [];
+  }
+}
+async function getLatestDaemonLog() {
+  const [latest] = await listDaemonLogFiles(1);
+  return latest || null;
+}
+
+const DEFAULT_SERVER_URL = "https://veryhappy.dev";
+const LEGACY_CLOUD_SERVER_URL = "https://happy.mereith.com";
+const CLOUD_SERVER_URLS = [DEFAULT_SERVER_URL, LEGACY_CLOUD_SERVER_URL];
+function sameRelay(left, right) {
+  try {
+    return new URL(left).origin === new URL(right).origin;
+  } catch {
+    return left.replace(/\/+$/, "") === right.replace(/\/+$/, "");
+  }
+}
+function credentialRelayProblem(credentialServerUrl, configuredServerUrl) {
+  if (credentialServerUrl) {
+    return sameRelay(credentialServerUrl, configuredServerUrl) ? void 0 : `Credentials belong to ${credentialServerUrl}, but the active relay is ${configuredServerUrl}.`;
+  }
+  if (CLOUD_SERVER_URLS.some((cloudUrl) => sameRelay(configuredServerUrl, cloudUrl))) {
+    return void 0;
+  }
+  return `These credentials predate relay tracking, so they cannot be safely reused with ${configuredServerUrl}.`;
+}
+
+const SandboxConfigSchema = z__namespace.object({
+  enabled: z__namespace.boolean().default(false),
+  workspaceRoot: z__namespace.string().optional(),
+  sessionIsolation: z__namespace.enum(["strict", "workspace", "custom"]).default("workspace"),
+  customWritePaths: z__namespace.array(z__namespace.string()).default([]),
+  denyReadPaths: z__namespace.array(z__namespace.string()).default(["~/.ssh", "~/.aws", "~/.gnupg"]),
+  extraWritePaths: z__namespace.array(z__namespace.string()).default(["/tmp"]),
+  denyWritePaths: z__namespace.array(z__namespace.string()).default([".env"]),
+  networkMode: z__namespace.enum(["blocked", "allowed", "custom"]).default("allowed"),
+  allowedDomains: z__namespace.array(z__namespace.string()).default([]),
+  deniedDomains: z__namespace.array(z__namespace.string()).default([]),
+  allowLocalBinding: z__namespace.boolean().default(true)
+});
+const SUPPORTED_SCHEMA_VERSION = 2;
+const defaultSettings = {
+  schemaVersion: SUPPORTED_SCHEMA_VERSION,
+  onboardingCompleted: false,
+  sandboxConfig: void 0
+};
+function migrateSettings(raw, fromVersion) {
+  let migrated = { ...raw };
+  return migrated;
+}
+async function readSettingsOutcome() {
+  if (!node_fs.existsSync(configuration.settingsFile)) {
+    return { kind: "absent" };
+  }
+  try {
+    return { kind: "ok", settings: await parseSettingsFile() };
+  } catch (error) {
+    return { kind: "unreadable", error: error?.message ?? String(error) };
+  }
+}
+async function readSettings() {
+  const outcome = await readSettingsOutcome();
+  if (outcome.kind === "ok") return outcome.settings;
+  if (outcome.kind === "unreadable") {
+    logger.warn(`Failed to read settings: ${outcome.error}`);
+  }
+  return { ...defaultSettings };
+}
+async function parseSettingsFile() {
+  const content = await promises.readFile(configuration.settingsFile, "utf8");
+  const raw = JSON.parse(content);
+  const schemaVersion = raw.schemaVersion ?? 1;
+  if (schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+    logger.warn(
+      `\u26A0\uFE0F Settings schema v${schemaVersion} > supported v${SUPPORTED_SCHEMA_VERSION}. Update happy-cli for full functionality.`
+    );
+  }
+  const migrated = migrateSettings(raw);
+  if (migrated.sandboxConfig !== void 0) {
+    try {
+      migrated.sandboxConfig = SandboxConfigSchema.parse(migrated.sandboxConfig);
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F Invalid sandbox config - skipping. Error: ${error.message}`);
+      migrated.sandboxConfig = void 0;
+    }
+  }
+  return { ...defaultSettings, ...migrated };
+}
+async function writeSettings(settings) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  const settingsWithVersion = {
+    ...settings,
+    schemaVersion: settings.schemaVersion ?? SUPPORTED_SCHEMA_VERSION
+  };
+  await writePrivateFile(configuration.settingsFile, JSON.stringify(settingsWithVersion, null, 2));
+}
+async function updateSettings(updater) {
+  const LOCK_RETRY_INTERVAL_MS = 100;
+  const MAX_LOCK_ATTEMPTS = 50;
+  const STALE_LOCK_TIMEOUT_MS = 1e4;
+  const lockFile = configuration.settingsFile + ".lock";
+  const tmpFile = configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await promises.open(lockFile, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY, PRIVATE_FILE_MODE);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await promises.stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await promises.unlink(lockFile).catch(() => {
+            });
+          }
+        } catch {
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const outcome = await readSettingsOutcome();
+    if (outcome.kind === "unreadable") {
+      throw new Error(
+        `Settings file ${configuration.settingsFile} exists but could not be read (${outcome.error}). Refusing to overwrite it \u2014 fix or remove the file (a removed file is recreated with defaults).`
+      );
+    }
+    const current = outcome.kind === "ok" ? outcome.settings : { ...defaultSettings };
+    const updated = await updater(current);
+    await ensurePrivateDirectory(configuration.happyHomeDir);
+    await writePrivateFile(tmpFile, JSON.stringify(updated, null, 2));
+    await promises.rename(tmpFile, configuration.settingsFile);
+    await hardenPrivateFile(configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await promises.unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z__namespace.object({
+  token: z__namespace.string(),
+  authServerUrl: z__namespace.string().optional(),
+  secret: z__namespace.string().base64().nullish(),
+  // Legacy
+  encryption: z__namespace.object({
+    publicKey: z__namespace.string().base64(),
+    machineKey: z__namespace.string().base64()
+  }).nullish()
+});
+async function readCredentials() {
+  if (!node_fs.existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await promises.readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    if (credentials.secret) {
+      return {
+        token: credentials.token,
+        authServerUrl: credentials.authServerUrl,
+        encryption: {
+          type: "legacy",
+          secret: new Uint8Array(Buffer.from(credentials.secret, "base64"))
+        }
+      };
+    } else if (credentials.encryption) {
+      return {
+        token: credentials.token,
+        authServerUrl: credentials.authServerUrl,
+        encryption: {
+          type: "dataKey",
+          publicKey: new Uint8Array(Buffer.from(credentials.encryption.publicKey, "base64")),
+          machineKey: new Uint8Array(Buffer.from(credentials.encryption.machineKey, "base64"))
+        }
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function readCredentialsForConfiguredRelay() {
+  const credentials = await readCredentials();
+  if (!credentials) return null;
+  const relayProblem = credentialRelayProblem(credentials.authServerUrl, configuration.serverUrl);
+  if (relayProblem) {
+    throw new Error(
+      `${relayProblem} Use a separate HAPPY_HOME_DIR for this relay, or run \`very-happy auth login --force\` before making relay requests.`
+    );
+  }
+  return credentials;
+}
+async function writeCredentialsLegacy(credentials) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token,
+    authServerUrl: configuration.serverUrl
+  }, null, 2));
+}
+async function writeCredentialsDataKey(credentials) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
+    token: credentials.token,
+    authServerUrl: configuration.serverUrl
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (node_fs.existsSync(configuration.privateKeyFile)) {
+    await promises.unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!node_fs.existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await promises.readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  writePrivateFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2));
+}
+async function clearDaemonState() {
+  if (node_fs.existsSync(configuration.daemonStateFile)) {
+    await promises.unlink(configuration.daemonStateFile);
+  }
+  if (node_fs.existsSync(configuration.daemonLockFile)) {
+    try {
+      await promises.unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await promises.open(
+        configuration.daemonLockFile,
+        node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY,
+        PRIVATE_FILE_MODE
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = node_fs.readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              node_fs.unlinkSync(configuration.daemonLockFile);
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      if (attempt === maxAttempts) {
+        return null;
+      }
+      const delayMs = attempt * delayIncrementMs;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return null;
+}
+async function releaseDaemonLock(lockHandle) {
+  try {
+    await lockHandle.close();
+  } catch {
+  }
+  try {
+    if (node_fs.existsSync(configuration.daemonLockFile)) {
+      node_fs.unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+const SESSION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function readPersistedSessions() {
+  try {
+    if (!node_fs.existsSync(configuration.sessionsFile)) return {};
+    const data = JSON.parse(node_fs.readFileSync(configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return {};
+    const now = Date.now();
+    const sessions = {};
+    for (const [id, session] of Object.entries(data.sessions)) {
+      if (now - session.savedAt < SESSION_MAX_AGE_MS) {
+        sessions[id] = session;
+      }
+    }
+    return sessions;
+  } catch {
+    return {};
+  }
+}
+function readTrackedClaudeSessionIds() {
+  try {
+    if (!node_fs.existsSync(configuration.sessionsFile)) return [];
+    const data = JSON.parse(node_fs.readFileSync(configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const session of Object.values(data.sessions)) {
+      const metadata = (session ?? {}).metadata;
+      for (const id of [metadata?.claudeSessionId, metadata?.importedFromClaudeSessionId]) {
+        if (typeof id === "string" && id.length > 0) ids.add(id.toLowerCase());
+      }
+    }
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+function persistSession(sessionId, session) {
+  try {
+    const existing = readPersistedSessions();
+    existing[sessionId] = session;
+    const tmpFile = configuration.sessionsFile + ".tmp";
+    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    node_fs.renameSync(tmpFile, configuration.sessionsFile);
+    hardenPrivateFileSync(configuration.sessionsFile);
+  } catch (error) {
+    logger.debug(`[PERSISTENCE] Failed to persist session ${sessionId}:`, error);
+  }
+}
+function deletePersistedSessions(sessionIds) {
+  try {
+    const existing = readPersistedSessions();
+    let changed = false;
+    for (const id of sessionIds) {
+      if (id in existing) {
+        delete existing[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    const tmpFile = configuration.sessionsFile + ".tmp";
+    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    node_fs.renameSync(tmpFile, configuration.sessionsFile);
+    hardenPrivateFileSync(configuration.sessionsFile);
+  } catch (error) {
+    logger.debug(`[PERSISTENCE] Failed to delete persisted sessions:`, error);
+  }
+}
+
+var persistence = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  SUPPORTED_SCHEMA_VERSION: SUPPORTED_SCHEMA_VERSION,
+  SandboxConfigSchema: SandboxConfigSchema,
+  acquireDaemonLock: acquireDaemonLock,
+  clearCredentials: clearCredentials,
+  clearDaemonState: clearDaemonState,
+  clearMachineId: clearMachineId,
+  deletePersistedSessions: deletePersistedSessions,
+  persistSession: persistSession,
+  readCredentials: readCredentials,
+  readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay,
+  readDaemonState: readDaemonState,
+  readPersistedSessions: readPersistedSessions,
+  readSettings: readSettings,
+  readSettingsOutcome: readSettingsOutcome,
+  readTrackedClaudeSessionIds: readTrackedClaudeSessionIds,
+  releaseDaemonLock: releaseDaemonLock,
+  updateSettings: updateSettings,
+  writeCredentialsDataKey: writeCredentialsDataKey,
+  writeCredentialsLegacy: writeCredentialsLegacy,
+  writeDaemonState: writeDaemonState,
+  writeSettings: writeSettings
+});
+
+const CLIPBOARD_MAX_BYTES = 256 * 1024;
+const CLIPBOARD_TOOL_NAME = "copy_to_clipboard";
+const CLIPBOARD_TOOL_TITLE = "Copy to User Clipboard";
+const CLIPBOARD_TOOL_DESCRIPTION = `Copy text to the clipboard of the device the user is currently viewing this session from (their web browser, possibly a phone). Use this whenever the user wants a piece of text handed to them \u2014 not only when they literally say "clipboard". Trigger phrases include: "copy X", "copy that for me", "give me X", "send me X", "I need X on my phone", "\u590D\u5236\u7ED9\u6211", "\u628A X \u590D\u5236\u4E00\u4E0B", "\u53D1\u6211", "\u7ED9\u6211\u4E00\u4EFD", "\u590D\u5236\u5230\u526A\u5207\u677F/\u526A\u8D34\u677F". Typical payloads: command output, code snippets, tokens/keys, URLs, file contents, commit messages. The text is delivered to every device where the user has the web client open. Payloads larger than ${CLIPBOARD_MAX_BYTES / 1024}KB are truncated.`;
+function prepareClipboardText(input) {
+  const totalBytes = Buffer.byteLength(input, "utf8");
+  if (totalBytes <= CLIPBOARD_MAX_BYTES) {
+    return { text: input, truncated: false, totalBytes };
+  }
+  const sliced = Buffer.from(input, "utf8").subarray(0, CLIPBOARD_MAX_BYTES).toString("utf8");
+  let text = sliced;
+  if (text.endsWith("\uFFFD")) {
+    text = text.slice(0, -1);
+  }
+  const lastCode = text.charCodeAt(text.length - 1);
+  if (lastCode >= 55296 && lastCode <= 56319) {
+    text = text.slice(0, -1);
+  }
+  return { text, truncated: true, totalBytes };
+}
+
+exports.CLIPBOARD_MAX_BYTES = CLIPBOARD_MAX_BYTES;
+exports.CLIPBOARD_TOOL_DESCRIPTION = CLIPBOARD_TOOL_DESCRIPTION;
+exports.CLIPBOARD_TOOL_NAME = CLIPBOARD_TOOL_NAME;
+exports.CLIPBOARD_TOOL_TITLE = CLIPBOARD_TOOL_TITLE;
+exports.SandboxConfigSchema = SandboxConfigSchema;
+exports.acquireDaemonLock = acquireDaemonLock;
+exports.clearCredentials = clearCredentials;
+exports.clearDaemonState = clearDaemonState;
+exports.clearMachineId = clearMachineId;
+exports.configuration = configuration;
+exports.credentialRelayProblem = credentialRelayProblem;
+exports.decodeBase64 = decodeBase64;
+exports.decrypt = decrypt;
+exports.decryptBlob = decryptBlob;
+exports.decryptLegacy = decryptLegacy;
+exports.decryptWithDataKey = decryptWithDataKey;
+exports.deletePersistedSessions = deletePersistedSessions;
+exports.encodeBase64 = encodeBase64;
+exports.encodeBase64Url = encodeBase64Url;
+exports.encrypt = encrypt;
+exports.ensurePrivateDirectory = ensurePrivateDirectory;
+exports.ensurePrivateDirectorySync = ensurePrivateDirectorySync;
+exports.getLatestDaemonLog = getLatestDaemonLog;
+exports.getRandomBytes = getRandomBytes;
+exports.hardenPrivateFile = hardenPrivateFile;
+exports.hardenPrivateFileSync = hardenPrivateFileSync;
+exports.libsodiumEncryptForPublicKey = libsodiumEncryptForPublicKey;
+exports.libsodiumPublicKeyFromSecretKey = libsodiumPublicKeyFromSecretKey;
+exports.logger = logger;
+exports.normalizeHttpEndpoint = normalizeHttpEndpoint;
+exports.packageJson = packageJson;
+exports.persistSession = persistSession;
+exports.persistence = persistence;
+exports.prepareClipboardText = prepareClipboardText;
+exports.readCredentials = readCredentials;
+exports.readCredentialsForConfiguredRelay = readCredentialsForConfiguredRelay;
+exports.readDaemonState = readDaemonState;
+exports.readPersistedSessions = readPersistedSessions;
+exports.readSettings = readSettings;
+exports.readSettingsOutcome = readSettingsOutcome;
+exports.readTrackedClaudeSessionIds = readTrackedClaudeSessionIds;
+exports.redactLogValue = redactLogValue;
+exports.releaseDaemonLock = releaseDaemonLock;
+exports.updateSettings = updateSettings;
+exports.writeCredentialsDataKey = writeCredentialsDataKey;
+exports.writeCredentialsLegacy = writeCredentialsLegacy;
+exports.writeDaemonState = writeDaemonState;
+exports.writePrivateFileSync = writePrivateFileSync;
+exports.writeSettings = writeSettings;