very-happy-cli 0.2.124 → 0.2.126

package/dist/{types-gDOmwOKw.mjs → types-n_VWu9qe.mjs}

@@ -1,625 +1,31 @@
 import axios from 'axios';
-import chalk from 'chalk';
-import { inspect } from 'node:util';
-import { mkdirSync, chmodSync, readdirSync, statSync, appendFileSync, writeFileSync, existsSync, readFileSync, constants, unlinkSync, renameSync, accessSync, createReadStream, createWriteStream } from 'node:fs';
-import os$1, { homedir } from 'node:os';
-import { join, basename, isAbsolute, resolve as resolve$1 } from 'node:path';
-import { mkdir, chmod, writeFile, stat as stat$1, readdir as readdir$1, lstat, open, unlink as unlink$1, readFile as readFile$1, rename as rename$1, copyFile } from 'node:fs/promises';
+import { l as logger, g as encodeBase64, j as encrypt, k as decrypt, m as decodeBase64, c as configuration, o as decryptBlob, q as prepareClipboardText, f as readSettings, r as readPersistedSessions, s as credentialRelayProblem, p as packageJson, t as readTrackedClaudeSessionIds, u as libsodiumEncryptForPublicKey, v as libsodiumPublicKeyFromSecretKey, x as getRandomBytes, y as redactLogValue } from './limits-DlbYYtOw.mjs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import * as z from 'zod';
 import { z as z$1 } from 'zod';
 import { isCuid, createId } from '@paralleldrive/cuid2';
-import { randomBytes, createCipheriv, createDecipheriv, createHash, createHmac, randomUUID as randomUUID$1 } from 'node:crypto';
-import tweetnacl from 'tweetnacl';
-import { p as prepareClipboardText } from './limits-CwFb5S2b.mjs';
+import { createHmac, randomUUID as randomUUID$1, randomBytes, createHash as createHash$1 } from 'node:crypto';
 import { spawn as spawn$1, exec, execSync } from 'child_process';
 import { promisify } from 'util';
-import { mkdir as mkdir$1, writeFile as writeFile$1, appendFile, stat, rename, unlink, readdir, readFile } from 'fs/promises';
-import { randomUUID, createHash as createHash$1 } from 'crypto';
-import { dirname, resolve, join as join$1, sep } from 'path';
+import { mkdir, writeFile, appendFile, stat, rename, unlink, readdir, readFile } from 'fs/promises';
+import { randomUUID, createHash } from 'crypto';
+import { dirname, resolve, join, sep } from 'path';
 import { spawn } from 'cross-spawn';
 import { fileURLToPath } from 'url';
 import os, { platform } from 'os';
+import { stat as stat$1, readdir as readdir$1, lstat, open, copyFile, unlink as unlink$1, readFile as readFile$1, rename as rename$1, writeFile as writeFile$1 } from 'node:fs/promises';
+import { join as join$1, isAbsolute, resolve as resolve$1 } from 'node:path';
+import os$1, { homedir } from 'node:os';
 import { spawn as spawn$2, spawnSync, execSync as execSync$1 } from 'node:child_process';
 import * as pty from 'node-pty';
+import { existsSync, statSync, writeFileSync, unlinkSync, readFileSync, mkdirSync, accessSync, constants, createReadStream, createWriteStream } from 'node:fs';
 import { existsSync as existsSync$1 } from 'fs';
+import tweetnacl from 'tweetnacl';
 import { createInterface } from 'node:readline';
 import { SandboxManager } from '@anthropic-ai/sandbox-runtime';
 import { Expo } from 'expo-server-sdk';
