very-happy-cli 0.2.124 → 0.2.125

package/dist/limits-FjbPJPsF.mjs

@@ -0,0 +1,1129 @@
+import { mkdir, chmod, writeFile, readFile, open, unlink, stat, rename } from 'node:fs/promises';
+import { mkdirSync, chmodSync, readdirSync, statSync, appendFileSync, writeFileSync, existsSync, readFileSync, constants, unlinkSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
+import * as z from 'zod';
+import { randomBytes, createCipheriv, createDecipheriv, createHash } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import chalk from 'chalk';
+import { inspect } from 'node:util';
+
+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) {
+  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();
+
+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(randomBytes(size));
+}
+function libsodiumPublicKeyFromSecretKey(seed) {
+  const hashedSeed = new Uint8Array(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 = 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 = 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 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 : 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 (!existsSync(logsDir)) {
+      return [];
+    }
+    const logs = readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = join(logsDir, file);
+      const stats = 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 && existsSync(state.daemonLogPath)) {
+        const stats = statSync(state.daemonLogPath);
+        const persisted = {
+          file: 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.object({
+  enabled: z.boolean().default(false),
+  workspaceRoot: z.string().optional(),
+  sessionIsolation: z.enum(["strict", "workspace", "custom"]).default("workspace"),
+  customWritePaths: z.array(z.string()).default([]),
+  denyReadPaths: z.array(z.string()).default(["~/.ssh", "~/.aws", "~/.gnupg"]),
+  extraWritePaths: z.array(z.string()).default(["/tmp"]),
+  denyWritePaths: z.array(z.string()).default([".env"]),
+  networkMode: z.enum(["blocked", "allowed", "custom"]).default("allowed"),
+  allowedDomains: z.array(z.string()).default([]),
+  deniedDomains: z.array(z.string()).default([]),
+  allowLocalBinding: z.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 (!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 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 open(lockFile, constants.O_CREAT | constants.O_EXCL | 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 stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await 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 rename(tmpFile, configuration.settingsFile);
+    await hardenPrivateFile(configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z.object({
+  token: z.string(),
+  authServerUrl: z.string().optional(),
+  secret: z.string().base64().nullish(),
+  // Legacy
+  encryption: z.object({
+    publicKey: z.string().base64(),
+    machineKey: z.string().base64()
+  }).nullish()
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await 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 (existsSync(configuration.privateKeyFile)) {
+    await unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await 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 (existsSync(configuration.daemonStateFile)) {
+    await unlink(configuration.daemonStateFile);
+  }
+  if (existsSync(configuration.daemonLockFile)) {
+    try {
+      await unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await open(
+        configuration.daemonLockFile,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+        PRIVATE_FILE_MODE
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              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 (existsSync(configuration.daemonLockFile)) {
+      unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+const SESSION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function readPersistedSessions() {
+  try {
+    if (!existsSync(configuration.sessionsFile)) return {};
+    const data = JSON.parse(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 (!existsSync(configuration.sessionsFile)) return [];
+    const data = JSON.parse(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));
+    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));
+    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 };
+}
+
+export { clearDaemonState as A, ensurePrivateDirectory as B, CLIPBOARD_TOOL_NAME as C, hardenPrivateFile as D, readCredentials as E, readSettingsOutcome as F, updateSettings as G, encodeBase64Url as H, writeCredentialsLegacy as I, writeCredentialsDataKey as J, decryptWithDataKey as K, decryptLegacy as L, persistSession as M, acquireDaemonLock as N, deletePersistedSessions as O, writeDaemonState as P, writeSettings as Q, releaseDaemonLock as R, clearCredentials as S, clearMachineId as T, SandboxConfigSchema as U, getLatestDaemonLog as V, persistence as W, CLIPBOARD_TOOL_TITLE as a, CLIPBOARD_TOOL_DESCRIPTION as b, configuration as c, CLIPBOARD_MAX_BYTES as d, ensurePrivateDirectorySync as e, readSettings as f, encodeBase64 as g, hardenPrivateFileSync as h, readCredentialsForConfiguredRelay as i, encrypt as j, decrypt as k, logger as l, decodeBase64 as m, normalizeHttpEndpoint as n, decryptBlob as o, packageJson as p, prepareClipboardText as q, readPersistedSessions as r, credentialRelayProblem as s, readTrackedClaudeSessionIds as t, libsodiumEncryptForPublicKey as u, libsodiumPublicKeyFromSecretKey as v, writePrivateFileSync as w, getRandomBytes as x, redactLogValue as y, readDaemonState as z };