@zonease/happy 0.6.37 → 0.6.39

package/dist/persistence-JLUn_Nou.cjs

@@ -0,0 +1,996 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var 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 fs$1 = require('fs');
+
+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);
+
+const DEBUG_TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true"]);
+function isDebug() {
+  return DEBUG_TRUE_VALUES.has(process.env.DEBUG?.toLowerCase() ?? "");
+}
+
+var name = "@zonease/happy";
+var version = "0.6.39";
+var description = "Mobile and Web client for Claude Code, Codex, and Gemini";
+var author = "ZonEaseTech";
+var license = "MIT";
+var type = "module";
+var homepage = "https://github.com/ZonEaseTech/happy-wfs";
+var bugs = "https://github.com/ZonEaseTech/happy-wfs/issues";
+var repository = {
+	type: "git",
+	url: "git+https://github.com/ZonEaseTech/happy-wfs.git",
+	directory: "packages/happy-cli"
+};
+var bin = {
+	happy: "./bin/happy.mjs",
+	"happy-mcp": "./bin/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",
+	"package.json"
+];
+var scripts = {
+	"why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
+	typecheck: "tsc --noEmit",
+	build: "shx rm -rf dist && tsc --noEmit && pkgroll",
+	test: "$npm_execpath run build && vitest run",
+	"test:integration": "$npm_execpath run build && vitest run --config vitest.integration.config.ts",
+	start: "$npm_execpath run build && node ./bin/happy.mjs",
+	dev: "tsx src/index.ts",
+	"dev:local-server": "$npm_execpath run build && tsx --env-file .env.dev-local-server src/index.ts",
+	"dev:integration-test-env": "$npm_execpath run build && tsx --env-file .env.integration-test src/index.ts",
+	prepublishOnly: "$npm_execpath run build && $npm_execpath test",
+	release: "$npm_execpath install && release-it",
+	postinstall: "node scripts/unpack-tools.cjs",
+	"// ==== Dev/Stable Variant Management ====": "",
+	stable: "node scripts/env-wrapper.cjs stable",
+	"dev:variant": "node scripts/env-wrapper.cjs dev",
+	"// ==== Stable Version Quick Commands ====": "",
+	"stable:daemon:start": "node scripts/env-wrapper.cjs stable daemon start",
+	"stable:daemon:stop": "node scripts/env-wrapper.cjs stable daemon stop",
+	"stable:daemon:status": "node scripts/env-wrapper.cjs stable daemon status",
+	"stable:auth": "node scripts/env-wrapper.cjs stable auth",
+	"// ==== Development Version Quick Commands ====": "",
+	"dev:daemon:start": "node scripts/env-wrapper.cjs dev daemon start",
+	"dev:daemon:stop": "node scripts/env-wrapper.cjs dev daemon stop",
+	"dev:daemon:status": "node scripts/env-wrapper.cjs dev daemon status",
+	"dev:auth": "node scripts/env-wrapper.cjs dev auth",
+	"// ==== Setup ====": "",
+	"setup:dev": "node scripts/setup-dev.cjs",
+	doctor: "node scripts/env-wrapper.cjs stable doctor",
+	"// ==== Development Linking ====": "",
+	"link:dev": "node scripts/link-dev.cjs",
+	"unlink:dev": "node scripts/link-dev.cjs unlink"
+};
+var dependencies = {
+	"@agentclientprotocol/sdk": "^0.14.1",
+	"@paralleldrive/cuid2": "^2.2.2",
+	"@modelcontextprotocol/sdk": "^1.25.3",
+	"@stablelib/base64": "^2.0.1",
+	"@stablelib/hex": "^2.0.1",
+	"@types/cross-spawn": "^6.0.6",
+	"@types/http-proxy": "^1.17.17",
+	"@types/qrcode-terminal": "^0.12.2",
+	"@types/react": "^19.2.7",
+	"@types/tmp": "^0.2.6",
+	"@types/ws": "^8.18.1",
+	ai: "^5.0.107",
+	axios: "^1.13.2",
+	chalk: "^5.6.2",
+	"cross-spawn": "^7.0.6",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "^5.6.2",
+	"fastify-type-provider-zod": "4.0.2",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.5",
+	ink: "^6.5.1",
+	open: "^10.2.0",
+	"ps-list": "^8.1.1",
+	"qrcode-terminal": "^0.12.0",
+	react: "^19.2.0",
+	"socket.io-client": "^4.8.1",
+	tar: "^7.5.2",
+	tmp: "^0.2.5",
+	tweetnacl: "^1.0.3",
+	ws: "^8.19.0",
+	zod: "3.25.76"
+};
+var devDependencies = {
+	"@eslint/compat": "^1",
+	"@types/node": ">=20",
+	"cross-env": "^10.1.0",
+	dotenv: "^16.6.1",
+	eslint: "^9",
+	"eslint-config-prettier": "^10",
+	pkgroll: "^2.14.2",
+	"release-it": "^19.0.6",
+	shx: "^0.3.3",
+	"ts-node": "^10",
+	tsx: "^4.20.6",
+	typescript: "5.9.3",
+	vitest: "^3.2.4",
+	"happy-wire": "*"
+};
+var resolutions = {
+	"whatwg-url": "14.2.0",
+	"parse-path": "7.0.3",
+	"@types/parse-path": "7.0.3"
+};
+var publishConfig = {
+	registry: "https://registry.npmjs.org",
+	access: "public"
+};
+var packageManager = "yarn@1.22.22";
+var optionalDependencies = {
+	"node-pty": "^1.0.0",
+	"@zonease/happy-tools-arm64-darwin": "1.0.0",
+	"@zonease/happy-tools-x64-darwin": "1.0.0",
+	"@zonease/happy-tools-arm64-linux": "1.0.0",
+	"@zonease/happy-tools-x64-linux": "1.0.0",
+	"@zonease/happy-tools-x64-win32": "1.0.0",
+	"@zonease/happy-tools-arm64-win32": "1.0.0"
+};
+var packageJson = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	license: license,
+	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,
+	devDependencies: devDependencies,
+	resolutions: resolutions,
+	publishConfig: publishConfig,
+	packageManager: packageManager,
+	optionalDependencies: optionalDependencies
+};
+
+class Configuration {
+  serverUrl;
+  webappUrl;
+  isDaemonProcess;
+  // Directories and paths (from persistence)
+  happyHomeDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  daemonStateFile;
+  daemonLockFile;
+  sessionKeysDir;
+  currentCliVersion;
+  isExperimentalEnabled;
+  disableCaffeinate;
+  constructor() {
+    this.serverUrl = process.env.HAPPY_SERVER_URL || "https://api-happy.zonease.org";
+    this.webappUrl = process.env.HAPPY_WEBAPP_URL || "https://happy.zonease.org";
+    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.sessionKeysDir = path.join(this.happyHomeDir, "session-keys");
+    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 (variant === "dev" && !this.happyHomeDir.includes("dev")) {
+      console.warn('\u26A0\uFE0F  WARNING: HAPPY_VARIANT=dev but HAPPY_HOME_DIR does not contain "dev"');
+      console.warn(`   Current: ${this.happyHomeDir}`);
+      console.warn(`   Expected: Should contain "dev" (e.g., ~/.happy-dev)`);
+    }
+    if (!this.isDaemonProcess && variant === "dev") {
+      console.log("\x1B[33m\u{1F527} DEV MODE\x1B[0m - Data: " + this.happyHomeDir);
+    }
+    if (!fs.existsSync(this.happyHomeDir)) {
+      fs.mkdirSync(this.happyHomeDir, { recursive: true });
+    }
+    if (!fs.existsSync(this.logsDir)) {
+      fs.mkdirSync(this.logsDir, { recursive: true });
+    }
+  }
+}
+const configuration = new Configuration();
+
+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);
+}
+class Logger {
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && process.env.HAPPY_SERVER_URL) {
+      this.dangerouslyUnencryptedServerLoggingUrl = process.env.HAPPY_SERVER_URL;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
+  }
+  dangerouslyUnencryptedServerLoggingUrl;
+  // 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 (!isDebug()) {
+      this.debug(`In production, skipping message inspection`);
+    }
+    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(object);
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
+  }
+  info(message, ...args) {
+    this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
+  }
+  infoDeveloper(message, ...args) {
+    this.debug(message, ...args);
+    if (isDebug()) {
+      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) {
+    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" },
+        body: JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level,
+          message: `${message} ${args.map(
+            (a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)
+          ).join(" ")}`,
+          source: "cli",
+          platform: process.platform
+        })
+      });
+    } catch (error) {
+    }
+  }
+  logToFile(prefix, message, ...args) {
+    const logLine = `${prefix} ${message} ${args.map((arg) => {
+      if (typeof arg === "string") return arg;
+      if (arg instanceof Error) return `${arg.message}
+${arg.stack ?? ""}`;
+      return JSON.stringify(arg);
+    }).join(" ")}
+`;
+    if (this.dangerouslyUnencryptedServerLoggingUrl) {
+      let level = "info";
+      if (prefix.includes(this.localTimezoneTimestamp())) {
+        level = "debug";
+      }
+      this.sendToRemoteServer(level, message, ...args).catch(() => {
+      });
+    }
+    try {
+      fs$1.appendFileSync(this.logFilePath, logLine);
+    } catch (appendError) {
+      if (isDebug()) {
+        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 (!fs.existsSync(logsDir)) {
+      return [];
+    }
+    const logs = fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = path.join(logsDir, file);
+      const stats = 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 && fs.existsSync(state.daemonLogPath)) {
+        const stats = 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;
+}
+
+var logger$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getLatestDaemonLog: getLatestDaemonLog,
+    listDaemonLogFiles: listDaemonLogFiles,
+    logger: logger
+});
+
+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 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);
+  }
+}
+
+const AnthropicConfigSchema = z__namespace.object({
+  baseUrl: z__namespace.string().url().optional(),
+  authToken: z__namespace.string().optional(),
+  model: z__namespace.string().optional()
+});
+const OpenAIConfigSchema = z__namespace.object({
+  apiKey: z__namespace.string().optional(),
+  baseUrl: z__namespace.string().url().optional(),
+  model: z__namespace.string().optional()
+});
+const AzureOpenAIConfigSchema = z__namespace.object({
+  apiKey: z__namespace.string().optional(),
+  endpoint: z__namespace.string().url().optional(),
+  apiVersion: z__namespace.string().optional(),
+  deploymentName: z__namespace.string().optional()
+});
+const TogetherAIConfigSchema = z__namespace.object({
+  apiKey: z__namespace.string().optional(),
+  model: z__namespace.string().optional()
+});
+const TmuxConfigSchema = z__namespace.object({
+  sessionName: z__namespace.string().optional(),
+  tmpDir: z__namespace.string().optional(),
+  updateEnvironment: z__namespace.boolean().optional()
+});
+const EnvironmentVariableSchema = z__namespace.object({
+  name: z__namespace.string().regex(/^[A-Z_][A-Z0-9_]*$/, "Invalid environment variable name"),
+  value: z__namespace.string()
+});
+const ProfileCompatibilitySchema = z__namespace.object({
+  claude: z__namespace.boolean().default(true),
+  codex: z__namespace.boolean().default(true),
+  gemini: z__namespace.boolean().default(true)
+});
+const AIBackendProfileSchema = z__namespace.object({
+  id: z__namespace.string().uuid(),
+  name: z__namespace.string().min(1).max(100),
+  description: z__namespace.string().max(500).optional(),
+  // Agent-specific configurations
+  anthropicConfig: AnthropicConfigSchema.optional(),
+  openaiConfig: OpenAIConfigSchema.optional(),
+  azureOpenAIConfig: AzureOpenAIConfigSchema.optional(),
+  togetherAIConfig: TogetherAIConfigSchema.optional(),
+  // Tmux configuration
+  tmuxConfig: TmuxConfigSchema.optional(),
+  // Environment variables (validated)
+  environmentVariables: z__namespace.array(EnvironmentVariableSchema).default([]),
+  // Default session type for this profile
+  defaultSessionType: z__namespace.enum(["simple", "worktree"]).optional(),
+  // Default permission mode for this profile (supports both Claude and Codex modes)
+  defaultPermissionMode: z__namespace.enum([
+    "default",
+    "acceptEdits",
+    "bypassPermissions",
+    "plan",
+    // Claude modes
+    "read-only",
+    "safe-yolo",
+    "yolo"
+    // Codex modes
+  ]).optional(),
+  // Default model mode for this profile
+  defaultModelMode: z__namespace.string().optional(),
+  // Compatibility metadata
+  compatibility: ProfileCompatibilitySchema.default({ claude: true, codex: true, gemini: true }),
+  // Built-in profile indicator
+  isBuiltIn: z__namespace.boolean().default(false),
+  // Metadata
+  createdAt: z__namespace.number().default(() => Date.now()),
+  updatedAt: z__namespace.number().default(() => Date.now()),
+  version: z__namespace.string().default("1.0.0")
+});
+function validateProfileForAgent(profile, agent) {
+  return profile.compatibility[agent];
+}
+function getProfileEnvironmentVariables(profile) {
+  const envVars = {};
+  profile.environmentVariables.forEach((envVar) => {
+    envVars[envVar.name] = envVar.value;
+  });
+  if (profile.anthropicConfig) {
+    if (profile.anthropicConfig.baseUrl) envVars.ANTHROPIC_BASE_URL = profile.anthropicConfig.baseUrl;
+    if (profile.anthropicConfig.authToken) envVars.ANTHROPIC_AUTH_TOKEN = profile.anthropicConfig.authToken;
+    if (profile.anthropicConfig.model) envVars.ANTHROPIC_MODEL = profile.anthropicConfig.model;
+  }
+  if (profile.openaiConfig) {
+    if (profile.openaiConfig.apiKey) envVars.OPENAI_API_KEY = profile.openaiConfig.apiKey;
+    if (profile.openaiConfig.baseUrl) envVars.OPENAI_BASE_URL = profile.openaiConfig.baseUrl;
+    if (profile.openaiConfig.model) envVars.OPENAI_MODEL = profile.openaiConfig.model;
+  }
+  if (profile.azureOpenAIConfig) {
+    if (profile.azureOpenAIConfig.apiKey) envVars.AZURE_OPENAI_API_KEY = profile.azureOpenAIConfig.apiKey;
+    if (profile.azureOpenAIConfig.endpoint) envVars.AZURE_OPENAI_ENDPOINT = profile.azureOpenAIConfig.endpoint;
+    if (profile.azureOpenAIConfig.apiVersion) envVars.AZURE_OPENAI_API_VERSION = profile.azureOpenAIConfig.apiVersion;
+    if (profile.azureOpenAIConfig.deploymentName) envVars.AZURE_OPENAI_DEPLOYMENT_NAME = profile.azureOpenAIConfig.deploymentName;
+  }
+  if (profile.togetherAIConfig) {
+    if (profile.togetherAIConfig.apiKey) envVars.TOGETHER_API_KEY = profile.togetherAIConfig.apiKey;
+    if (profile.togetherAIConfig.model) envVars.TOGETHER_MODEL = profile.togetherAIConfig.model;
+  }
+  if (profile.tmuxConfig) {
+    if (profile.tmuxConfig.sessionName !== void 0) envVars.TMUX_SESSION_NAME = profile.tmuxConfig.sessionName;
+    if (profile.tmuxConfig.tmpDir) envVars.TMUX_TMPDIR = profile.tmuxConfig.tmpDir;
+    if (profile.tmuxConfig.updateEnvironment !== void 0) {
+      envVars.TMUX_UPDATE_ENVIRONMENT = profile.tmuxConfig.updateEnvironment.toString();
+    }
+  }
+  return envVars;
+}
+const SUPPORTED_SCHEMA_VERSION = 2;
+const defaultSettings = {
+  schemaVersion: SUPPORTED_SCHEMA_VERSION,
+  onboardingCompleted: false,
+  profiles: [],
+  localEnvironmentVariables: {}
+};
+function migrateSettings(raw, fromVersion) {
+  let migrated = { ...raw };
+  if (fromVersion < 2) {
+    if (!migrated.profiles) {
+      migrated.profiles = [];
+    }
+    if (!migrated.localEnvironmentVariables) {
+      migrated.localEnvironmentVariables = {};
+    }
+    migrated.schemaVersion = 2;
+  }
+  return migrated;
+}
+async function readSettings() {
+  if (!fs.existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    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, schemaVersion);
+    if (migrated.profiles && Array.isArray(migrated.profiles)) {
+      const validProfiles = [];
+      for (const profile of migrated.profiles) {
+        try {
+          const validated = AIBackendProfileSchema.parse(profile);
+          validProfiles.push(validated);
+        } catch (error) {
+          logger.warn(
+            `\u26A0\uFE0F Invalid profile "${profile?.name || profile?.id || "unknown"}" - skipping. Error: ${error.message}`
+          );
+        }
+      }
+      migrated.profiles = validProfiles;
+    }
+    return { ...defaultSettings, ...migrated };
+  } catch (error) {
+    logger.warn(`Failed to read settings: ${error.message}`);
+    return { ...defaultSettings };
+  }
+}
+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, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
+      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 current = await readSettings() || { ...defaultSettings };
+    const updated = await updater(current);
+    if (!fs.existsSync(configuration.happyHomeDir)) {
+      await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+    }
+    await promises.writeFile(tmpFile, JSON.stringify(updated, null, 2));
+    await promises.rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await promises.unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z__namespace.object({
+  token: z__namespace.string(),
+  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 (!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,
+        encryption: {
+          type: "legacy",
+          secret: new Uint8Array(Buffer.from(credentials.secret, "base64"))
+        }
+      };
+    } else if (credentials.encryption) {
+      return {
+        token: credentials.token,
+        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 writeCredentialsLegacy(credentials) {
+  if (!fs.existsSync(configuration.happyHomeDir)) {
+    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+async function writeCredentialsDataKey(credentials) {
+  if (!fs.existsSync(configuration.happyHomeDir)) {
+    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
+    token: credentials.token
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (fs.existsSync(configuration.privateKeyFile)) {
+    await promises.unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!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) {
+  fs.writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearDaemonState() {
+  if (fs.existsSync(configuration.daemonStateFile)) {
+    await promises.unlink(configuration.daemonStateFile);
+  }
+  if (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,
+        fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = fs.readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              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 (fs.existsSync(configuration.daemonLockFile)) {
+      fs.unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+
+var persistence = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AIBackendProfileSchema: AIBackendProfileSchema,
+    SUPPORTED_SCHEMA_VERSION: SUPPORTED_SCHEMA_VERSION,
+    acquireDaemonLock: acquireDaemonLock,
+    clearCredentials: clearCredentials,
+    clearDaemonState: clearDaemonState,
+    clearMachineId: clearMachineId,
+    getProfileEnvironmentVariables: getProfileEnvironmentVariables,
+    readCredentials: readCredentials,
+    readDaemonState: readDaemonState,
+    readSettings: readSettings,
+    releaseDaemonLock: releaseDaemonLock,
+    updateSettings: updateSettings,
+    validateProfileForAgent: validateProfileForAgent,
+    writeCredentialsDataKey: writeCredentialsDataKey,
+    writeCredentialsLegacy: writeCredentialsLegacy,
+    writeDaemonState: writeDaemonState
+});
+
+exports.acquireDaemonLock = acquireDaemonLock;
+exports.clearCredentials = clearCredentials;
+exports.clearDaemonState = clearDaemonState;
+exports.clearMachineId = clearMachineId;
+exports.configuration = configuration;
+exports.decodeBase64 = decodeBase64;
+exports.decrypt = decrypt;
+exports.decryptLegacy = decryptLegacy;
+exports.decryptWithDataKey = decryptWithDataKey;
+exports.encodeBase64 = encodeBase64;
+exports.encodeBase64Url = encodeBase64Url;
+exports.encrypt = encrypt;
+exports.encryptLegacy = encryptLegacy;
+exports.encryptWithDataKey = encryptWithDataKey;
+exports.getProfileEnvironmentVariables = getProfileEnvironmentVariables;
+exports.getRandomBytes = getRandomBytes;
+exports.isDebug = isDebug;
+exports.libsodiumEncryptForPublicKey = libsodiumEncryptForPublicKey;
+exports.libsodiumPublicKeyFromSecretKey = libsodiumPublicKeyFromSecretKey;
+exports.logger = logger;
+exports.logger$1 = logger$1;
+exports.packageJson = packageJson;
+exports.persistence = persistence;
+exports.readCredentials = readCredentials;
+exports.readDaemonState = readDaemonState;
+exports.readSettings = readSettings;
+exports.releaseDaemonLock = releaseDaemonLock;
+exports.updateSettings = updateSettings;
+exports.validateProfileForAgent = validateProfileForAgent;
+exports.writeCredentialsDataKey = writeCredentialsDataKey;
+exports.writeCredentialsLegacy = writeCredentialsLegacy;
+exports.writeDaemonState = writeDaemonState;