-
-var name = "very-happy-cli";
-var version = "0.2.124";
-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.124",
-	"very-happy-tools-x64-darwin": "0.2.124",
-	"very-happy-tools-arm64-linux": "0.2.124",
-	"very-happy-tools-x64-linux": "0.2.124",
-	"very-happy-tools-arm64-win32": "0.2.124",
-	"very-happy-tools-x64-win32": "0.2.124"
-};
-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 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;
-}
+import chalk from 'chalk';
 
 const sessionRoleSchema = z.enum(["user", "agent"]);
 const sessionTextEventSchema = z.object({
@@ -1026,8 +432,36 @@ const ConnectionDiagnosticEventSchema = z$1.object({
 z$1.object({
   events: z$1.array(ConnectionDiagnosticEventSchema).min(1).max(32)
 }).strict();
+const TeamPermissionModeSchema = z$1.enum(["default", "bypassPermissions"]);
+const id = z$1.string().min(1).max(128);
+const text = z$1.string().min(1).max(32e3);
+const TeamActionSchema = z$1.discriminatedUnion("type", [
+  z$1.object({ type: z$1.literal("archive") }),
+  z$1.object({ type: z$1.literal("set-permission-mode"), permissionMode: TeamPermissionModeSchema }),
+  z$1.object({ type: z$1.literal("schedule-create"), name: id, botId: id, body: text, runAt: z$1.number().int().positive().max(864e13), intervalMs: z$1.number().int().min(6e4).max(366 * 864e5).optional() }),
+  z$1.object({ type: z$1.literal("schedule-pause"), scheduleId: id, version: z$1.number().int().positive() }),
+  z$1.object({ type: z$1.literal("schedule-resume"), scheduleId: id, version: z$1.number().int().positive() }),
+  z$1.object({ type: z$1.literal("schedule-cancel"), scheduleId: id, version: z$1.number().int().positive() }),
+  z$1.object({ type: z$1.literal("reconcile-operation"), operationId: id, claimId: id, note: z$1.string().trim().min(1).max(4e3) }),
+  z$1.object({ type: z$1.literal("join"), name: id, sessionId: id, botId: id.optional() }),
+  z$1.object({ type: z$1.literal("delegate"), goal: text, acceptance: z$1.array(text).min(1).max(32), parentTaskId: id.optional(), assigneeBotId: id.optional(), botName: id.optional(), directory: z$1.string().min(1).max(4096).optional(), assistant: z$1.enum(["claude", "codex", "pi-acp"]).optional() }),
+  z$1.object({ type: z$1.literal("message"), taskId: id, body: text, recipientBotId: id.optional() }),
+  z$1.object({ type: z$1.literal("submit"), taskId: id, attemptId: id, goalVersion: z$1.number().int().positive(), result: text }),
+  z$1.object({ type: z$1.literal("accept"), taskId: id, attemptId: id, goalVersion: z$1.number().int().positive() }),
+  z$1.object({ type: z$1.literal("return"), taskId: id, attemptId: id, goalVersion: z$1.number().int().positive(), reason: text }),
+  z$1.object({ type: z$1.literal("cancel"), taskId: id, attemptId: id, goalVersion: z$1.number().int().positive(), reason: text }),
+  z$1.object({ type: z$1.literal("handoff"), taskId: id, attemptId: id, goalVersion: z$1.number().int().positive(), assigneeBotId: id }),
+  z$1.object({ type: z$1.literal("claim-operation"), operationId: id, machineId: id }),
+  z$1.object({ type: z$1.literal("complete-operation"), operationId: id, machineId: id, claimId: id, sessionId: id.optional() }),
+  z$1.object({ type: z$1.literal("fail-operation"), operationId: id, machineId: id, claimId: id, error: text, unknown: z$1.boolean().optional() }),
+  z$1.object({ type: z$1.literal("session-event"), sessionId: id, event: z$1.enum(["idle", "blocked", "exited"]) }),
+  z$1.object({ type: z$1.literal("message-delivered"), messageId: id, recipientBotId: id, generation: z$1.number().int().positive(), sessionId: id })
+]);
+z$1.object({ requestId: id, action: TeamActionSchema });
+z$1.object({ name: id, machineId: id, requestId: id.optional() });
 
 z$1.object({
+  teamsVersion: z$1.number().int().positive().optional(),
   host: z$1.string(),
   platform: z$1.string(),
   happyCliVersion: z$1.string(),
@@ -1302,125 +736,6 @@ const AgentMessageSchema = z$1.object({
 });
 z$1.union([UserMessageSchema, AgentMessageSchema]);
 
-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);
-  }
-}
-
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1693,7 +1008,7 @@ function projectPath() {
 }
 
 function run$1(args, options) {
-  const RUNNER_PATH = resolve(join$1(projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  const RUNNER_PATH = resolve(join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
     const child = spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -1724,7 +1039,7 @@ function run$1(args, options) {
 function getBinaryPath() {
   const platformName = platform();
   const binaryName = platformName === "win32" ? "difft.exe" : "difft";
-  return resolve(join$1(projectPath(), "tools", "unpacked", binaryName));
+  return resolve(join(projectPath(), "tools", "unpacked", binaryName));
 }
 function run(args, options) {
   const binaryPath = getBinaryPath();
@@ -1836,7 +1151,7 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
     const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
     await Promise.all(entries.map(async (entry) => {
       if (!entry.isFile() || !/^\..+\.[A-Za-z0-9_-]{8,80}\.part$/.test(entry.name)) return;
-      const path = join$1(dir, entry.name);
+      const path = join(dir, entry.name);
       const fileStat = await stat(path).catch(() => null);
       if (fileStat && fileStat.mtimeMs < cutoff) await unlink(path).catch(() => {
       });
@@ -1846,13 +1161,13 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
     let tempPath = null;
     try {
       const buffer = decodeUploadBase64(data.content, MAX_USER_UPLOAD_BYTES);
-      const dir = join$1(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
-      await mkdir$1(dir, { recursive: true });
+      const dir = join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
+      await mkdir(dir, { recursive: true });
       const name = safeFileName(data.name);
       const token = randomUUID().replace(/-/g, "").slice(0, 12);
-      const target = join$1(dir, uniqueFileName(name, token));
-      tempPath = join$1(dir, `.${name}.legacy_${randomUUID().replace(/-/g, "")}.part`);
-      await writeFile$1(tempPath, buffer, { flag: "wx" });
+      const target = join(dir, uniqueFileName(name, token));
+      tempPath = join(dir, `.${name}.legacy_${randomUUID().replace(/-/g, "")}.part`);
+      await writeFile(tempPath, buffer, { flag: "wx" });
       await rename(tempPath, target);
       tempPath = null;
       return { success: true, path: target, pathQuoteStyle, size: buffer.length };
@@ -1872,13 +1187,13 @@ function createUploadFileHandlers(happyHomeDir, now = Date.now, pathQuoteStyle =
         }
         if (active.has(uploadId)) throw new Error("Upload id is already active");
         if (active.size >= MAX_ACTIVE_UPLOADS) throw new Error("Too many active uploads");
-        const dir = join$1(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
-        await mkdir$1(dir, { recursive: true });
+        const dir = join(happyHomeDir, "uploads", safeSegment(data.subdir, "misc", 80));
+        await mkdir(dir, { recursive: true });
         await sweepExpiredFiles(dir);
         const name = safeFileName(data.name);
-        const targetPath = join$1(dir, uniqueFileName(name, randomUUID().replace(/-/g, "").slice(0, 12)));
-        const tempPath = join$1(dir, `.${name}.${uploadId}.part`);
-        await writeFile$1(tempPath, Buffer.alloc(0), { flag: "wx" });
+        const targetPath = join(dir, uniqueFileName(name, randomUUID().replace(/-/g, "").slice(0, 12)));
+        const tempPath = join(dir, `.${name}.${uploadId}.part`);
+        await writeFile(tempPath, Buffer.alloc(0), { flag: "wx" });
         active.set(uploadId, { tempPath, targetPath, totalSize: data.totalSize, received: 0, touchedAt: now() });
         return { success: true, size: 0 };
       }
@@ -2014,7 +1329,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       if (data.expectedHash !== null && data.expectedHash !== void 0) {
         try {
           const existingBuffer = await readFile(validation.resolvedPath);
-          const existingHash = createHash$1("sha256").update(existingBuffer).digest("hex");
+          const existingHash = createHash("sha256").update(existingBuffer).digest("hex");
           if (existingHash !== data.expectedHash) {
             return {
               success: false,
@@ -2046,8 +1361,8 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
         }
       }
       const buffer = Buffer.from(data.content, "base64");
-      await writeFile$1(validation.resolvedPath, buffer);
-      const hash = createHash$1("sha256").update(buffer).digest("hex");
+      await writeFile(validation.resolvedPath, buffer);
+      const hash = createHash("sha256").update(buffer).digest("hex");
       return { success: true, hash };
     } catch (error) {
       logger.debug("Failed to write file:", error);
@@ -2068,7 +1383,7 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
       const entries = await readdir(directoryPath, { withFileTypes: true });
       const directoryEntries = await Promise.all(
         entries.map(async (entry) => {
-          const fullPath = join$1(directoryPath, entry.name);
+          const fullPath = join(directoryPath, entry.name);
           let type = "other";
           let size;
           let modified;
@@ -2125,10 +1440,10 @@ function registerCommonHandlers(rpcHandlerManager, workingDirectory) {
           await Promise.all(
             entries.map(async (entry) => {
               if (entry.isSymbolicLink()) {
-                logger.debug(`Skipping symlink: ${join$1(path, entry.name)}`);
+                logger.debug(`Skipping symlink: ${join(path, entry.name)}`);
                 return;
               }
-              const childPath = join$1(path, entry.name);
+              const childPath = join(path, entry.name);
               const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
               if (childNode) {
                 children.push(childNode);
@@ -4423,10 +3738,10 @@ function normalizeFsPath(input, homeDir) {
   if (p === "~") {
     p = homeDir;
   } else if (p.startsWith("~/")) {
-    p = join(homeDir, p.slice(2));
+    p = join$1(homeDir, p.slice(2));
   }
   if (!isAbsolute(p)) {
-    p = join(homeDir, p);
+    p = join$1(homeDir, p);
   }
   return resolve$1(p);
 }
@@ -4482,7 +3797,7 @@ async function fsList(inputPath, homeDir = homedir()) {
     dirents.map(async (d) => {
       const entry = { name: d.name, type: entryTypeOf(d) };
       try {
-        const s = await lstat(join(path, d.name));
+        const s = await lstat(join$1(path, d.name));
         entry.size = s.size;
         entry.mtimeMs = Math.round(s.mtimeMs);
       } catch {
@@ -4539,391 +3854,6 @@ function registerFsHandlers(rpcHandlerManager) {
   });
 }
 
-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$1(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$1(lockFile);
-          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
-            await unlink$1(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$1(tmpFile, configuration.settingsFile);
-    await hardenPrivateFile(configuration.settingsFile);
-    return updated;
-  } finally {
-    await fileHandle.close();
-    await unlink$1(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$1(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$1(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$1(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$1(configuration.daemonStateFile);
-  }
-  if (existsSync(configuration.daemonLockFile)) {
-    try {
-      await unlink$1(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 TODO_LIST_MAX_ITEMS = 500;
 const TODO_TITLE_MAX_CHARS = 500;
 const FIELD_MAX_CHARS = 200;
@@ -5282,14 +4212,14 @@ function scrubTmuxClientEnv(env) {
 }
 
 function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || join$1(homedir(), ".claude");
 }
 function getClaudeProjectsRoot() {
-  return join(getClaudeConfigDir(), "projects");
+  return join$1(getClaudeConfigDir(), "projects");
 }
 function getProjectPath(workingDirectory) {
   const projectId = resolve$1(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
-  return join(getClaudeProjectsRoot(), projectId);
+  return join$1(getClaudeProjectsRoot(), projectId);
 }
 
 var xtermHeadless = {};
@@ -10521,7 +9451,7 @@ function pruneTombstones(map, now, ttlMs = TOMBSTONE_TTL_MS) {
   return out;
 }
 function tombstoneFile() {
-  return join(configuration.happyHomeDir, "terminal-tombstones.json");
+  return join$1(configuration.happyHomeDir, "terminal-tombstones.json");
 }
 function loadTombstones() {
   try {
@@ -10540,7 +9470,7 @@ function saveTombstones(map) {
   }
 }
 function closedTerminalsFile() {
-  return join(configuration.happyHomeDir, "closed-terminals.json");
+  return join$1(configuration.happyHomeDir, "closed-terminals.json");
 }
 function loadClosedTerminals() {
   try {
@@ -10558,7 +9488,7 @@ function saveClosedTerminals(list) {
   }
 }
 function liveTerminalsFile() {
-  return join(configuration.happyHomeDir, "live-terminals.json");
+  return join$1(configuration.happyHomeDir, "live-terminals.json");
 }
 function loadLiveSnapshot() {
   try {
@@ -10833,7 +9763,7 @@ function tmuxSupportsEnvFlag() {
 }
 const PASTE_FILE_TTL_MS = 5e3;
 function pasteSpoolDir() {
-  const dir = join(configuration.happyHomeDir, "paste-spool");
+  const dir = join$1(configuration.happyHomeDir, "paste-spool");
   try {
     mkdirSync(dir, { recursive: true, mode: 448 });
   } catch {
@@ -11662,7 +10592,7 @@ class WebTerminalManager {
           return false;
         }
       },
-      conversationExists: (cwd, claudeSessionId) => existsSync(join(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
+      conversationExists: (cwd, claudeSessionId) => existsSync(join$1(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
       // B-273: only consulted for records that were attach terminals.
       // Unbounded: the panel's 50-row cap must not hide a restore target.
       userSessions: record.attachTmux ? this.listUserTmuxSessions(Infinity) : [],
@@ -12907,7 +11837,7 @@ function detectPosix() {
   const codex = commandExists("codex");
   const gemini = commandExists("gemini");
   const openclawCommand = commandExists("openclaw");
-  const openclawConfig = existsSync$1(join$1(os.homedir(), ".openclaw", "openclaw.json"));
+  const openclawConfig = existsSync$1(join(os.homedir(), ".openclaw", "openclaw.json"));
   const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
   const openclaw = openclawCommand || openclawConfig || openclawEnv;
   const pi = commandExists("pi") && commandExists("pi-acp");
@@ -12919,7 +11849,7 @@ function detectWindows() {
   const codex = checkCommand("codex");
   const gemini = checkCommand("gemini");
   const openclawCommand = checkCommand("openclaw");
-  const openclawConfig = existsSync$1(join$1(process.env.USERPROFILE || os.homedir(), ".openclaw", "openclaw.json"));
+  const openclawConfig = existsSync$1(join(process.env.USERPROFILE || os.homedir(), ".openclaw", "openclaw.json"));
   const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
   const openclaw = openclawCommand || openclawConfig || openclawEnv;
   const pi = checkCommand("pi") && checkCommand("pi-acp");
@@ -12954,7 +11884,7 @@ function deriveKey(master, usage, path) {
 }
 function deriveContentKeyPair(secret) {
   const seed = deriveKey(secret, "Happy EnCoder", ["content"]);
-  const hashedSeed = new Uint8Array(createHash("sha512").update(seed).digest());
+  const hashedSeed = new Uint8Array(createHash$1("sha512").update(seed).digest());
   const secretKey = hashedSeed.slice(0, 32);
   const keyPair = tweetnacl.box.keyPair.fromSecretKey(secretKey);
   return {
@@ -12963,7 +11893,7 @@ function deriveContentKeyPair(secret) {
   };
 }
 function getLocalHappyAgentCredentialPath(happyHomeDir = configuration.happyHomeDir) {
-  return join(happyHomeDir, "agent.key");
+  return join$1(happyHomeDir, "agent.key");
 }
 function readLocalHappyAgentCredentials(happyHomeDir = configuration.happyHomeDir, serverUrl = configuration.serverUrl) {
   const credentialPath = getLocalHappyAgentCredentialPath(happyHomeDir);
@@ -13021,7 +11951,7 @@ async function listClaudeProjectDirs(projectsRoot) {
   }
   const dirs = [];
   for (const name of names) {
-    const full = join(projectsRoot, name);
+    const full = join$1(projectsRoot, name);
     try {
       if ((await stat$1(full)).isDirectory()) dirs.push(full);
     } catch {
@@ -13042,7 +11972,7 @@ async function collectCandidates(projectDirs, exclude) {
       if (!name.endsWith(".jsonl")) continue;
       const id = name.slice(0, -".jsonl".length);
       if (!UUID_RE$1.test(id) || exclude.has(id.toLowerCase())) continue;
-      const path = join(dir, name);
+      const path = join$1(dir, name);
       try {
         const s = await stat$1(path);
         if (!s.isFile() || s.size === 0) continue;
@@ -13191,7 +12121,7 @@ class ForkSourceMissingError extends Error {
   }
 }
 function jsonlPath(projectDir, sessionId) {
-  return join(projectDir, `${sessionId}.jsonl`);
+  return join$1(projectDir, `${sessionId}.jsonl`);
 }
 function isUserPrompt(parsed) {
   if (!parsed || parsed.type !== "user") return false;
@@ -13364,7 +12294,7 @@ async function forkBeforeUserMessage(projectDir, sourceClaudeSessionId, cutBefor
   const destination = jsonlPath(projectDir, newId);
   const temporary = `${destination}.tmp-${process.pid}`;
   try {
-    await writeFile(temporary, lines.slice(0, cut).join("\n") + "\n", { encoding: "utf-8", flag: "wx" });
+    await writeFile$1(temporary, lines.slice(0, cut).join("\n") + "\n", { encoding: "utf-8", flag: "wx" });
     await rename$1(temporary, destination);
   } catch (error) {
     await unlink$1(temporary).catch(() => void 0);
@@ -16937,4 +15867,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { tmuxArgs as $, ApiClient as A, commandOnPath as B, readCredentials as C, credentialRelayProblem as D, deriveLocalCliUpdateSummary as E, readSettingsOutcome as F, updateSettings as G, encodeBase64Url as H, InvalidateSync as I, decodeBase64 as J, writeCredentialsLegacy as K, writeCredentialsDataKey as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, readCredentialsForConfiguredRelay as N, encrypt as O, isClaudeSessionId as P, getLocalHappyAgentCredentialPath as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, readLocalHappyAgentCredentials as T, decryptWithDataKey as U, decryptLegacy as V, parseExactVersion as W, compareExactVersions as X, extractCompleteLines as Y, decideBackfill as Z, parseTerminalHookPayload as _, ApiSessionClient as a, scrubTmuxClientEnv as a0, decideMirrorBinding as a1, MIRROR_BACKFILL_LINES_DEFAULT as a2, persistSession as a3, mirrorLineKey as a4, mirrorLocalId as a5, detectCLIAvailability as a6, detectResumeSupport as a7, acquireDaemonLock as a8, summarizeSpawnSessionForLog as a9, deletePersistedSessions as aa, shellescape as ab, decrypt as ac, writeDaemonState as ad, writeSettings as ae, fetchCliUpdateState as af, resolveCliUpdateCheckInterval as ag, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as ah, releaseDaemonLock as ai, listVhTerminals as aj, isValidTerminalId as ak, readVhTerminal as al, sendToVhTerminal as am, TITLE_PROMPT_PREFIX as an, BOARD_ANALYZER_PROMPT_PREFIX as ao, startOfflineReconnection as ap, clearCredentials as aq, clearMachineId as ar, SandboxConfigSchema as as, CodexAppServerClient as at, getLatestDaemonLog as au, persistence as av, api as aw, createEnvelope as b, configuration as c, connectionState as d, readSettings as e, encodeBase64 as f, contentLogMetadata as g, errorLogMetadata as h, isValidSessionId as i, packageJson as j, delay as k, logger as l, ensurePrivateDirectorySync as m, hardenPrivateFileSync as n, readDaemonState as o, projectPath as p, clearDaemonState as q, readPersistedSessions as r, streamKeyOf as s, getProjectPath as t, initializeSandbox as u, wrapCommand as v, writePrivateFileSync as w, AsyncLock as x, ensurePrivateDirectory as y, hardenPrivateFile as z };
+export { ApiClient as A, MIRROR_BACKFILL_LINES_DEFAULT as B, mirrorLineKey as C, mirrorLocalId as D, detectCLIAvailability as E, detectResumeSupport as F, summarizeSpawnSessionForLog as G, shellescape as H, InvalidateSync as I, fetchCliUpdateState as J, resolveCliUpdateCheckInterval as K, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, listVhTerminals as N, isValidTerminalId as O, readVhTerminal as P, sendToVhTerminal as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, TITLE_PROMPT_PREFIX as T, BOARD_ANALYZER_PROMPT_PREFIX as U, startOfflineReconnection as V, CodexAppServerClient as W, api as X, ApiSessionClient as a, contentLogMetadata as b, createEnvelope as c, delay as d, errorLogMetadata as e, connectionState as f, getProjectPath as g, initializeSandbox as h, isValidSessionId as i, AsyncLock as j, commandOnPath as k, deriveLocalCliUpdateSummary as l, isClaudeSessionId as m, getLocalHappyAgentCredentialPath as n, parseExactVersion as o, projectPath as p, compareExactVersions as q, readLocalHappyAgentCredentials as r, streamKeyOf as s, extractCompleteLines as t, decideBackfill as u, parseTerminalHookPayload as v, wrapCommand as w, tmuxArgs as x, scrubTmuxClientEnv as y, decideMirrorBinding as z };