@cerulin/chell 0.2.5

package/dist/types-DBjv5m4J.cjs

@@ -0,0 +1,2499 @@
+'use strict';
+
+var axios = require('axios');
+var chalk = require('chalk');
+var fs = require('fs');
+var node_fs = require('node:fs');
+var os = require('node:os');
+var node_path = require('node:path');
+var promises = require('node:fs/promises');
+var z = require('zod');
+var node_crypto = require('node:crypto');
+var tweetnacl = require('tweetnacl');
+var node_events = require('node:events');
+var socket_ioClient = require('socket.io-client');
+var child_process = require('child_process');
+var util = require('util');
+var fs$1 = require('fs/promises');
+var crypto = require('crypto');
+var path = require('path');
+var url = require('url');
+var os$1 = require('os');
+var nodePty = require('node-pty');
+var expoServerSdk = require('expo-server-sdk');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+var name = "@cerulin/chell";
+var version = "0.2.5";
+var description = "Mobile and Web client for Claude Code and Codex";
+var author = "Cerulin";
+var license = "MIT";
+var type = "module";
+var homepage = "https://github.com/cerulin/chell-cli";
+var bugs = "https://github.com/cerulin/chell-cli/issues";
+var repository = "cerulin/chell-cli";
+var bin = {
+	happy: "./bin/chell.mjs",
+	"happy-mcp": "./bin/chell-mcp.mjs",
+	chell: "./bin/chell.mjs",
+	"chell-mcp": "./bin/chell-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/chellMcpStdioBridge": {
+		require: {
+			types: "./dist/codex/chellMcpStdioBridge.d.cts",
+			"default": "./dist/codex/chellMcpStdioBridge.cjs"
+		},
+		"import": {
+			types: "./dist/codex/chellMcpStdioBridge.d.mts",
+			"default": "./dist/codex/chellMcpStdioBridge.mjs"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"scripts",
+	"tools",
+	"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 && npx tsc --noEmit && pkgroll",
+	obfuscate: "shx rm -rf dist.obf && javascript-obfuscator dist --output dist.obf --compact true --self-defending false --control-flow-flattening true --string-array true --string-array-encoding base64 --identifier-names-generator mangled && shx cp -r dist/*.d.* dist.obf 2>nul && shx rm -rf dist && shx mv dist.obf dist",
+	"build:obf": "yarn build && yarn obfuscate",
+	"pack:chell": "node scripts/pack-chell.cjs",
+	test: "yarn build && tsx --env-file .env.integration-test node_modules/.bin/vitest run",
+	start: "yarn build && ./bin/chell.mjs",
+	dev: "yarn build && tsx --env-file .env.dev src/index.ts",
+	"dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
+	"dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
+	prepublishOnly: "yarn build && yarn test",
+	release: "release-it",
+	postinstall: "node scripts/unpack-tools.cjs"
+};
+var dependencies = {
+	"@anthropic-ai/claude-code": "^2.0.14",
+	"@anthropic-ai/sdk": "^0.56.0",
+	"@modelcontextprotocol/sdk": "^1.15.1",
+	"@openai/codex": "^0.50.0",
+	"@stablelib/base64": "^2.0.1",
+	"@types/cross-spawn": "^6.0.6",
+	"@types/http-proxy": "^1.17.16",
+	"@types/ps-list": "^6.2.1",
+	"@types/qrcode-terminal": "^0.12.2",
+	"@types/react": "^19.1.9",
+	axios: "^1.10.0",
+	chalk: "^5.4.1",
+	chell: "^1.0.4",
+	"cross-spawn": "^7.0.6",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "^5.5.0",
+	"fastify-type-provider-zod": "4.0.2",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.5",
+	ink: "^6.1.0",
+	"node-pty": "1.0.0",
+	open: "^10.2.0",
+	"ps-list": "^8.1.1",
+	"qrcode-terminal": "^0.12.0",
+	react: "^19.1.1",
+	"socket.io-client": "^4.8.1",
+	tar: "^7.4.3",
+	tweetnacl: "^1.0.3",
+	zod: "^3.23.8"
+};
+var devDependencies = {
+	"@eslint/compat": "^1",
+	"@types/node": ">=20",
+	"cross-env": "^10.0.0",
+	dotenv: "^16.6.1",
+	eslint: "^9",
+	"eslint-config-prettier": "^10",
+	"javascript-obfuscator": "4",
+	pkgroll: "^2.14.2",
+	"release-it": "^19.0.4",
+	shx: "^0.3.3",
+	"ts-node": "^10",
+	tsx: "^4.20.3",
+	typescript: "^5",
+	vitest: "^3.2.4"
+};
+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"
+};
+var packageManager = "yarn@1.22.22";
+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
+};
+
+class Configuration {
+  serverUrl;
+  isDaemonProcess;
+  isHeadlessMode;
+  // Directories and paths (from persistence)
+  happyHomeDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  daemonStateFile;
+  daemonLockFile;
+  currentCliVersion;
+  isExperimentalEnabled;
+  constructor() {
+    this.serverUrl = process.env.HAPPY_SERVER_URL || "https://auth.cerulin.com";
+    const args = process.argv.slice(2);
+    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
+    this.isHeadlessMode = process.env.CHELL_HEADLESS === "1" || args.includes("--headless");
+    if (process.env.HAPPY_HOME_DIR) {
+      const expandedPath = process.env.HAPPY_HOME_DIR.replace(/^~/, os.homedir());
+      this.happyHomeDir = expandedPath;
+    } else if (this.isHeadlessMode && process.platform !== "win32") {
+      this.happyHomeDir = node_path.join("/home", "dev", ".chell");
+    } else {
+      this.happyHomeDir = node_path.join(os.homedir(), ".chell");
+    }
+    this.logsDir = node_path.join(this.happyHomeDir, "logs");
+    this.settingsFile = node_path.join(this.happyHomeDir, "settings.json");
+    this.privateKeyFile = node_path.join(this.happyHomeDir, "access.key");
+    this.daemonStateFile = node_path.join(this.happyHomeDir, "daemon.state.json");
+    this.daemonLockFile = node_path.join(this.happyHomeDir, "daemon.state.json.lock");
+    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
+    this.currentCliVersion = packageJson.version;
+    try {
+      if (!node_fs.existsSync(this.happyHomeDir)) {
+        node_fs.mkdirSync(this.happyHomeDir, { recursive: true });
+      }
+    } catch (error) {
+      if (process.env.DEBUG) {
+        console.error(`[CONFIG] Failed to create ${this.happyHomeDir}, falling back to /tmp/.chell:`, error);
+      }
+      this.happyHomeDir = node_path.join("/tmp", ".chell");
+      this.logsDir = node_path.join(this.happyHomeDir, "logs");
+      this.settingsFile = node_path.join(this.happyHomeDir, "settings.json");
+      this.privateKeyFile = node_path.join(this.happyHomeDir, "access.key");
+      this.daemonStateFile = node_path.join(this.happyHomeDir, "daemon.state.json");
+      this.daemonLockFile = node_path.join(this.happyHomeDir, "daemon.state.json.lock");
+      try {
+        if (!node_fs.existsSync(this.happyHomeDir)) {
+          node_fs.mkdirSync(this.happyHomeDir, { recursive: true });
+        }
+      } catch (fallbackError) {
+        if (process.env.DEBUG) {
+          console.error(`[CONFIG] Failed to create fallback directory ${this.happyHomeDir}:`, fallbackError);
+        }
+      }
+    }
+  }
+}
+const configuration = new Configuration();
+
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (variant === "base64url") {
+    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
+    return new Uint8Array(Buffer.from(base64Standard, "base64"));
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(node_crypto.randomBytes(size));
+}
+function encrypt(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 decrypt(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));
+}
+
+const defaultSettings = {
+  onboardingCompleted: false,
+  terminalEnabled: true
+};
+async function readSettings() {
+  if (!node_fs.existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await promises.readFile(configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
+}
+async function updateSettings(updater) {
+  const LOCK_RETRY_INTERVAL_MS = 100;
+  const MAX_LOCK_ATTEMPTS = 50;
+  const STALE_LOCK_TIMEOUT_MS = 1e4;
+  const lockFile = configuration.settingsFile + ".lock";
+  const tmpFile = configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await promises.open(lockFile, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await promises.stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await promises.unlink(lockFile).catch(() => {
+            });
+          }
+        } catch {
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const current = await readSettings() || { ...defaultSettings };
+    const updated = await updater(current);
+    if (!node_fs.existsSync(configuration.happyHomeDir)) {
+      await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+    }
+    await promises.writeFile(tmpFile, JSON.stringify(updated, null, 2));
+    await promises.rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await promises.unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z__namespace.object({
+  secret: z__namespace.string().base64(),
+  token: z__namespace.string()
+});
+async function readCredentials() {
+  if (!node_fs.existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await promises.readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    return {
+      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
+      token: credentials.token
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCredentials(credentials) {
+  if (!node_fs.existsSync(configuration.happyHomeDir)) {
+    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (node_fs.existsSync(configuration.privateKeyFile)) {
+    await promises.unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!node_fs.existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await promises.readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  node_fs.writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearDaemonState() {
+  if (node_fs.existsSync(configuration.daemonStateFile)) {
+    await promises.unlink(configuration.daemonStateFile);
+  }
+  if (node_fs.existsSync(configuration.daemonLockFile)) {
+    try {
+      await promises.unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await promises.open(
+        configuration.daemonLockFile,
+        node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = node_fs.readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              node_fs.unlinkSync(configuration.daemonLockFile);
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      if (attempt === maxAttempts) {
+        return null;
+      }
+      const delayMs = attempt * delayIncrementMs;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return null;
+}
+async function releaseDaemonLock(lockHandle) {
+  try {
+    await lockHandle.close();
+  } catch {
+  }
+  try {
+    if (node_fs.existsSync(configuration.daemonLockFile)) {
+      node_fs.unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+
+function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hour = pad(date.getHours());
+  const minute = pad(date.getMinutes());
+  const second = pad(date.getSeconds());
+  return `${year}-${month}-${day}-${hour}-${minute}-${second}-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 node_path.join(configuration.logsDir, filename);
+}
+class Logger {
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && process.env.HAPPY_SERVER_URL) {
+      this.dangerouslyUnencryptedServerLoggingUrl = process.env.HAPPY_SERVER_URL;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
+    try {
+      fs.mkdirSync(configuration.logsDir, { recursive: true });
+      fs.appendFileSync(this.logFilePath, "");
+      this.latestLogDupPath = node_path.join(configuration.logsDir, "latest-logs.txt");
+      fs.writeFileSync(this.latestLogDupPath, `# Latest session log (overwritten each start)
+# Path: ${this.logFilePath}
+`);
+      try {
+        const legacy = node_path.join(configuration.logsDir, "latest-logs.text");
+        if (node_fs.existsSync(legacy)) {
+          node_fs.unlinkSync(legacy);
+        }
+      } catch {
+      }
+      if (configuration.isHeadlessMode) {
+        try {
+          console.log(`[HEADLESS] Logs directory: ${configuration.logsDir}`);
+          console.log(`[HEADLESS] Session log: ${this.logFilePath}`);
+          console.log(`[HEADLESS] Latest log mirror: ${this.latestLogDupPath}`);
+        } catch {
+        }
+      }
+    } catch (error) {
+      this.initError = error;
+      console.error(chalk.yellow(`[LOGGER] FAILED TO CREATE LOG FILE: ${this.logFilePath}`));
+      console.error(chalk.yellow(`[LOGGER] Error:`), error);
+      if (configuration.isHeadlessMode) {
+        try {
+          console.log(`[HEADLESS] Log init failed at: ${this.logFilePath}`);
+          console.log(`[HEADLESS] Reason: ${formatError(error)}`);
+          console.log(`[HEADLESS] Logs directory attempted: ${configuration.logsDir}`);
+        } catch {
+        }
+      }
+    }
+  }
+  dangerouslyUnencryptedServerLoggingUrl;
+  latestLogDupPath;
+  initError;
+  // 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`);
+    }
+    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 (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) {
+    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) => typeof arg === "string" ? arg : JSON.stringify(arg)
+    ).join(" ")}
+`;
+    if (this.dangerouslyUnencryptedServerLoggingUrl) {
+      let level = "info";
+      if (prefix.includes(this.localTimezoneTimestamp())) {
+        level = "debug";
+      }
+      this.sendToRemoteServer(level, message, ...args).catch(() => {
+      });
+    }
+    try {
+      fs.mkdirSync(configuration.logsDir, { recursive: true });
+      fs.appendFileSync(this.logFilePath, logLine);
+      try {
+        fs.appendFileSync(this.latestLogDupPath, logLine);
+      } catch {
+      }
+    } catch (appendError) {
+      console.error(`[LOGGER] FAILED TO WRITE LOG: ${this.logFilePath}`);
+      console.error(`[LOGGER] Error:`, appendError);
+      if (configuration.isHeadlessMode) {
+        try {
+          console.log(`[HEADLESS] Log write failed at: ${this.logFilePath}`);
+          console.log(`[HEADLESS] Reason: ${formatError(appendError)}`);
+        } catch {
+        }
+      }
+      if (process.env.DEBUG) {
+        throw appendError;
+      }
+    }
+  }
+  getInitError() {
+    return this.initError;
+  }
+}
+let logger = new Logger();
+function formatError(err) {
+  try {
+    if (!err) return "Unknown error";
+    if (typeof err === "string") return err;
+    if (err instanceof Error) {
+      const anyErr = err;
+      const code = anyErr && anyErr.code ? ` (code: ${anyErr.code})` : "";
+      return `${err.message}${code}`;
+    }
+    if (typeof err === "object") {
+      const anyErr = err;
+      const msg = anyErr.message ? String(anyErr.message) : JSON.stringify(anyErr);
+      const code = anyErr.code ? ` (code: ${anyErr.code})` : "";
+      return `${msg}${code}`;
+    }
+    return String(err);
+  } catch {
+    return "Unprintable error";
+  }
+}
+async function listDaemonLogFiles(limit = 50) {
+  try {
+    const logsDir = configuration.logsDir;
+    if (!node_fs.existsSync(logsDir)) {
+      return [];
+    }
+    const logs = node_fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = node_path.join(logsDir, file);
+      const stats = node_fs.statSync(fullPath);
+      return { file, path: fullPath, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    try {
+      const state = await readDaemonState();
+      if (!state) {
+        return logs;
+      }
+      if (state.daemonLogPath && node_fs.existsSync(state.daemonLogPath)) {
+        const stats = node_fs.statSync(state.daemonLogPath);
+        const persisted = {
+          file: node_path.basename(state.daemonLogPath),
+          path: state.daemonLogPath,
+          modified: stats.mtime
+        };
+        const idx = logs.findIndex((l) => l.path === persisted.path);
+        if (idx >= 0) {
+          const [found] = logs.splice(idx, 1);
+          logs.unshift(found);
+        } else {
+          logs.unshift(persisted);
+        }
+      }
+    } catch {
+    }
+    return logs.slice(0, Math.max(0, limit));
+  } catch {
+    return [];
+  }
+}
+async function getLatestDaemonLog() {
+  const [latest] = await listDaemonLogFiles(1);
+  return latest || null;
+}
+
+const SessionMessageContentSchema = z.z.object({
+  c: z.z.string(),
+  // Base64 encoded encrypted content
+  t: z.z.literal("encrypted")
+});
+const UpdateBodySchema = z.z.object({
+  message: z.z.object({
+    id: z.z.string(),
+    seq: z.z.number(),
+    content: SessionMessageContentSchema
+  }),
+  sid: z.z.string(),
+  // Session ID
+  t: z.z.literal("new-message")
+});
+const UpdateSessionBodySchema = z.z.object({
+  t: z.z.literal("update-session"),
+  sid: z.z.string(),
+  metadata: z.z.object({
+    version: z.z.number(),
+    value: z.z.string()
+  }).nullish(),
+  agentState: z.z.object({
+    version: z.z.number(),
+    value: z.z.string()
+  }).nullish()
+});
+const UpdateMachineBodySchema = z.z.object({
+  t: z.z.literal("update-machine"),
+  machineId: z.z.string(),
+  metadata: z.z.object({
+    version: z.z.number(),
+    value: z.z.string()
+  }).nullish(),
+  daemonState: z.z.object({
+    version: z.z.number(),
+    value: z.z.string()
+  }).nullish()
+});
+z.z.object({
+  id: z.z.string(),
+  seq: z.z.number(),
+  body: z.z.union([
+    UpdateBodySchema,
+    UpdateSessionBodySchema,
+    UpdateMachineBodySchema
+  ]),
+  createdAt: z.z.number()
+});
+z.z.object({
+  createdAt: z.z.number(),
+  id: z.z.string(),
+  seq: z.z.number(),
+  updatedAt: z.z.number(),
+  metadata: z.z.any(),
+  metadataVersion: z.z.number(),
+  agentState: z.z.any().nullable(),
+  agentStateVersion: z.z.number(),
+  // Connectivity tracking (from server)
+  connectivityStatus: z.z.union([
+    z.z.enum(["neverConnected", "online", "offline"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  connectivityStatusSince: z.z.number().optional(),
+  connectivityStatusReason: z.z.string().optional(),
+  // State tracking (from server)
+  state: z.z.union([
+    z.z.enum(["running", "archiveRequested", "archived"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  stateSince: z.z.number().optional(),
+  stateReason: z.z.string().optional()
+});
+z.z.object({
+  host: z.z.string(),
+  platform: z.z.string(),
+  happyCliVersion: z.z.string(),
+  homeDir: z.z.string(),
+  happyHomeDir: z.z.string(),
+  happyLibDir: z.z.string()
+});
+z.z.object({
+  status: z.z.union([
+    z.z.enum(["running", "shutting-down"]),
+    z.z.string()
+    // Forward compatibility
+  ]),
+  pid: z.z.number().optional(),
+  httpPort: z.z.number().optional(),
+  startedAt: z.z.number().optional(),
+  shutdownRequestedAt: z.z.number().optional(),
+  shutdownSource: z.z.union([
+    z.z.enum(["mobile-app", "cli", "os-signal", "unknown"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional()
+});
+z.z.object({
+  id: z.z.string(),
+  metadata: z.z.any(),
+  // Decrypted MachineMetadata
+  metadataVersion: z.z.number(),
+  daemonState: z.z.any().nullable(),
+  // Decrypted DaemonState
+  daemonStateVersion: z.z.number(),
+  // We don't really care about these on the CLI for now
+  // ApiMachineClient will not sync these
+  active: z.z.boolean(),
+  activeAt: z.z.number(),
+  createdAt: z.z.number(),
+  updatedAt: z.z.number(),
+  // Connectivity tracking (from server)
+  connectivityStatus: z.z.union([
+    z.z.enum(["neverConnected", "online", "offline"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  connectivityStatusSince: z.z.number().optional(),
+  connectivityStatusReason: z.z.string().optional(),
+  // State tracking (from server)
+  state: z.z.union([
+    z.z.enum(["running", "archiveRequested", "archived"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional(),
+  stateSince: z.z.number().optional(),
+  stateReason: z.z.string().optional()
+});
+z.z.object({
+  content: SessionMessageContentSchema,
+  createdAt: z.z.number(),
+  id: z.z.string(),
+  seq: z.z.number(),
+  updatedAt: z.z.number()
+});
+const MessageMetaSchema = z.z.object({
+  sentFrom: z.z.string().optional(),
+  // Source identifier
+  permissionMode: z.z.string().optional(),
+  // Permission mode for this message
+  model: z.z.string().nullable().optional(),
+  // Model name for this message (null = reset)
+  fallbackModel: z.z.string().nullable().optional(),
+  // Fallback model for this message (null = reset)
+  customSystemPrompt: z.z.string().nullable().optional(),
+  // Custom system prompt for this message (null = reset)
+  appendSystemPrompt: z.z.string().nullable().optional(),
+  // Append to system prompt for this message (null = reset)
+  allowedTools: z.z.array(z.z.string()).nullable().optional(),
+  // Allowed tools for this message (null = reset)
+  disallowedTools: z.z.array(z.z.string()).nullable().optional()
+  // Disallowed tools for this message (null = reset)
+});
+z.z.object({
+  session: z.z.object({
+    id: z.z.string(),
+    tag: z.z.string(),
+    seq: z.z.number(),
+    createdAt: z.z.number(),
+    updatedAt: z.z.number(),
+    metadata: z.z.string(),
+    metadataVersion: z.z.number(),
+    agentState: z.z.string().nullable(),
+    agentStateVersion: z.z.number()
+  })
+});
+const UserMessageSchema = z.z.object({
+  role: z.z.literal("user"),
+  content: z.z.object({
+    type: z.z.literal("text"),
+    text: z.z.string()
+  }),
+  localKey: z.z.string().optional(),
+  // Mobile messages include this
+  meta: MessageMetaSchema.optional()
+});
+const AgentMessageSchema = z.z.object({
+  role: z.z.literal("agent"),
+  content: z.z.object({
+    type: z.z.literal("output"),
+    data: z.z.any()
+  }),
+  meta: MessageMetaSchema.optional()
+});
+z.z.union([UserMessageSchema, AgentMessageSchema]);
+
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.min(currentFailureCount, maxFailureCount);
+  return Math.round(Math.random() * maxDelayRet);
+}
+function createBackoff(opts) {
+  return async (callback) => {
+    let currentFailureCount = 0;
+    const minDelay = 250;
+    const maxDelay = 1e3;
+    const maxFailureCount = 50;
+    while (true) {
+      try {
+        return await callback();
+      } catch (e) {
+        if (currentFailureCount < maxFailureCount) {
+          currentFailureCount++;
+        }
+        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+        await delay(waitForRequest);
+      }
+    }
+  };
+}
+let backoff = createBackoff();
+
+class AsyncLock {
+  permits = 1;
+  promiseResolverQueue = [];
+  async inLock(func) {
+    try {
+      await this.lock();
+      return await func();
+    } finally {
+      this.unlock();
+    }
+  }
+  async lock() {
+    if (this.permits > 0) {
+      this.permits = this.permits - 1;
+      return;
+    }
+    await new Promise((resolve) => this.promiseResolverQueue.push(resolve));
+  }
+  unlock() {
+    this.permits += 1;
+    if (this.permits > 1 && this.promiseResolverQueue.length > 0) {
+      throw new Error("this.permits should never be > 0 when there is someone waiting.");
+    } else if (this.permits === 1 && this.promiseResolverQueue.length > 0) {
+      this.permits -= 1;
+      const nextResolver = this.promiseResolverQueue.shift();
+      if (nextResolver) {
+        setTimeout(() => {
+          nextResolver(true);
+        }, 0);
+      }
+    }
+  }
+}
+
+class RpcHandlerManager {
+  handlers = /* @__PURE__ */ new Map();
+  scopePrefix;
+  secret;
+  logger;
+  socket = null;
+  constructor(config) {
+    this.scopePrefix = config.scopePrefix;
+    this.secret = config.secret;
+    this.logger = config.logger || ((msg, data) => logger.debug(msg, data));
+  }
+  /**
+   * Register an RPC handler for a specific method
+   * @param method - The method name (without prefix)
+   * @param handler - The handler function
+   */
+  registerHandler(method, handler) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    this.handlers.set(prefixedMethod, handler);
+    if (this.socket) {
+      this.socket.emit("rpc-register", { method: prefixedMethod });
+    }
+  }
+  /**
+   * Handle an incoming RPC request
+   * @param request - The RPC request data
+   * @param callback - The response callback
+   */
+  async handleRequest(request) {
+    try {
+      const handler = this.handlers.get(request.method);
+      if (!handler) {
+        this.logger("[RPC] [ERROR] Method not found", { method: request.method });
+        const errorResponse = { error: "Method not found" };
+        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+        return encryptedError;
+      }
+      const decryptedParams = decrypt(decodeBase64(request.params), this.secret);
+      const result = await handler(decryptedParams);
+      const encryptedResponse = encodeBase64(encrypt(result, this.secret));
+      return encryptedResponse;
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling request", { error });
+      const errorResponse = {
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+      const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+      return encryptedError;
+    }
+  }
+  onSocketConnect(socket) {
+    this.socket = socket;
+    for (const [prefixedMethod] of this.handlers) {
+      socket.emit("rpc-register", { method: prefixedMethod });
+    }
+  }
+  onSocketDisconnect() {
+    this.socket = null;
+  }
+  /**
+   * Get the number of registered handlers
+   */
+  getHandlerCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Check if a handler is registered
+   * @param method - The method name (without prefix)
+   */
+  hasHandler(method) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    return this.handlers.has(prefixedMethod);
+  }
+  /**
+   * Clear all handlers
+   */
+  clearHandlers() {
+    this.handlers.clear();
+    this.logger("Cleared all RPC handlers");
+  }
+  /**
+   * Get the prefixed method name
+   * @param method - The method name
+   */
+  getPrefixedMethod(method) {
+    return `${this.scopePrefix}:${method}`;
+  }
+}
+
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-DBjv5m4J.cjs', document.baseURI).href))));
+function projectPath() {
+  const path$1 = path.resolve(__dirname$1, "..");
+  return path$1;
+}
+
+function run$1(args, options) {
+  const RUNNER_PATH = path.resolve(path.join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  return new Promise((resolve2, reject) => {
+    const child = child_process.spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: options?.cwd
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2({
+        exitCode: code || 0,
+        stdout,
+        stderr
+      });
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+function getBinaryPath() {
+  const platformName = os$1.platform();
+  const binaryName = platformName === "win32" ? "difft.exe" : "difft";
+  return path.resolve(path.join(projectPath(), "tools", "unpacked", binaryName));
+}
+function run(args, options) {
+  const binaryPath = getBinaryPath();
+  return new Promise((resolve2, reject) => {
+    const child = child_process.spawn(binaryPath, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: options?.cwd,
+      env: {
+        ...process.env,
+        // Force color output when needed
+        FORCE_COLOR: "1"
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2({
+        exitCode: code || 0,
+        stdout,
+        stderr
+      });
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+const execAsync = util.promisify(child_process.exec);
+function registerCommonHandlers(rpcHandlerManager) {
+  rpcHandlerManager.registerHandler("bash", async (data) => {
+    logger.debug("Shell command request:", data.command);
+    try {
+      const options = {
+        cwd: data.cwd,
+        timeout: data.timeout || 3e4
+        // Default 30 seconds timeout
+      };
+      const { stdout, stderr } = await execAsync(data.command, options);
+      return {
+        success: true,
+        stdout: stdout ? stdout.toString() : "",
+        stderr: stderr ? stderr.toString() : "",
+        exitCode: 0
+      };
+    } catch (error) {
+      const execError = error;
+      if (execError.code === "ETIMEDOUT" || execError.killed) {
+        return {
+          success: false,
+          stdout: execError.stdout || "",
+          stderr: execError.stderr || "",
+          exitCode: typeof execError.code === "number" ? execError.code : -1,
+          error: "Command timed out"
+        };
+      }
+      return {
+        success: false,
+        stdout: execError.stdout ? execError.stdout.toString() : "",
+        stderr: execError.stderr ? execError.stderr.toString() : execError.message || "Command failed",
+        exitCode: typeof execError.code === "number" ? execError.code : 1,
+        error: execError.message || "Command failed"
+      };
+    }
+  });
+  rpcHandlerManager.registerHandler("readFile", async (data) => {
+    logger.debug("Read file request:", data.path);
+    try {
+      const buffer = await fs$1.readFile(data.path);
+      const content = buffer.toString("base64");
+      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+      return { success: true, content, hash };
+    } catch (error) {
+      logger.debug("Failed to read file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
+    }
+  });
+  rpcHandlerManager.registerHandler("writeFile", async (data) => {
+    logger.debug("Write file request:", data.path);
+    try {
+      if (data.expectedHash !== null && data.expectedHash !== void 0) {
+        try {
+          const existingBuffer = await fs$1.readFile(data.path);
+          const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
+          if (existingHash !== data.expectedHash) {
+            return {
+              success: false,
+              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
+            };
+          }
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+          return {
+            success: false,
+            error: "File does not exist but hash was provided"
+          };
+        }
+      } else {
+        try {
+          await fs$1.stat(data.path);
+          return {
+            success: false,
+            error: "File already exists but was expected to be new"
+          };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      const buffer = Buffer.from(data.content, "base64");
+      await fs$1.writeFile(data.path, buffer);
+      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+      return { success: true, hash };
+    } catch (error) {
+      logger.debug("Failed to write file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
+    }
+  });
+  rpcHandlerManager.registerHandler("listDirectory", async (data) => {
+    logger.debug("List directory request:", data.path);
+    try {
+      const entries = await fs$1.readdir(data.path, { withFileTypes: true });
+      const directoryEntries = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = path.join(data.path, entry.name);
+          let type = "other";
+          let size;
+          let modified;
+          if (entry.isDirectory()) {
+            type = "directory";
+          } else if (entry.isFile()) {
+            type = "file";
+          }
+          try {
+            const stats = await fs$1.stat(fullPath);
+            size = stats.size;
+            modified = stats.mtime.getTime();
+          } catch (error) {
+            logger.debug(`Failed to stat ${fullPath}:`, error);
+          }
+          return {
+            name: entry.name,
+            type,
+            size,
+            modified
+          };
+        })
+      );
+      directoryEntries.sort((a, b) => {
+        if (a.type === "directory" && b.type !== "directory") return -1;
+        if (a.type !== "directory" && b.type === "directory") return 1;
+        return a.name.localeCompare(b.name);
+      });
+      return { success: true, entries: directoryEntries };
+    } catch (error) {
+      logger.debug("Failed to list directory:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
+    }
+  });
+  rpcHandlerManager.registerHandler("getDirectoryTree", async (data) => {
+    logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    async function buildTree(path$1, name, currentDepth) {
+      try {
+        const stats = await fs$1.stat(path$1);
+        const node = {
+          name,
+          path: path$1,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.getTime()
+        };
+        if (stats.isDirectory() && currentDepth < data.maxDepth) {
+          const entries = await fs$1.readdir(path$1, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
+                return;
+              }
+              const childPath = path.join(path$1, entry.name);
+              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
+              if (childNode) {
+                children.push(childNode);
+              }
+            })
+          );
+          children.sort((a, b) => {
+            if (a.type === "directory" && b.type !== "directory") return -1;
+            if (a.type !== "directory" && b.type === "directory") return 1;
+            return a.name.localeCompare(b.name);
+          });
+          node.children = children;
+        }
+        return node;
+      } catch (error) {
+        logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
+        return null;
+      }
+    }
+    try {
+      if (data.maxDepth < 0) {
+        return { success: false, error: "maxDepth must be non-negative" };
+      }
+      const baseName = data.path === "/" ? "/" : data.path.split("/").pop() || data.path;
+      const tree = await buildTree(data.path, baseName, 0);
+      if (!tree) {
+        return { success: false, error: "Failed to access the specified path" };
+      }
+      return { success: true, tree };
+    } catch (error) {
+      logger.debug("Failed to get directory tree:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
+    }
+  });
+  rpcHandlerManager.registerHandler("ripgrep", async (data) => {
+    logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
+    try {
+      const result = await run$1(data.args, { cwd: data.cwd });
+      return {
+        success: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout.toString(),
+        stderr: result.stderr.toString()
+      };
+    } catch (error) {
+      logger.debug("Failed to run ripgrep:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to run ripgrep"
+      };
+    }
+  });
+  rpcHandlerManager.registerHandler("difftastic", async (data) => {
+    logger.debug("Difftastic request with args:", data.args, "cwd:", data.cwd);
+    try {
+      const result = await run(data.args, { cwd: data.cwd });
+      return {
+        success: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout.toString(),
+        stderr: result.stderr.toString()
+      };
+    } catch (error) {
+      logger.debug("Failed to run difftastic:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to run difftastic"
+      };
+    }
+  });
+}
+
+function getHeadlessJsonPath() {
+  return node_path.resolve(configuration.happyHomeDir, "link", "headless.json");
+}
+function writeHeadlessJson(updates) {
+  try {
+    const outputDir = node_path.resolve(configuration.happyHomeDir, "link");
+    const jsonPath = getHeadlessJsonPath();
+    node_fs.mkdirSync(outputDir, { recursive: true });
+    let data = {};
+    try {
+      const existing = node_fs.readFileSync(jsonPath, "utf8");
+      data = JSON.parse(existing);
+    } catch {
+    }
+    if (typeof data.claude_return_auth !== "string") data.claude_return_auth = "";
+    if (typeof data.codex_return_auth !== "string") data.codex_return_auth = "";
+    if (typeof data.claude_auth_url !== "string") data.claude_auth_url = "";
+    if (typeof data.codex_auth_url !== "string") data.codex_auth_url = "";
+    if (typeof data.last_message_time !== "number") data.last_message_time = 0;
+    Object.assign(data, updates);
+    node_fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2));
+    logger.debug(`[headlessJson] Updated: ${JSON.stringify(updates)}`);
+  } catch (error) {
+    logger.debug(`[headlessJson] Failed to write: ${error}`);
+  }
+}
+function updateActivityTimestamp() {
+  writeHeadlessJson({
+    last_message_time: Math.floor(Date.now() / 1e3)
+  });
+}
+
+class ApiSessionClient extends node_events.EventEmitter {
+  token;
+  secret;
+  sessionId;
+  metadata;
+  metadataVersion;
+  agentState;
+  agentStateVersion;
+  socket;
+  pendingMessages = [];
+  pendingMessageCallback = null;
+  rpcHandlerManager;
+  agentStateLock = new AsyncLock();
+  metadataLock = new AsyncLock();
+  constructor(token, secret, session) {
+    super();
+    this.token = token;
+    this.secret = secret;
+    this.sessionId = session.id;
+    this.metadata = session.metadata;
+    this.metadataVersion = session.metadataVersion;
+    this.agentState = session.agentState;
+    this.agentStateVersion = session.agentStateVersion;
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.sessionId,
+      secret: this.secret,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    registerCommonHandlers(this.rpcHandlerManager);
+    this.socket = socket_ioClient.io(configuration.serverUrl, {
+      auth: {
+        token: this.token,
+        clientType: "session-scoped",
+        sessionId: this.sessionId
+      },
+      path: "/v1/updates",
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+    this.socket.on("connect", () => {
+      logger.debug("Socket connected successfully");
+      this.rpcHandlerManager.onSocketConnect(this.socket);
+    });
+    this.socket.on("rpc-request", async (data, callback) => {
+      callback(await this.rpcHandlerManager.handleRequest(data));
+    });
+    this.socket.on("disconnect", (reason) => {
+      logger.debug("[API] Socket disconnected:", reason);
+      this.rpcHandlerManager.onSocketDisconnect();
+    });
+    this.socket.on("connect_error", (error) => {
+      logger.debug("[API] Socket connection error:", error);
+      this.rpcHandlerManager.onSocketDisconnect();
+    });
+    this.socket.on("update", (data) => {
+      try {
+        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
+        if (!data.body) {
+          logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
+          return;
+        }
+        if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
+          const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
+          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          const userResult = UserMessageSchema.safeParse(body);
+          if (userResult.success) {
+            updateActivityTimestamp();
+            if (this.pendingMessageCallback) {
+              this.pendingMessageCallback(userResult.data);
+            } else {
+              this.pendingMessages.push(userResult.data);
+            }
+          } else {
+            this.emit("message", body);
+          }
+        } else if (data.body.t === "update-session") {
+          if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
+            this.metadata = decrypt(decodeBase64(data.body.metadata.value), this.secret);
+            this.metadataVersion = data.body.metadata.version;
+          }
+          if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+            this.agentState = data.body.agentState.value ? decrypt(decodeBase64(data.body.agentState.value), this.secret) : null;
+            this.agentStateVersion = data.body.agentState.version;
+          }
+        } else if (data.body.t === "update-machine") {
+          logger.debug(`[SOCKET] WARNING: Session client received unexpected machine update - ignoring`);
+        } else {
+          this.emit("message", data.body);
+        }
+      } catch (error) {
+        logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
+      }
+    });
+    this.socket.on("error", (error) => {
+      logger.debug("[API] Socket error:", error);
+    });
+    this.socket.connect();
+  }
+  onUserMessage(callback) {
+    this.pendingMessageCallback = callback;
+    while (this.pendingMessages.length > 0) {
+      callback(this.pendingMessages.shift());
+    }
+  }
+  /**
+   * Send message to session
+   * @param body - Message body (can be MessageContent or raw content for agent messages)
+   */
+  sendClaudeSessionMessage(body) {
+    let content;
+    if (body.type === "user" && body.isSidechain !== true && body.isMeta !== true) {
+      let userText = null;
+      const raw = body.message?.content;
+      if (typeof raw === "string") {
+        userText = raw;
+      } else if (Array.isArray(raw)) {
+        const pieces = [];
+        for (const c of raw) {
+          if (c && typeof c === "object" && c.type === "text" && typeof c.text === "string") {
+            pieces.push(c.text);
+          }
+        }
+        if (pieces.length > 0) {
+          userText = pieces.join("\n\n");
+        }
+      }
+      if (typeof userText === "string") {
+        content = {
+          role: "user",
+          content: { type: "text", text: userText },
+          meta: { sentFrom: "cli" }
+        };
+        updateActivityTimestamp();
+      } else {
+        content = {
+          role: "agent",
+          content: { type: "output", data: body },
+          meta: { sentFrom: "cli" }
+        };
+        updateActivityTimestamp();
+      }
+    } else {
+      content = {
+        role: "agent",
+        content: { type: "output", data: body },
+        meta: { sentFrom: "cli" }
+      };
+      updateActivityTimestamp();
+    }
+    logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
+    const encrypted = encodeBase64(encrypt(content, this.secret));
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+    if (body.type === "assistant" && body.message.usage) {
+      try {
+        this.sendUsageData(body.message.usage);
+      } catch (error) {
+        logger.debug("[SOCKET] Failed to send usage data:", error);
+      }
+    }
+    if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
+      this.updateMetadata((metadata) => ({
+        ...metadata,
+        summary: {
+          text: body.summary,
+          updatedAt: Date.now()
+        }
+      }));
+    }
+  }
+  sendCodexMessage(body) {
+    updateActivityTimestamp();
+    let content = {
+      role: "agent",
+      content: {
+        type: "codex",
+        data: body
+        // This wraps the entire Claude message
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    logger.debugLargeJson("[SOCKET] Sending codex message through socket:", content);
+    const encrypted = encodeBase64(encrypt(content, this.secret));
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+  }
+  sendGeminiMessage(body) {
+    updateActivityTimestamp();
+    let content = {
+      role: "agent",
+      content: {
+        type: "gemini",
+        data: body
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    const encrypted = encodeBase64(encrypt(content, this.secret));
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+  }
+  sendSessionEvent(event, id) {
+    let content = {
+      role: "agent",
+      content: {
+        id: id ?? node_crypto.randomUUID(),
+        type: "event",
+        data: event
+      }
+    };
+    const encrypted = encodeBase64(encrypt(content, this.secret));
+    this.socket.emit("message", {
+      sid: this.sessionId,
+      message: encrypted
+    });
+  }
+  /**
+   * Send a ping message to keep the connection alive
+   */
+  keepAlive(thinking, mode) {
+    if (process.env.DEBUG) {
+      logger.debug(`[API] Sending keep alive message: ${thinking}`);
+    }
+    this.socket.volatile.emit("session-alive", {
+      sid: this.sessionId,
+      time: Date.now(),
+      thinking,
+      mode
+    });
+  }
+  /**
+   * Send session death message
+   */
+  sendSessionDeath() {
+    this.socket.emit("session-end", { sid: this.sessionId, time: Date.now() });
+  }
+  /**
+   * Send usage data to the server
+   */
+  sendUsageData(usage) {
+    const totalTokens = usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+    const usageReport = {
+      key: "claude-session",
+      sessionId: this.sessionId,
+      tokens: {
+        total: totalTokens,
+        input: usage.input_tokens,
+        output: usage.output_tokens,
+        cache_creation: usage.cache_creation_input_tokens || 0,
+        cache_read: usage.cache_read_input_tokens || 0
+      },
+      cost: {
+        // TODO: Calculate actual costs based on pricing
+        // For now, using placeholder values
+        total: 0,
+        input: 0,
+        output: 0
+      }
+    };
+    logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
+    this.socket.emit("usage-report", usageReport);
+  }
+  /**
+   * Update session metadata
+   * @param handler - Handler function that returns the updated metadata
+   */
+  updateMetadata(handler) {
+    this.metadataLock.inLock(async () => {
+      await backoff(async () => {
+        let updated = handler(this.metadata);
+        const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(updated, this.secret)) });
+        if (answer.result === "success") {
+          this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+          this.metadataVersion = answer.version;
+        } else if (answer.result === "version-mismatch") {
+          if (answer.version > this.metadataVersion) {
+            this.metadataVersion = answer.version;
+            this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+          }
+          throw new Error("Metadata version mismatch");
+        } else if (answer.result === "error") ;
+      });
+    });
+  }
+  /**
+   * Update session agent state
+   * @param handler - Handler function that returns the updated agent state
+   */
+  updateAgentState(handler) {
+    logger.debugLargeJson("Updating agent state", this.agentState);
+    this.agentStateLock.inLock(async () => {
+      await backoff(async () => {
+        let updated = handler(this.agentState || {});
+        const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(updated, this.secret)) : null });
+        if (answer.result === "success") {
+          this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
+          this.agentStateVersion = answer.version;
+          logger.debug("Agent state updated", this.agentState);
+        } else if (answer.result === "version-mismatch") {
+          if (answer.version > this.agentStateVersion) {
+            this.agentStateVersion = answer.version;
+            this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
+          }
+          throw new Error("Agent state version mismatch");
+        } else if (answer.result === "error") ;
+      });
+    });
+  }
+  /**
+   * Wait for socket buffer to flush
+   */
+  async flush() {
+    if (!this.socket.connected) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("ping", () => {
+        resolve();
+      });
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+  }
+  async close() {
+    logger.debug("[API] socket.close() called");
+    this.socket.close();
+  }
+}
+
+class TerminalManager {
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  /**
+   * Spawn a new PTY terminal session
+   */
+  spawn(sessionId, cols = 80, rows = 24) {
+    if (this.sessions.has(sessionId)) {
+      logger.debug(`[TERMINAL] Session ${sessionId} already exists`);
+      this.callbacks.onError(sessionId, "ALREADY_EXISTS", "Terminal session already exists");
+      return;
+    }
+    try {
+      const shell = process.env.SHELL || (os.platform() === "win32" ? "powershell.exe" : "/bin/bash");
+      const cwd = process.env.HOME || process.env.USERPROFILE || process.cwd();
+      logger.debug(`[TERMINAL] Spawning PTY for session ${sessionId}: shell=${shell}, cwd=${cwd}, size=${cols}x${rows}`);
+      const pty = nodePty.spawn(shell, [], {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd,
+        env: process.env
+      });
+      const session = {
+        id: sessionId,
+        pty,
+        cols,
+        rows,
+        createdAt: Date.now()
+      };
+      this.sessions.set(sessionId, session);
+      pty.onData((data) => {
+        const base64 = Buffer.from(data, "utf-8").toString("base64");
+        this.callbacks.onStdout(sessionId, base64);
+      });
+      pty.onExit(({ exitCode, signal }) => {
+        logger.debug(`[TERMINAL] Session ${sessionId} exited: code=${exitCode}, signal=${signal}`);
+        this.callbacks.onExit(sessionId, exitCode, signal);
+        this.sessions.delete(sessionId);
+      });
+      this.callbacks.onOpen(sessionId);
+      logger.debug(`[TERMINAL] Session ${sessionId} spawned successfully`);
+    } catch (error) {
+      logger.debug(`[TERMINAL] Failed to spawn session ${sessionId}:`, error);
+      this.callbacks.onError(sessionId, "SPAWN_FAILED", error instanceof Error ? error.message : String(error));
+    }
+  }
+  /**
+   * Write data to PTY stdin
+   */
+  writeStdin(sessionId, dataBase64) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      logger.debug(`[TERMINAL] Session ${sessionId} not found for stdin write`);
+      return;
+    }
+    try {
+      const data = Buffer.from(dataBase64, "base64").toString("utf-8");
+      session.pty.write(data);
+    } catch (error) {
+      logger.debug(`[TERMINAL] Failed to write to session ${sessionId}:`, error);
+      this.callbacks.onError(sessionId, "WRITE_FAILED", error instanceof Error ? error.message : String(error));
+    }
+  }
+  /**
+   * Resize PTY
+   */
+  resize(sessionId, cols, rows) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      logger.debug(`[TERMINAL] Session ${sessionId} not found for resize`);
+      return;
+    }
+    try {
+      session.pty.resize(cols, rows);
+      session.cols = cols;
+      session.rows = rows;
+      logger.debug(`[TERMINAL] Session ${sessionId} resized to ${cols}x${rows}`);
+    } catch (error) {
+      logger.debug(`[TERMINAL] Failed to resize session ${sessionId}:`, error);
+      this.callbacks.onError(sessionId, "RESIZE_FAILED", error instanceof Error ? error.message : String(error));
+    }
+  }
+  /**
+   * Close PTY session
+   */
+  close(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      logger.debug(`[TERMINAL] Session ${sessionId} not found for close`);
+      return;
+    }
+    try {
+      session.pty.kill();
+      this.sessions.delete(sessionId);
+      logger.debug(`[TERMINAL] Session ${sessionId} closed`);
+    } catch (error) {
+      logger.debug(`[TERMINAL] Failed to close session ${sessionId}:`, error);
+      this.callbacks.onError(sessionId, "CLOSE_FAILED", error instanceof Error ? error.message : String(error));
+    }
+  }
+  /**
+   * Close all sessions (cleanup on shutdown)
+   */
+  closeAll() {
+    logger.debug(`[TERMINAL] Closing all ${this.sessions.size} sessions`);
+    for (const sessionId of this.sessions.keys()) {
+      this.close(sessionId);
+    }
+  }
+  /**
+   * Get session info
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /**
+   * Get all active session IDs
+   */
+  getActiveSessionIds() {
+    return Array.from(this.sessions.keys());
+  }
+}
+
+class ApiMachineClient {
+  constructor(token, secret, machine) {
+    this.token = token;
+    this.secret = secret;
+    this.machine = machine;
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.machine.id,
+      secret: this.secret,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    registerCommonHandlers(this.rpcHandlerManager);
+    this.terminalManager = new TerminalManager({
+      onOpen: (sessionId) => {
+        if (this.socket?.connected) {
+          this.socket.emit("terminal-open", { sessionId });
+        }
+      },
+      onStdout: (sessionId, dataBase64) => {
+        if (this.socket?.connected) {
+          this.socket.emit("terminal-stdout", { sessionId, dataBase64 });
+        }
+      },
+      onExit: (sessionId, code, signal) => {
+        if (this.socket?.connected) {
+          const signalStr = signal !== void 0 ? String(signal) : void 0;
+          this.socket.emit("terminal-exit", { sessionId, code, signal: signalStr });
+        }
+      },
+      onError: (sessionId, code, message) => {
+        if (this.socket?.connected) {
+          this.socket.emit("terminal-error", { sessionId, code, message });
+        }
+      }
+    });
+  }
+  socket;
+  keepAliveInterval = null;
+  rpcHandlerManager;
+  terminalManager;
+  setRPCHandlers({
+    spawnSession,
+    stopSession,
+    requestShutdown
+  }) {
+    this.rpcHandlerManager.registerHandler("spawn-happy-session", async (params) => {
+      const { directory, sessionId, machineId, approvedNewDirectoryCreation } = params || {};
+      if (!directory) {
+        throw new Error("Directory is required");
+      }
+      const result = await spawnSession({ directory, sessionId, machineId, approvedNewDirectoryCreation });
+      switch (result.type) {
+        case "success":
+          logger.debug(`[API MACHINE] Spawned session ${result.sessionId}`);
+          return { type: "success", sessionId: result.sessionId };
+        case "requestToApproveDirectoryCreation":
+          logger.debug(`[API MACHINE] Requesting directory creation approval for: ${result.directory}`);
+          return { type: "requestToApproveDirectoryCreation", directory: result.directory };
+        case "error":
+          throw new Error(result.errorMessage);
+      }
+    });
+    this.rpcHandlerManager.registerHandler("stop-session", (params) => {
+      const { sessionId } = params || {};
+      if (!sessionId) {
+        throw new Error("Session ID is required");
+      }
+      const success = stopSession(sessionId);
+      if (!success) {
+        throw new Error("Session not found or failed to stop");
+      }
+      logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
+      return { message: "Session stopped" };
+    });
+    this.rpcHandlerManager.registerHandler("stop-daemon", () => {
+      logger.debug("[API MACHINE] Received stop-daemon RPC request");
+      setTimeout(() => {
+        logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
+        requestShutdown();
+      }, 100);
+      return { message: "Daemon stop request acknowledged, starting shutdown sequence..." };
+    });
+  }
+  /**
+   * Update machine metadata
+   * Currently unused, changes from the mobile client are more likely
+   * for example to set a custom name.
+   */
+  async updateMachineMetadata(handler) {
+    await backoff(async () => {
+      const updated = handler(this.machine.metadata);
+      const answer = await this.socket.emitWithAck("machine-update-metadata", {
+        machineId: this.machine.id,
+        metadata: encodeBase64(encrypt(updated, this.secret)),
+        expectedVersion: this.machine.metadataVersion
+      });
+      if (answer.result === "success") {
+        this.machine.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        this.machine.metadataVersion = answer.version;
+        logger.debug("[API MACHINE] Metadata updated successfully");
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.machine.metadataVersion) {
+          this.machine.metadataVersion = answer.version;
+          this.machine.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        }
+        throw new Error("Metadata version mismatch");
+      }
+    });
+  }
+  /**
+   * Update daemon state (runtime info) - similar to session updateAgentState
+   * Simplified without lock - relies on backoff for retry
+   */
+  async updateDaemonState(handler) {
+    await backoff(async () => {
+      const updated = handler(this.machine.daemonState);
+      const answer = await this.socket.emitWithAck("machine-update-state", {
+        machineId: this.machine.id,
+        daemonState: encodeBase64(encrypt(updated, this.secret)),
+        expectedVersion: this.machine.daemonStateVersion
+      });
+      if (answer.result === "success") {
+        this.machine.daemonState = decrypt(decodeBase64(answer.daemonState), this.secret);
+        this.machine.daemonStateVersion = answer.version;
+        logger.debug("[API MACHINE] Daemon state updated successfully");
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.machine.daemonStateVersion) {
+          this.machine.daemonStateVersion = answer.version;
+          this.machine.daemonState = decrypt(decodeBase64(answer.daemonState), this.secret);
+        }
+        throw new Error("Daemon state version mismatch");
+      }
+    });
+  }
+  connect() {
+    const serverUrl = configuration.serverUrl.replace(/^http/, "ws");
+    logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
+    this.socket = socket_ioClient.io(serverUrl, {
+      transports: ["websocket"],
+      auth: {
+        token: this.token,
+        clientType: "machine-scoped",
+        machineId: this.machine.id
+      },
+      path: "/v1/updates",
+      reconnection: true,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3
+    });
+    this.socket.on("connect", () => {
+      logger.debug("[API MACHINE] Connected to server");
+      this.updateDaemonState((state) => ({
+        ...state,
+        status: "running",
+        pid: process.pid,
+        httpPort: this.machine.daemonState?.httpPort,
+        startedAt: Date.now()
+      }));
+      this.rpcHandlerManager.onSocketConnect(this.socket);
+      this.startKeepAlive();
+      this.setupTerminalListeners();
+    });
+    this.socket.on("disconnect", () => {
+      logger.debug("[API MACHINE] Disconnected from server");
+      this.rpcHandlerManager.onSocketDisconnect();
+      this.stopKeepAlive();
+      this.terminalManager.closeAll();
+    });
+    this.socket.on("rpc-request", async (data, callback) => {
+      logger.debugLargeJson(`[API MACHINE] Received RPC request:`, data);
+      callback(await this.rpcHandlerManager.handleRequest(data));
+    });
+    this.socket.on("update", (data) => {
+      if (data.body.t === "update-machine" && data.body.machineId === this.machine.id) {
+        const update = data.body;
+        if (update.metadata) {
+          logger.debug("[API MACHINE] Received external metadata update");
+          this.machine.metadata = decrypt(decodeBase64(update.metadata.value), this.secret);
+          this.machine.metadataVersion = update.metadata.version;
+        }
+        if (update.daemonState) {
+          logger.debug("[API MACHINE] Received external daemon state update");
+          this.machine.daemonState = decrypt(decodeBase64(update.daemonState.value), this.secret);
+          this.machine.daemonStateVersion = update.daemonState.version;
+        }
+      } else {
+        logger.debug(`[API MACHINE] Received unknown update type: ${data.body.t}`);
+      }
+    });
+    this.socket.on("connect_error", (error) => {
+      logger.debug(`[API MACHINE] Connection error: ${error.message}`);
+    });
+    this.socket.io.on("error", (error) => {
+      logger.debug("[API MACHINE] Socket error:", error);
+    });
+  }
+  /**
+   * Set up terminal event listeners from server
+   */
+  setupTerminalListeners() {
+    this.socket.on("terminal-spawn", async (data) => {
+      try {
+        const settings = await readSettings();
+        if (settings.terminalEnabled === false) {
+          logger.debug(`[API MACHINE] Terminal is disabled; rejecting spawn ${data.sessionId}`);
+          this.socket.emit("terminal-error", { sessionId: data.sessionId, code: "DISABLED", message: "Terminal is disabled on this machine" });
+          return;
+        }
+      } catch {
+      }
+      logger.debug(`[API MACHINE] Received terminal-spawn request: ${data.sessionId}`);
+      this.terminalManager.spawn(data.sessionId, data.cols || 80, data.rows || 24);
+    });
+    this.socket.on("terminal-stdin", (data) => {
+      this.terminalManager.writeStdin(data.sessionId, data.dataBase64);
+    });
+    this.socket.on("terminal-resize", (data) => {
+      logger.debug(`[API MACHINE] Received terminal-resize request: ${data.sessionId} to ${data.cols}x${data.rows}`);
+      this.terminalManager.resize(data.sessionId, data.cols, data.rows);
+    });
+    this.socket.on("terminal-close", (data) => {
+      logger.debug(`[API MACHINE] Received terminal-close request: ${data.sessionId}`);
+      this.terminalManager.close(data.sessionId);
+    });
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveInterval = setInterval(() => {
+      const payload = {
+        machineId: this.machine.id,
+        time: Date.now()
+      };
+      if (process.env.DEBUG) {
+        logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
+      }
+      this.socket.emit("machine-alive", payload);
+    }, 2e4);
+    logger.debug("[API MACHINE] Keep-alive started (20s interval)");
+  }
+  stopKeepAlive() {
+    if (this.keepAliveInterval) {
+      clearInterval(this.keepAliveInterval);
+      this.keepAliveInterval = null;
+      logger.debug("[API MACHINE] Keep-alive stopped");
+    }
+  }
+  shutdown() {
+    logger.debug("[API MACHINE] Shutting down");
+    this.stopKeepAlive();
+    this.terminalManager.closeAll();
+    if (this.socket) {
+      this.socket.close();
+      logger.debug("[API MACHINE] Socket closed");
+    }
+  }
+}
+
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expo;
+  constructor(token, baseUrl = "https://api.cluster-fluster.com") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+    this.expo = new expoServerSdk.Expo();
+  }
+  /**
+   * Fetch all push tokens for the authenticated user
+   */
+  async fetchPushTokens() {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/v1/push-tokens`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+      response.data.tokens.forEach((token, index) => {
+        logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, token=${token.token}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
+      });
+      return response.data.tokens;
+    } catch (error) {
+      logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
+      throw new Error(`Failed to fetch push tokens: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Send push notification via Expo Push API with retry
+   * @param messages - Array of push messages to send
+   */
+  async sendPushNotifications(messages) {
+    logger.debug(`Sending ${messages.length} push notifications`);
+    const validMessages = messages.filter((message) => {
+      if (Array.isArray(message.to)) {
+        return message.to.every((token) => expoServerSdk.Expo.isExpoPushToken(token));
+      }
+      return expoServerSdk.Expo.isExpoPushToken(message.to);
+    });
+    if (validMessages.length === 0) {
+      logger.debug("No valid Expo push tokens found");
+      return;
+    }
+    const chunks = this.expo.chunkPushNotifications(validMessages);
+    for (const chunk of chunks) {
+      const startTime = Date.now();
+      const timeout = 3e5;
+      let attempt = 0;
+      while (true) {
+        try {
+          const ticketChunk = await this.expo.sendPushNotificationsAsync(chunk);
+          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
+          if (errors.length > 0) {
+            const errorDetails = errors.map((e) => ({ message: e.message, details: e.details }));
+            logger.debug("[PUSH] Some notifications failed:", errorDetails);
+          }
+          if (errors.length === ticketChunk.length) {
+            throw new Error("All push notifications in chunk failed");
+          }
+          break;
+        } catch (error) {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            break;
+          }
+          attempt++;
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          const remainingTime = timeout - elapsed;
+          const waitTime = Math.min(delay, remainingTime);
+          if (waitTime > 0) {
+            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+    }
+    logger.debug(`Push notifications sent successfully`);
+  }
+  /**
+   * Send a push notification to all registered devices for the user
+   * @param title - Notification title
+   * @param body - Notification body
+   * @param data - Additional data to send with the notification
+   */
+  sendToAllDevices(title, body, data) {
+    logger.debug(`[PUSH] sendToAllDevices called with title: "${title}", body: "${body}"`);
+    (async () => {
+      try {
+        logger.debug("[PUSH] Fetching push tokens...");
+        const tokens = await this.fetchPushTokens();
+        logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
+        tokens.forEach((token, index) => {
+          logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}, token=${token.token}`);
+        });
+        if (tokens.length === 0) {
+          logger.debug("No push tokens found for user");
+          return;
+        }
+        const messages = tokens.map((token, index) => {
+          logger.debug(`[PUSH] Creating message ${index + 1} for token: ${token.token}`);
+          return {
+            to: token.token,
+            title,
+            body,
+            data,
+            sound: "default",
+            priority: "high"
+          };
+        });
+        logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        await this.sendPushNotifications(messages);
+        logger.debug("[PUSH] Push notifications sent successfully");
+      } catch (error) {
+        logger.debug("[PUSH] Error sending to all devices:", error);
+      }
+    })();
+  }
+}
+
+class ApiClient {
+  token;
+  secret;
+  pushClient;
+  constructor(token, secret) {
+    this.token = token;
+    this.secret = secret;
+    this.pushClient = new PushNotificationClient(token);
+  }
+  /**
+   * Create a new session or load existing one with the given tag
+   */
+  async getOrCreateSession(opts) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions`,
+        {
+          tag: opts.tag,
+          metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
+          agentState: opts.state ? encodeBase64(encrypt(opts.state, this.secret)) : null
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          },
+          timeout: 5e3
+          // 5 second timeout
+        }
+      );
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      let raw = response.data.session;
+      let session = {
+        id: raw.id,
+        createdAt: raw.createdAt,
+        updatedAt: raw.updatedAt,
+        seq: raw.seq,
+        metadata: decrypt(decodeBase64(raw.metadata), this.secret),
+        metadataVersion: raw.metadataVersion,
+        agentState: raw.agentState ? decrypt(decodeBase64(raw.agentState), this.secret) : null,
+        agentStateVersion: raw.agentStateVersion
+      };
+      return session;
+    } catch (error) {
+      logger.debug("[API] [ERROR] Failed to get or create session:", error);
+      throw new Error(`Failed to get or create session: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get machine by ID from the server
+   * Returns the current machine state from the server with decrypted metadata and daemonState
+   */
+  async getMachine(machineId) {
+    const response = await axios.get(`${configuration.serverUrl}/v1/machines/${machineId}`, {
+      headers: {
+        "Authorization": `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 2e3
+    });
+    const raw = response.data.machine;
+    if (!raw) {
+      return null;
+    }
+    logger.debug(`[API] Machine ${machineId} fetched from server`);
+    const machine = {
+      id: raw.id,
+      metadata: raw.metadata ? decrypt(decodeBase64(raw.metadata), this.secret) : null,
+      metadataVersion: raw.metadataVersion || 0,
+      daemonState: raw.daemonState ? decrypt(decodeBase64(raw.daemonState), this.secret) : null,
+      daemonStateVersion: raw.daemonStateVersion || 0,
+      active: raw.active,
+      activeAt: raw.activeAt,
+      createdAt: raw.createdAt,
+      updatedAt: raw.updatedAt
+    };
+    return machine;
+  }
+  /**
+   * Register or update machine with the server
+   * Returns the current machine state from the server with decrypted metadata and daemonState
+   */
+  async getOrCreateMachine(opts) {
+    const response = await axios.post(
+      `${configuration.serverUrl}/v1/machines`,
+      {
+        id: opts.machineId,
+        metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
+        daemonState: opts.daemonState ? encodeBase64(encrypt(opts.daemonState, this.secret)) : void 0
+      },
+      {
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 5e3
+      }
+    );
+    if (response.status !== 200) {
+      console.error(chalk.red(`[API] Failed to create machine: ${response.statusText}`));
+      console.log(chalk.yellow(`[API] Failed to create machine: ${response.statusText}, most likely you have re-authenticated, but you still have a machine associated with the old account. Now we are trying to re-associate the machine with the new account. That is not allowed. Please run 'happy doctor clean' to clean up your happy state, and try your original command again. Please create an issue on github if this is causing you problems. We apologize for the inconvenience.`));
+      process.exit(1);
+    }
+    const raw = response.data.machine;
+    logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
+    const machine = {
+      id: raw.id,
+      metadata: raw.metadata ? decrypt(decodeBase64(raw.metadata), this.secret) : null,
+      metadataVersion: raw.metadataVersion || 0,
+      daemonState: raw.daemonState ? decrypt(decodeBase64(raw.daemonState), this.secret) : null,
+      daemonStateVersion: raw.daemonStateVersion || 0,
+      active: raw.active,
+      activeAt: raw.activeAt,
+      createdAt: raw.createdAt,
+      updatedAt: raw.updatedAt
+    };
+    return machine;
+  }
+  sessionSyncClient(session) {
+    return new ApiSessionClient(this.token, this.secret, session);
+  }
+  machineSyncClient(machine) {
+    return new ApiMachineClient(this.token, this.secret, machine);
+  }
+  push() {
+    return this.pushClient;
+  }
+  /**
+   * Register a vendor API token with the server
+   * The token is sent as a JSON string - server handles encryption
+   */
+  async registerVendorToken(vendor, apiKey) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/connect/${vendor}/register`,
+        {
+          token: JSON.stringify(apiKey)
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          },
+          timeout: 5e3
+        }
+      );
+      if (response.status !== 200 && response.status !== 201) {
+        throw new Error(`Server returned status ${response.status}`);
+      }
+      logger.debug(`[API] Vendor token for ${vendor} registered successfully`);
+    } catch (error) {
+      logger.debug(`[API] [ERROR] Failed to register vendor token:`, error);
+      throw new Error(`Failed to register vendor token: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+}
+
+const UsageSchema = z.z.object({
+  input_tokens: z.z.number().int().nonnegative(),
+  cache_creation_input_tokens: z.z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z.z.number().int().nonnegative().optional(),
+  output_tokens: z.z.number().int().nonnegative(),
+  service_tier: z.z.string().optional()
+}).passthrough();
+const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
+  // User message - validates uuid and message.content
+  z.z.object({
+    type: z.z.literal("user"),
+    isSidechain: z.z.boolean().optional(),
+    isMeta: z.z.boolean().optional(),
+    uuid: z.z.string(),
+    // Used in getMessageKey()
+    message: z.z.object({
+      content: z.z.union([z.z.string(), z.z.any()])
+      // Used in sessionScanner.ts
+    }).passthrough()
+  }).passthrough(),
+  // Assistant message - validates message object with usage and content
+  z.z.object({
+    uuid: z.z.string(),
+    type: z.z.literal("assistant"),
+    message: z.z.object({
+      // Entire message used in getMessageKey()
+      usage: UsageSchema.optional(),
+      // Used in apiSession.ts
+      content: z.z.any()
+      // Used in tests
+    }).passthrough()
+  }).passthrough(),
+  // Summary message - validates summary and leafUuid
+  z.z.object({
+    type: z.z.literal("summary"),
+    summary: z.z.string(),
+    // Used in apiSession.ts
+    leafUuid: z.z.string()
+    // Used in getMessageKey()
+  }).passthrough(),
+  // System message - validates uuid
+  z.z.object({
+    type: z.z.literal("system"),
+    uuid: z.z.string()
+    // Used in getMessageKey()
+  }).passthrough()
+]);
+
+exports.ApiClient = ApiClient;
+exports.ApiSessionClient = ApiSessionClient;
+exports.AsyncLock = AsyncLock;
+exports.RawJSONLinesSchema = RawJSONLinesSchema;
+exports.acquireDaemonLock = acquireDaemonLock;
+exports.backoff = backoff;
+exports.clearCredentials = clearCredentials;
+exports.clearDaemonState = clearDaemonState;
+exports.clearMachineId = clearMachineId;
+exports.configuration = configuration;
+exports.decodeBase64 = decodeBase64;
+exports.delay = delay;
+exports.encodeBase64 = encodeBase64;
+exports.encodeBase64Url = encodeBase64Url;
+exports.getLatestDaemonLog = getLatestDaemonLog;
+exports.logger = logger;
+exports.packageJson = packageJson;
+exports.projectPath = projectPath;
+exports.readCredentials = readCredentials;
+exports.readDaemonState = readDaemonState;
+exports.readSettings = readSettings;
+exports.releaseDaemonLock = releaseDaemonLock;
+exports.updateActivityTimestamp = updateActivityTimestamp;
+exports.updateSettings = updateSettings;
+exports.writeCredentials = writeCredentials;
+exports.writeDaemonState = writeDaemonState;
+exports.writeHeadlessJson = writeHeadlessJson;