@zonease/happy 0.6.37 → 0.6.39

package/dist/persistence-BFjvtUad.mjs

@@ -0,0 +1,944 @@
+import { readFile, open, stat, unlink, mkdir, writeFile, rename } from 'node:fs/promises';
+import { existsSync, mkdirSync, readdirSync, statSync, constants, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
+import * as z from 'zod';
+import { randomBytes, createHash, createCipheriv, createDecipheriv } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import chalk from 'chalk';
+import { appendFileSync } from 'fs';
+
+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(/^~/, 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.sessionKeysDir = 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 (!existsSync(this.happyHomeDir)) {
+      mkdirSync(this.happyHomeDir, { recursive: true });
+    }
+    if (!existsSync(this.logsDir)) {
+      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 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 {
+      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 (!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;
+}
+
+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(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 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);
+  }
+}
+
+const AnthropicConfigSchema = z.object({
+  baseUrl: z.string().url().optional(),
+  authToken: z.string().optional(),
+  model: z.string().optional()
+});
+const OpenAIConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().url().optional(),
+  model: z.string().optional()
+});
+const AzureOpenAIConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  endpoint: z.string().url().optional(),
+  apiVersion: z.string().optional(),
+  deploymentName: z.string().optional()
+});
+const TogetherAIConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  model: z.string().optional()
+});
+const TmuxConfigSchema = z.object({
+  sessionName: z.string().optional(),
+  tmpDir: z.string().optional(),
+  updateEnvironment: z.boolean().optional()
+});
+const EnvironmentVariableSchema = z.object({
+  name: z.string().regex(/^[A-Z_][A-Z0-9_]*$/, "Invalid environment variable name"),
+  value: z.string()
+});
+const ProfileCompatibilitySchema = z.object({
+  claude: z.boolean().default(true),
+  codex: z.boolean().default(true),
+  gemini: z.boolean().default(true)
+});
+const AIBackendProfileSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).max(100),
+  description: z.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.array(EnvironmentVariableSchema).default([]),
+  // Default session type for this profile
+  defaultSessionType: z.enum(["simple", "worktree"]).optional(),
+  // Default permission mode for this profile (supports both Claude and Codex modes)
+  defaultPermissionMode: z.enum([
+    "default",
+    "acceptEdits",
+    "bypassPermissions",
+    "plan",
+    // Claude modes
+    "read-only",
+    "safe-yolo",
+    "yolo"
+    // Codex modes
+  ]).optional(),
+  // Default model mode for this profile
+  defaultModelMode: z.string().optional(),
+  // Compatibility metadata
+  compatibility: ProfileCompatibilitySchema.default({ claude: true, codex: true, gemini: true }),
+  // Built-in profile indicator
+  isBuiltIn: z.boolean().default(false),
+  // Metadata
+  createdAt: z.number().default(() => Date.now()),
+  updatedAt: z.number().default(() => Date.now()),
+  version: z.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 (!existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    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, 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 open(lockFile, constants.O_CREAT | constants.O_EXCL | 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 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 current = await readSettings() || { ...defaultSettings };
+    const updated = await updater(current);
+    if (!existsSync(configuration.happyHomeDir)) {
+      await mkdir(configuration.happyHomeDir, { recursive: true });
+    }
+    await writeFile(tmpFile, JSON.stringify(updated, null, 2));
+    await rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z.object({
+  token: z.string(),
+  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,
+        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 (!existsSync(configuration.happyHomeDir)) {
+    await mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await writeFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+async function writeCredentialsDataKey(credentials) {
+  if (!existsSync(configuration.happyHomeDir)) {
+    await mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await writeFile(configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
+    token: credentials.token
+  }, 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) {
+  writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+}
+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
+      );
+      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 {
+  }
+}
+
+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
+});
+
+export { getProfileEnvironmentVariables as A, encryptLegacy as B, getRandomBytes as C, libsodiumEncryptForPublicKey as D, logger$1 as E, persistence as F, readSettings as a, clearCredentials as b, configuration as c, clearMachineId as d, decodeBase64 as e, encodeBase64 as f, encrypt as g, decrypt as h, isDebug as i, readDaemonState as j, encryptWithDataKey as k, logger as l, decryptWithDataKey as m, clearDaemonState as n, libsodiumPublicKeyFromSecretKey as o, packageJson as p, decryptLegacy as q, readCredentials as r, encodeBase64Url as s, writeCredentialsLegacy as t, updateSettings as u, acquireDaemonLock as v, writeCredentialsDataKey as w, writeDaemonState as x, releaseDaemonLock as y, validateProfileForAgent as z };