flockbay 0.10.15

package/dist/types-DGd6ea2Z.mjs

@@ -0,0 +1,4450 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { appendFileSync } from 'fs';
+import fs__default, { existsSync, readFileSync, mkdirSync, constants, unlinkSync, writeFileSync, readdirSync, statSync, createWriteStream } from 'node:fs';
+import os, { homedir } from 'node:os';
+import path, { join, basename } from 'node:path';
+import { readFile, open, stat, unlink, mkdir, writeFile, rename } from 'node:fs/promises';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
+import { randomBytes, createCipheriv, createDecipheriv, randomUUID as randomUUID$1 } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
+import { spawn as spawn$1 } from 'node:child_process';
+import { spawn } from 'child_process';
+import { realpath, stat as stat$1, readdir, rm, mkdir as mkdir$1, readFile as readFile$1, open as open$1, writeFile as writeFile$1, chmod } from 'fs/promises';
+import { randomUUID, createHash } from 'crypto';
+import { dirname, resolve, join as join$1, relative } from 'path';
+import { fileURLToPath } from 'url';
+import process$1 from 'node:process';
+import { platform } from 'os';
+import net from 'node:net';
+import { Expo } from 'expo-server-sdk';
+
+var name = "flockbay";
+var version = "0.10.15";
+var description = "Flockbay CLI (local agent + daemon)";
+var author = "Eduardo Orellana";
+var license = "UNLICENSED";
+var type = "module";
+var homepage = "https://flockbay.com";
+var bugs = "https://flockbay.com";
+var repository = {
+	type: "git",
+	url: "https://flockbay.com"
+};
+var bin = {
+	flockbay: "bin/flockbay.mjs",
+	"flockbay-mcp": "bin/flockbay-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/flockbayMcpStdioBridge": {
+		require: {
+			types: "./dist/codex/flockbayMcpStdioBridge.d.cts",
+			"default": "./dist/codex/flockbayMcpStdioBridge.cjs"
+		},
+		"import": {
+			types: "./dist/codex/flockbayMcpStdioBridge.d.mts",
+			"default": "./dist/codex/flockbayMcpStdioBridge.mjs"
+		}
+	}
+};
+var files = [
+	"dist",
+	"bin",
+	"kits",
+	"scripts",
+	"tools/licenses",
+	"tools/unreal-mcp",
+	"package.json"
+];
+var scripts = {
+	"why do we need to build before running tests / dev?": "We need the binary to be built so daemon commands run the built CLI (avoids drift between dev entrypoints and the packaged runtime).",
+	typecheck: "tsc --noEmit",
+	build: "shx rm -rf dist && npx tsc --noEmit && pkgroll",
+	test: "yarn build && vitest run",
+	start: "yarn build && node ./bin/flockbay.mjs",
+	dev: "tsx 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: "yarn install && release-it",
+	postinstall: "node scripts/unpack-tools.cjs"
+};
+var dependencies = {
+	"@agentclientprotocol/sdk": "^0.8.0",
+	"@modelcontextprotocol/sdk": "^1.22.0",
+	"@stablelib/base64": "^2.0.1",
+	"@stablelib/hex": "^2.0.1",
+	"@types/cross-spawn": "^6.0.6",
+	"@types/http-proxy": "^1.17.17",
+	"@types/ps-list": "^6.2.1",
+	"@types/qrcode-terminal": "^0.12.2",
+	"@types/react": "^19.2.7",
+	"@types/tmp": "^0.2.6",
+	ai: "^5.0.107",
+	axios: "^1.13.2",
+	chalk: "^5.6.2",
+	"cross-spawn": "^7.0.6",
+	"expo-server-sdk": "^3.15.0",
+	fastify: "^5.6.2",
+	"fastify-type-provider-zod": "4.0.2",
+	"http-proxy": "^1.18.1",
+	"http-proxy-middleware": "^3.0.5",
+	ink: "^6.5.1",
+	open: "^10.2.0",
+	"ps-list": "^8.1.1",
+	"qrcode-terminal": "^0.12.0",
+	react: "^19.2.0",
+	"socket.io-client": "^4.8.1",
+	tar: "^7.5.2",
+	tmp: "^0.2.5",
+	tweetnacl: "^1.0.3",
+	zod: "^3.23.8"
+};
+var devDependencies = {
+	"@eslint/compat": "^1",
+	"@types/node": ">=20",
+	"cross-env": "^10.1.0",
+	dotenv: "^16.6.1",
+	eslint: "^9",
+	"eslint-config-prettier": "^10",
+	pkgroll: "^2.14.2",
+	"release-it": "^19.0.6",
+	shx: "^0.3.3",
+	"ts-node": "^10",
+	tsx: "^4.20.6",
+	typescript: "^5",
+	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
+};
+
+function normalizeServerUrlForNode(url) {
+  try {
+    const u = new URL(url);
+    if (u.hostname === "localhost") u.hostname = "127.0.0.1";
+    return u.origin;
+  } catch {
+    return url;
+  }
+}
+class Configuration {
+  serverUrl;
+  webappUrl;
+  isDaemonProcess;
+  // Directories and paths (from persistence)
+  flockbayHomeDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  daemonStateFile;
+  daemonLockFile;
+  currentCliVersion;
+  isExperimentalEnabled;
+  disableCaffeinate;
+  constructor() {
+    const args = process.argv.slice(2);
+    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
+    const homeOverride = process.env.FLOCKBAY_HOME_DIR;
+    if (homeOverride) {
+      const expandedPath = homeOverride.replace(/^~/, homedir());
+      this.flockbayHomeDir = expandedPath;
+    } else {
+      this.flockbayHomeDir = join(homedir(), ".flockbay");
+    }
+    this.logsDir = join(this.flockbayHomeDir, "logs");
+    this.settingsFile = join(this.flockbayHomeDir, "settings.json");
+    this.privateKeyFile = join(this.flockbayHomeDir, "access.key");
+    this.daemonStateFile = join(this.flockbayHomeDir, "daemon.state.json");
+    this.daemonLockFile = join(this.flockbayHomeDir, "daemon.state.json.lock");
+    let persistedSettings = null;
+    try {
+      if (existsSync(this.settingsFile)) {
+        persistedSettings = JSON.parse(readFileSync(this.settingsFile, "utf8"));
+      }
+    } catch {
+    }
+    const rawServerUrl = process.env.FLOCKBAY_SERVER_URL || persistedSettings?.serverUrl || "https://api-internal.flockbay.com";
+    this.serverUrl = normalizeServerUrlForNode(rawServerUrl);
+    this.webappUrl = process.env.FLOCKBAY_WEBAPP_URL || persistedSettings?.webappUrl || "https://flockbay.com";
+    this.isExperimentalEnabled = ["true", "1", "yes"].includes(
+      (process.env.FLOCKBAY_EXPERIMENTAL || "").toLowerCase()
+    );
+    this.disableCaffeinate = ["true", "1", "yes"].includes(
+      (process.env.FLOCKBAY_DISABLE_CAFFEINATE || "").toLowerCase()
+    );
+    this.currentCliVersion = packageJson.version;
+    if (!existsSync(this.flockbayHomeDir)) {
+      mkdirSync(this.flockbayHomeDir, { recursive: true });
+    }
+    if (!existsSync(this.logsDir)) {
+      mkdirSync(this.logsDir, { recursive: true });
+    }
+  }
+}
+const configuration = new Configuration();
+
+function encodeBase64(buffer, variant = "base64") {
+  if (variant === "base64url") {
+    return encodeBase64Url(buffer);
+  }
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64, variant = "base64") {
+  if (variant === "base64url") {
+    const base64Standard = base64.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - base64.length % 4) % 4);
+    return new Uint8Array(Buffer.from(base64Standard, "base64"));
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(randomBytes(size));
+}
+function 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 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, data) {
+  return encryptWithDataKey(data, key);
+}
+function decrypt(key, data) {
+  return decryptWithDataKey(data, key);
+}
+
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!existsSync(configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await 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 open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await unlink(lockFile).catch((unlinkErr) => {
+              if (unlinkErr?.code !== "ENOENT") {
+                console.error("[persistence] Failed to remove stale settings lock file", { lockFile, unlinkErr });
+              }
+            });
+          }
+        } catch (staleErr) {
+          console.error("[persistence] Failed while checking/removing stale settings lock file", { lockFile, staleErr });
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const current = await readSettings() || { ...defaultSettings };
+    const updated = await updater(current);
+    if (!existsSync(configuration.flockbayHomeDir)) {
+      await mkdir(configuration.flockbayHomeDir, { recursive: true });
+    }
+    await writeFile(tmpFile, JSON.stringify(updated, null, 2));
+    await rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z.object({
+  token: z.string(),
+  encryption: z.object({
+    publicKey: z.string().base64(),
+    machineKey: z.string().base64()
+  })
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    return {
+      token: credentials.token,
+      encryption: {
+        type: "dataKey",
+        publicKey: new Uint8Array(Buffer.from(credentials.encryption.publicKey, "base64")),
+        machineKey: new Uint8Array(Buffer.from(credentials.encryption.machineKey, "base64"))
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCredentialsDataKey(credentials) {
+  if (!existsSync(configuration.flockbayHomeDir)) {
+    await mkdir(configuration.flockbayHomeDir, { recursive: true });
+  }
+  await writeFile(configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
+    token: credentials.token
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (existsSync(configuration.privateKeyFile)) {
+    await unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  writeFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearDaemonState() {
+  if (existsSync(configuration.daemonStateFile)) {
+    await unlink(configuration.daemonStateFile);
+  }
+  if (existsSync(configuration.daemonLockFile)) {
+    try {
+      await unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await open(
+        configuration.daemonLockFile,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              unlinkSync(configuration.daemonLockFile);
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      if (attempt === maxAttempts) {
+        return null;
+      }
+      const delayMs = attempt * delayIncrementMs;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return null;
+}
+async function releaseDaemonLock(lockHandle) {
+  try {
+    await lockHandle.close();
+  } catch (err) {
+    console.error("[persistence] Failed to close daemon lock handle", err);
+  }
+  try {
+    if (existsSync(configuration.daemonLockFile)) {
+      unlinkSync(configuration.daemonLockFile);
+    }
+  } catch (err) {
+    console.error("[persistence] Failed to remove daemon lock file", { lockFile: configuration.daemonLockFile, err });
+  }
+}
+
+function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "") + "-pid-" + process.pid;
+}
+function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleTimeString("en-US", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+}
+function getSessionLogPath() {
+  const timestamp = createTimestampForFilename();
+  const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
+  return join(configuration.logsDir, filename);
+}
+class Logger {
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && process.env.FLOCKBAY_SERVER_URL) {
+      this.dangerouslyUnencryptedServerLoggingUrl = process.env.FLOCKBAY_SERVER_URL;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
+  }
+  dangerouslyUnencryptedServerLoggingUrl;
+  remoteLogErrorCount = 0;
+  lastRemoteLogErrorAt = 0;
+  logFileAppendErrorCount = 0;
+  lastLogFileAppendErrorAt = 0;
+  reportRemoteLoggingError(error) {
+    this.remoteLogErrorCount += 1;
+    const now = Date.now();
+    if (this.remoteLogErrorCount <= 3 || now - this.lastRemoteLogErrorAt > 6e4) {
+      this.lastRemoteLogErrorAt = now;
+      console.error("[REMOTE LOGGING] Failed to send logs to server:", error);
+    }
+  }
+  reportLogFileAppendError(error) {
+    this.logFileAppendErrorCount += 1;
+    const now = Date.now();
+    if (this.logFileAppendErrorCount <= 3 || now - this.lastLogFileAppendErrorAt > 6e4) {
+      this.lastLogFileAppendErrorAt = now;
+      console.error("[LOGGER] Failed to append to log file:", this.logFilePath, error);
+    }
+  }
+  // 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) {
+      this.reportRemoteLoggingError(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((error) => this.reportRemoteLoggingError(error));
+    }
+    try {
+      appendFileSync(this.logFilePath, logLine);
+    } catch (appendError) {
+      this.reportLogFileAppendError(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 state = await readDaemonState();
+      if (!state) {
+        return logs;
+      }
+      if (state.daemonLogPath && existsSync(state.daemonLogPath)) {
+        const stats = statSync(state.daemonLogPath);
+        const persisted = {
+          file: basename(state.daemonLogPath),
+          path: state.daemonLogPath,
+          modified: stats.mtime
+        };
+        const idx = logs.findIndex((l) => l.path === persisted.path);
+        if (idx >= 0) {
+          const [found] = logs.splice(idx, 1);
+          logs.unshift(found);
+        } else {
+          logs.unshift(persisted);
+        }
+      }
+    } catch {
+    }
+    return logs.slice(0, Math.max(0, limit));
+  } catch {
+    return [];
+  }
+}
+async function getLatestDaemonLog() {
+  const [latest] = await listDaemonLogFiles(1);
+  return latest || null;
+}
+
+const SessionMessageContentSchema = z$1.object({
+  c: z$1.string(),
+  // Base64 encoded encrypted content
+  t: z$1.literal("encrypted")
+});
+const UpdateBodySchema = z$1.object({
+  message: z$1.object({
+    id: z$1.string(),
+    seq: z$1.number(),
+    content: SessionMessageContentSchema
+  }),
+  sid: z$1.string(),
+  // Session ID
+  t: z$1.literal("new-message")
+});
+const UpdateSessionBodySchema = z$1.object({
+  t: z$1.literal("update-session"),
+  sid: z$1.string(),
+  metadata: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
+  }).nullish(),
+  agentState: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
+  }).nullish()
+});
+const UpdateMachineBodySchema = z$1.object({
+  t: z$1.literal("update-machine"),
+  machineId: z$1.string(),
+  metadata: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
+  }).nullish(),
+  daemonState: z$1.object({
+    version: z$1.number(),
+    value: z$1.string()
+  }).nullish()
+});
+z$1.object({
+  id: z$1.string(),
+  seq: z$1.number(),
+  body: z$1.union([
+    UpdateBodySchema,
+    UpdateSessionBodySchema,
+    UpdateMachineBodySchema
+  ]),
+  createdAt: z$1.number()
+});
+z$1.object({
+  host: z$1.string(),
+  platform: z$1.string(),
+  flockbayCliVersion: z$1.string(),
+  homeDir: z$1.string(),
+  flockbayHomeDir: z$1.string(),
+  flockbayLibDir: z$1.string(),
+  // Dev-only: bypass Unreal project + SDK gating (so sessions can run in arbitrary folders).
+  flockbayDevBypassUeGates: z$1.boolean().optional()
+});
+z$1.object({
+  status: z$1.union([
+    z$1.enum(["running", "shutting-down"]),
+    z$1.string()
+    // Forward compatibility
+  ]),
+  pid: z$1.number().optional(),
+  httpPort: z$1.number().optional(),
+  startedAt: z$1.number().optional(),
+  shutdownRequestedAt: z$1.number().optional(),
+  shutdownSource: z$1.union([
+    z$1.enum(["mobile-app", "cli", "os-signal", "unknown"]),
+    z$1.string()
+    // Forward compatibility
+  ]).optional()
+});
+z$1.object({
+  content: SessionMessageContentSchema,
+  createdAt: z$1.number(),
+  id: z$1.string(),
+  seq: z$1.number(),
+  updatedAt: z$1.number()
+});
+const MessageMetaSchema = z$1.object({
+  sentFrom: z$1.string().optional(),
+  // Source identifier
+  permissionMode: z$1.string().optional(),
+  // Permission mode for this message
+  model: z$1.string().nullable().optional(),
+  // Model name for this message (null = reset)
+  customSystemPrompt: z$1.string().nullable().optional(),
+  // Custom system prompt for this message (null = reset)
+  appendSystemPrompt: z$1.string().nullable().optional(),
+  // Append to system prompt for this message (null = reset)
+  allowedTools: z$1.array(z$1.string()).nullable().optional(),
+  // Allowed tools for this message (null = reset)
+  disallowedTools: z$1.array(z$1.string()).nullable().optional(),
+  // Disallowed tools for this message (null = reset)
+  // Optional text to show in UI instead of the raw prompt (mobile/web feature).
+  displayText: z$1.string().optional(),
+  // Optional multimodal attachments (base64-embedded; used for vision-capable agents).
+  attachments: z$1.object({
+    images: z$1.array(
+      z$1.object({
+        mimeType: z$1.string(),
+        base64: z$1.string(),
+        name: z$1.string().optional(),
+        width: z$1.number().optional(),
+        height: z$1.number().optional()
+      })
+    ).optional()
+  }).optional()
+});
+z$1.object({
+  session: z$1.object({
+    id: z$1.string(),
+    tag: z$1.string(),
+    seq: z$1.number(),
+    createdAt: z$1.number(),
+    updatedAt: z$1.number(),
+    metadata: z$1.string(),
+    metadataVersion: z$1.number(),
+    agentState: z$1.string().nullable(),
+    agentStateVersion: z$1.number()
+  })
+});
+const UserMessageSchema = z$1.object({
+  role: z$1.literal("user"),
+  content: z$1.object({
+    type: z$1.literal("text"),
+    text: z$1.string()
+  }),
+  localKey: z$1.string().optional(),
+  // Mobile messages include this
+  meta: MessageMetaSchema.optional()
+});
+const AgentMessageSchema = z$1.object({
+  role: z$1.literal("agent"),
+  content: z$1.object({
+    type: z$1.literal("output"),
+    data: z$1.any()
+  }),
+  meta: MessageMetaSchema.optional()
+});
+z$1.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;
+  encryptionKey;
+  logger;
+  socket = null;
+  constructor(config) {
+    this.scopePrefix = config.scopePrefix;
+    this.encryptionKey = config.encryptionKey;
+    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(this.encryptionKey, errorResponse));
+        return encryptedError;
+      }
+      const decryptedParams = decrypt(this.encryptionKey, decodeBase64(request.params));
+      const result = await handler(decryptedParams);
+      const encryptedResponse = encodeBase64(encrypt(this.encryptionKey, result));
+      return encryptedResponse;
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling request", { error });
+      const errorResponse = {
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+      return encodeBase64(encrypt(this.encryptionKey, errorResponse));
+    }
+  }
+  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 = dirname(fileURLToPath(import.meta.url));
+function projectPath() {
+  const path = resolve(__dirname$1, "..");
+  return path;
+}
+
+function run$1(args, options) {
+  const RUNNER_PATH = resolve(join$1(projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  return new Promise((resolve2, reject) => {
+    const child = spawn(process$1.execPath, [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 = platform();
+  const binaryName = platformName === "win32" ? "difft.exe" : "difft";
+  return resolve(join$1(projectPath(), "tools", "unpacked", binaryName));
+}
+function run(args, options) {
+  const binaryPath = getBinaryPath();
+  return new Promise((resolve2, reject) => {
+    const child = 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);
+    });
+  });
+}
+
+function unrealMcpBundleRoot() {
+  return path.join(projectPath(), "tools", "unreal-mcp", "upstream");
+}
+function unrealMcpPythonDir() {
+  return path.join(unrealMcpBundleRoot(), "Python");
+}
+function unrealMcpPluginSourceDir() {
+  return path.join(unrealMcpBundleRoot(), "MCPGameProject", "Plugins", "UnrealMCP");
+}
+
+function waitForJsonFromSocket(socket, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    let settled = false;
+    const cleanup = () => {
+      socket.off("data", onData);
+      socket.off("error", onError);
+      socket.off("close", onClose);
+    };
+    const finishOk = (obj) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(obj);
+    };
+    const finishErr = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onError = (err) => finishErr(err);
+    const onClose = () => {
+      if (!settled) finishErr(new Error("Connection closed before receiving a complete JSON response."));
+    };
+    const onData = (chunk) => {
+      buffer += chunk.toString("utf8");
+      try {
+        const parsed = JSON.parse(buffer);
+        finishOk(parsed);
+      } catch {
+      }
+    };
+    socket.on("data", onData);
+    socket.on("error", onError);
+    socket.on("close", onClose);
+    socket.setTimeout(timeoutMs, () => finishErr(new Error(`Timed out waiting for Unreal response after ${timeoutMs}ms.`)));
+  });
+}
+async function sendUnrealMcpTcpCommand(options) {
+  const host = (options.host || "127.0.0.1").trim() || "127.0.0.1";
+  const port = Number.isFinite(options.port) ? Number(options.port) : 55557;
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(250, Number(options.timeoutMs)) : 5e3;
+  const type = String(options.type || "").trim();
+  if (!type) throw new Error("Missing Unreal MCP command type.");
+  const payload = JSON.stringify({ type, params: options.params || {} });
+  const socket = new net.Socket();
+  socket.setNoDelay(true);
+  await new Promise((resolve, reject) => {
+    const onError = (err) => {
+      socket.off("connect", onConnect);
+      reject(err);
+    };
+    const onConnect = () => {
+      socket.off("error", onError);
+      resolve();
+    };
+    socket.once("error", onError);
+    socket.once("connect", onConnect);
+    socket.connect(port, host);
+  });
+  socket.write(payload, "utf8");
+  const response = await waitForJsonFromSocket(socket, timeoutMs);
+  if (response && typeof response === "object") {
+    const status = response.status;
+    if (status === "error") {
+      const errorMessage = typeof response.error === "string" ? response.error : `UnrealMCP error (unrecognized response): ${JSON.stringify(response)}`;
+      const hints = [];
+      const isUnknownCommand = errorMessage.includes("Unknown command:") || errorMessage.includes("Unknown editor command:") || errorMessage.includes("Unknown blueprint command:") || errorMessage.includes("Unknown blueprint node command:") || errorMessage.includes("Unknown project command:") || errorMessage.includes("Unknown UMG command:");
+      if (isUnknownCommand) {
+        hints.push(
+          "Tip: your UnrealMCP plugin build likely does not expose that command. Run `get_plugin_info` to see the exact supported command list for the running editor, then retry with a supported command."
+        );
+        hints.push(
+          "Fix (if commands are missing): your UnrealMCP engine plugin is likely out of date, shadowed by another UnrealMCP install, or running stale binaries.\n- Ensure there is only ONE UnrealMCP plugin under your engine folder (common conflict: Engine/Plugins/Marketplace/UnrealMCP).\n- Reinstall the engine plugin (delete Engine/Plugins/UnrealMCP so Unreal rebuilds), then restart the editor."
+        );
+      }
+      const missingParamMatch = errorMessage.match(/Missing '([^']+)' parameter/);
+      if (missingParamMatch) {
+        const paramName = missingParamMatch[1];
+        hints.push(`Tip: include the required parameter \`${paramName}\` in the request params (UnrealMCP does not infer defaults).`);
+      }
+      const hint = hints.length > 0 ? `
+
+${hints.join("\n\n")}` : "";
+      throw new Error(`${errorMessage}${hint}`);
+    }
+  }
+  try {
+    socket.end();
+  } catch {
+  }
+  return response;
+}
+
+function validatePath(targetPath, workingDirectory) {
+  const resolvedTarget = resolve(workingDirectory, targetPath);
+  const resolvedWorkingDir = resolve(workingDirectory);
+  if (!resolvedTarget.startsWith(resolvedWorkingDir + "/") && resolvedTarget !== resolvedWorkingDir) {
+    return {
+      valid: false,
+      error: `Access denied: Path '${targetPath}' is outside the working directory`
+    };
+  }
+  return { valid: true, resolvedPath: resolvedTarget };
+}
+
+function logNonSilent(context, error, ignoredCodes = []) {
+  const e = error;
+  const code = typeof e?.code === "string" ? e.code : null;
+  if (code && ignoredCodes.includes(code)) return;
+  console.error(context, error);
+  logger.debug(context, error);
+}
+async function maybeAutoShipWorkItemAfterCommit(params) {
+  if (String(process.env.FLOCKBAY_COORDINATION_AUTO_SHIP_ON_COMMIT || "").trim() !== "1") {
+    return { ok: true };
+  }
+  const coordination = params.coordination;
+  if (!coordination) return { ok: true };
+  const projectId = String(coordination.workspaceProjectId || "").trim();
+  const workItemId = String(coordination.workItemId || "").trim();
+  if (!projectId || !workItemId) return { ok: true };
+  const head = await runProcess({
+    command: "git",
+    args: ["rev-parse", "HEAD"],
+    cwd: params.cwd,
+    timeoutMs: 15e3
+  });
+  if (!head.success) {
+    return { ok: false, error: head.stderr || head.error || "Failed to read commit hash" };
+  }
+  const commitHash = String(head.stdout || "").trim();
+  if (!commitHash) return { ok: false, error: "Missing commit hash" };
+  {
+    const url = `${coordination.serverUrl.replace(/\/+$/, "")}/v1/coordination/work-items/update`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${coordination.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        projectId,
+        workItemId,
+        commitHash
+      })
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok || !data?.success) {
+      const msg = typeof data?.error === "string" ? data.error : `work item update failed (${res.status})`;
+      return { ok: false, error: msg };
+    }
+  }
+  return { ok: true };
+}
+class TailBuffer {
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+  }
+  chunks = [];
+  totalBytes = 0;
+  truncated = false;
+  push(chunk) {
+    if (!chunk?.length) return;
+    this.chunks.push(chunk);
+    this.totalBytes += chunk.length;
+    while (this.totalBytes > this.maxBytes && this.chunks.length > 0) {
+      const extra = this.totalBytes - this.maxBytes;
+      const first = this.chunks[0];
+      this.truncated = true;
+      if (first.length <= extra) {
+        this.chunks.shift();
+        this.totalBytes -= first.length;
+        continue;
+      }
+      this.chunks[0] = first.subarray(extra);
+      this.totalBytes -= extra;
+      break;
+    }
+  }
+  toString() {
+    if (this.chunks.length === 0) return "";
+    return Buffer.concat(this.chunks, this.totalBytes).toString("utf8");
+  }
+  isTruncated() {
+    return this.truncated;
+  }
+}
+function asText(value) {
+  return typeof value === "string" ? value : String(value ?? "");
+}
+function ensureConfirmed(action, confirm) {
+  const writeActions = [
+    "clone",
+    "init_repo",
+    "stage_paths",
+    "unstage_paths",
+    "unstage_all",
+    "restore_file",
+    "discard_unstaged",
+    "discard_all",
+    "commit_all",
+    "commit_staged",
+    "revert_commit",
+    "reapply_commit",
+    "push_head",
+    "pr_create",
+    "github_snapshot_push",
+    "github_snapshot_pr_create"
+  ];
+  if (!writeActions.includes(action)) return;
+  if (confirm === true) return;
+  throw new Error(`confirmation_required:${action}`);
+}
+function sanitizeDestFolder(destFolder) {
+  const dest = destFolder.trim().replace(/^\/+|\/+$/g, "");
+  if (!dest) throw new Error("missing_dest_folder");
+  if (dest.startsWith(".") || dest.includes("..") || dest.includes("\\")) throw new Error("invalid_dest_folder");
+  if (dest.includes("\0")) throw new Error("invalid_dest_folder");
+  return dest;
+}
+function sanitizeRelativeGitPaths(value) {
+  const paths = Array.isArray(value) ? value : [];
+  if (paths.length === 0) throw new Error("missing_paths");
+  if (paths.length > 500) throw new Error("too_many_paths");
+  return paths.map((p) => {
+    const s = asText(p).trim().replace(/\\/g, "/");
+    if (!s) throw new Error("invalid_path");
+    if (s.includes("\0")) throw new Error("invalid_path");
+    if (s.startsWith("/")) throw new Error("invalid_path");
+    if (s === "." || s.startsWith("./")) throw new Error("invalid_path");
+    if (s === ".." || s.startsWith("../") || s.includes("/../")) throw new Error("invalid_path");
+    return s;
+  });
+}
+function sanitizeGitCommitHash(input) {
+  const s = asText(input).trim();
+  if (!s) throw new Error("missing_commit_hash");
+  if (!/^[0-9a-f]{7,40}$/i.test(s)) throw new Error("invalid_commit_hash");
+  return s;
+}
+function normalizePathSlashes(input) {
+  return String(input || "").replace(/\\/g, "/");
+}
+function inferEngineRootFromPluginBaseDir(baseDir) {
+  const raw = normalizePathSlashes(baseDir).trim();
+  if (!raw) return null;
+  const lower = raw.toLowerCase();
+  const idx = lower.indexOf("/engine/plugins/");
+  if (idx < 0) return null;
+  const root = raw.slice(0, idx).replace(/\/+$/, "");
+  return root ? root : null;
+}
+function isMarketplacePluginDir(baseDir) {
+  const lower = normalizePathSlashes(baseDir).toLowerCase();
+  return lower.includes("/engine/plugins/marketplace/unrealmcp") || lower.includes("/plugins/marketplace/unrealmcp");
+}
+function isUnrealMcpUnknownCommandError(err) {
+  const msg = err instanceof Error ? err.message : String(err ?? "");
+  return /\bUnknown (command|editor command|blueprint command|project command|UMG command):\b/i.test(msg);
+}
+async function readExpectedUnrealMcpUplugin() {
+  const upluginPath = join$1(unrealMcpPluginSourceDir(), "UnrealMCP.uplugin");
+  const raw = await readFile$1(upluginPath, "utf8");
+  const parsed = JSON.parse(raw);
+  const versionName = typeof parsed?.VersionName === "string" ? parsed.VersionName : null;
+  const version = typeof parsed?.Version === "number" ? parsed.Version : null;
+  return { upluginPath, versionName, version };
+}
+async function runProcess({
+  command,
+  args,
+  cwd,
+  timeoutMs,
+  env
+}) {
+  const MAX_CAPTURE_BYTES = 512 * 1024;
+  const stdoutTail = new TailBuffer(MAX_CAPTURE_BYTES);
+  const stderrTail = new TailBuffer(MAX_CAPTURE_BYTES);
+  try {
+    const { exitCode, signal, timedOut } = await new Promise((resolvePromise, rejectPromise) => {
+      const child = spawn(command, args, {
+        cwd,
+        shell: false,
+        env: env ? { ...process.env, ...env } : process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stdout?.on("data", (chunk) => stdoutTail.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+      child.stderr?.on("data", (chunk) => stderrTail.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+      let didTimeout = false;
+      const timeoutHandle = setTimeout(() => {
+        didTimeout = true;
+        try {
+          child.kill("SIGTERM");
+        } catch (error) {
+          logNonSilent(`[registerCommonHandlers] Failed to SIGTERM child process (${command})`, error, ["ESRCH"]);
+        }
+        setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch (error) {
+            logNonSilent(`[registerCommonHandlers] Failed to SIGKILL child process (${command})`, error, ["ESRCH"]);
+          }
+        }, 5e3).unref();
+      }, timeoutMs);
+      timeoutHandle.unref();
+      child.on("error", (err) => {
+        clearTimeout(timeoutHandle);
+        rejectPromise(err);
+      });
+      child.on("close", (code, sig) => {
+        clearTimeout(timeoutHandle);
+        resolvePromise({
+          exitCode: typeof code === "number" ? code : null,
+          signal: sig ?? null,
+          timedOut: didTimeout
+        });
+      });
+    });
+    const stdout = stdoutTail.toString();
+    const stderr = stderrTail.toString();
+    if (timedOut) {
+      return {
+        success: false,
+        stdout,
+        stderr,
+        exitCode: typeof exitCode === "number" ? exitCode : -1,
+        error: "Command timed out",
+        stdoutTruncated: stdoutTail.isTruncated(),
+        stderrTruncated: stderrTail.isTruncated()
+      };
+    }
+    const ok = exitCode === 0;
+    return {
+      success: ok,
+      stdout,
+      stderr,
+      exitCode: typeof exitCode === "number" ? exitCode : ok ? 0 : 1,
+      ...ok ? {} : { error: signal ? `Command failed (signal ${signal})` : "Command failed" },
+      stdoutTruncated: stdoutTail.isTruncated(),
+      stderrTruncated: stderrTail.isTruncated()
+    };
+  } catch (error) {
+    const e = error;
+    const msg = e?.code === "ENOENT" ? `Command not found: ${command}` : e?.message || "Command failed";
+    return {
+      success: false,
+      stdout: "",
+      stderr: msg,
+      exitCode: 1,
+      error: msg
+    };
+  }
+}
+async function apiJsonGet(params) {
+  const url = `${params.serverUrl.replace(/\/+$/, "")}${params.path}`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${params.token}`,
+      Accept: "application/json"
+    }
+  });
+  const data = await res.json().catch(() => null);
+  if (!res.ok) {
+    const msg = typeof data?.error === "string" ? data.error : `Request failed (${res.status})`;
+    throw new Error(msg);
+  }
+  return data;
+}
+async function apiJsonPost(params) {
+  const url = `${params.serverUrl.replace(/\/+$/, "")}${params.path}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${params.token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(params.body ?? {})
+  });
+  const data = await res.json().catch(() => null);
+  if (!res.ok) {
+    const msg = typeof data?.error === "string" ? data.error : `Request failed (${res.status})`;
+    throw new Error(msg);
+  }
+  return data;
+}
+function isGithubRemoteUrl(url) {
+  const raw = String(url || "").trim();
+  if (!raw) return false;
+  if (/^git@github\.com:/i.test(raw)) return true;
+  if (/^ssh:\/\/git@github\.com\//i.test(raw)) return true;
+  try {
+    const u = new URL(raw);
+    return u.hostname.toLowerCase() === "github.com";
+  } catch {
+    return false;
+  }
+}
+function parseGithubRepoFullName(repoUrl) {
+  const raw = String(repoUrl || "").trim();
+  if (!raw) return null;
+  if (/^git@github\.com:/i.test(raw)) {
+    const rhs = raw.replace(/^git@github\.com:/i, "");
+    const cleaned = rhs.replace(/\.git$/i, "").replace(/^\/+|\/+$/g, "");
+    const parts = cleaned.split("/").filter(Boolean);
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  }
+  if (/^ssh:\/\/git@github\.com\//i.test(raw)) {
+    const rhs = raw.replace(/^ssh:\/\/git@github\.com\//i, "");
+    const cleaned = rhs.replace(/\.git$/i, "").replace(/^\/+|\/+$/g, "");
+    const parts = cleaned.split("/").filter(Boolean);
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  }
+  try {
+    const u = new URL(raw);
+    if (u.hostname.toLowerCase() !== "github.com") return null;
+    const cleaned = u.pathname.replace(/\.git$/i, "").replace(/^\/+|\/+$/g, "");
+    const parts = cleaned.split("/").filter(Boolean);
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+  } catch {
+    return null;
+  }
+}
+async function createGithubAskpassScript() {
+  const isWin = os.platform() === "win32";
+  const suffix = isWin ? ".cmd" : ".sh";
+  const askpassPath = join$1(os.tmpdir(), `flockbay-git-askpass-${randomUUID()}${suffix}`);
+  const content = isWin ? [
+    "@echo off",
+    "set prompt=%*",
+    'echo %prompt% | findstr /i "Username" >nul && (echo x-access-token & exit /b 0)',
+    'echo %prompt% | findstr /i "Password" >nul && (echo %FLOCKBAY_GITHUB_TOKEN% & exit /b 0)',
+    "echo."
+  ].join("\r\n") : [
+    "#!/bin/sh",
+    'case "$1" in',
+    '  *Username*) echo "x-access-token" ;;',
+    '  *Password*) echo "$FLOCKBAY_GITHUB_TOKEN" ;;',
+    '  *) echo "" ;;',
+    "esac"
+  ].join("\n");
+  await writeFile$1(askpassPath, content, { encoding: "utf8" });
+  if (!isWin) await chmod(askpassPath, 448);
+  return {
+    askpassPath,
+    cleanup: async () => {
+      try {
+        await rm(askpassPath, { force: true });
+      } catch (error) {
+        logNonSilent(`[registerCommonHandlers] Failed to cleanup git-askpass (${askpassPath})`, error, ["ENOENT"]);
+      }
+    }
+  };
+}
+async function resolveBaseBranch(params) {
+  const preferredBaseBranch = String(params.preferredBaseBranch || "").trim() || null;
+  const cwd = params.cwd;
+  const refExists = async (ref) => {
+    const res = await runProcess({ command: "git", args: ["show-ref", "--verify", "--quiet", `refs/heads/${ref}`], cwd, timeoutMs: 1e4 });
+    return res.success;
+  };
+  const current = await runProcess({ command: "git", args: ["branch", "--show-current"], cwd, timeoutMs: 1e4 });
+  const currentBranch = String(current.stdout || "").trim();
+  const candidates = Array.from(new Set([preferredBaseBranch, currentBranch, "main", "master"].map((b) => String(b || "").trim()).filter(Boolean)));
+  for (const candidate of candidates) {
+    if (await refExists(candidate)) return candidate;
+  }
+  const remoteHead = await runProcess({
+    command: "git",
+    args: ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+    cwd,
+    timeoutMs: 1e4,
+    env: { GIT_TERMINAL_PROMPT: "0" }
+  });
+  const remoteRef = String(remoteHead.stdout || "").trim();
+  const remoteBranch = remoteRef.startsWith("origin/") ? remoteRef.slice("origin/".length) : "";
+  if (remoteBranch && !await refExists(remoteBranch)) {
+    await runProcess({
+      command: "git",
+      args: ["branch", "--track", remoteBranch, `origin/${remoteBranch}`],
+      cwd,
+      timeoutMs: 2e4,
+      env: { GIT_TERMINAL_PROMPT: "0" }
+    });
+  }
+  if (remoteBranch && await refExists(remoteBranch)) return remoteBranch;
+  const heads = await runProcess({ command: "git", args: ["for-each-ref", "--format=%(refname:short)", "refs/heads"], cwd, timeoutMs: 1e4 });
+  const available = String(heads.stdout || "").split("\n").map((l) => l.trim()).filter(Boolean).slice(0, 20).join(", ");
+  throw new Error(
+    `Invalid base branch '${preferredBaseBranch || "main"}' (no local branch found). Create the branch locally (or rename your default branch). Available local branches: ${available || "(none)"}`
+  );
+}
+async function appendCoordinationActivity(params) {
+  const { coordination, projectId, event } = params;
+  await apiJsonPost({
+    serverUrl: coordination.serverUrl,
+    token: coordination.token,
+    path: "/v1/coordination/activity/append",
+    body: { projectId, events: [event] }
+  });
+}
+async function runProcessToFile({
+  command,
+  args,
+  cwd,
+  timeoutMs,
+  outputPath
+}) {
+  const MAX_CAPTURE_BYTES = 512 * 1024;
+  const stderrTail = new TailBuffer(MAX_CAPTURE_BYTES);
+  try {
+    const { exitCode, signal, timedOut } = await new Promise((resolvePromise, rejectPromise) => {
+      const out = createWriteStream(outputPath, { flags: "w" });
+      const child = spawn(command, args, {
+        cwd,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      child.stdout?.pipe(out);
+      child.stderr?.on("data", (chunk) => stderrTail.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+      let didTimeout = false;
+      const timeoutHandle = setTimeout(() => {
+        didTimeout = true;
+        try {
+          child.kill("SIGTERM");
+        } catch (error) {
+          logNonSilent(`[registerCommonHandlers] Failed to SIGTERM child process (${command})`, error, ["ESRCH"]);
+        }
+        setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch (error) {
+            logNonSilent(`[registerCommonHandlers] Failed to SIGKILL child process (${command})`, error, ["ESRCH"]);
+          }
+        }, 5e3).unref();
+      }, timeoutMs);
+      timeoutHandle.unref();
+      const finish = (code, sig) => {
+        clearTimeout(timeoutHandle);
+        try {
+          out.end();
+        } catch (error) {
+          logNonSilent(`[registerCommonHandlers] Failed to close output stream (${outputPath})`, error);
+        }
+        resolvePromise({ exitCode: typeof code === "number" ? code : null, signal: sig, timedOut: didTimeout });
+      };
+      child.on("error", (err) => {
+        clearTimeout(timeoutHandle);
+        try {
+          out.end();
+        } catch (error) {
+          logNonSilent(`[registerCommonHandlers] Failed to close output stream after spawn error (${outputPath})`, error);
+        }
+        rejectPromise(err);
+      });
+      child.on("close", finish);
+    });
+    const stderr = stderrTail.toString();
+    if (timedOut) {
+      return {
+        success: false,
+        stdout: "",
+        stderr,
+        exitCode: typeof exitCode === "number" ? exitCode : -1,
+        error: "Command timed out",
+        stderrTruncated: stderrTail.isTruncated()
+      };
+    }
+    const ok = exitCode === 0;
+    return {
+      success: ok,
+      stdout: "",
+      stderr,
+      exitCode: typeof exitCode === "number" ? exitCode : ok ? 0 : 1,
+      ...ok ? {} : { error: signal ? `Command failed (signal ${signal})` : "Command failed" },
+      stderrTruncated: stderrTail.isTruncated()
+    };
+  } catch (error) {
+    const e = error;
+    const msg = e?.code === "ENOENT" ? `Command not found: ${command}` : e?.message || "Command failed";
+    return {
+      success: false,
+      stdout: "",
+      stderr: msg,
+      exitCode: 1,
+      error: msg
+    };
+  }
+}
+async function ensureGitRepo(cwd) {
+  const res = await runProcess({ command: "git", args: ["rev-parse", "--is-inside-work-tree"], cwd, timeoutMs: 1e4 });
+  if (!res.success) throw new Error(res.stderr || res.error || "not_a_git_repo");
+  const ok = (res.stdout || "").trim().toLowerCase() === "true";
+  if (!ok) throw new Error("not_a_git_repo");
+}
+function normalizeCoordinationFilePath(input) {
+  const raw = String(input || "").trim();
+  if (!raw) return null;
+  const candidate = raw.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
+  if (!candidate) return null;
+  const parts = candidate.split("/").filter(Boolean);
+  const out = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") return null;
+    out.push(part);
+  }
+  return out.join("/") || null;
+}
+function registerCommonHandlers(rpcHandlerManager, workingDirectory, coordination, options) {
+  const bashEnabled = options?.bashEnabled !== false;
+  const spawnEnv = (() => {
+    const basePath = process.env.PATH ?? "";
+    const existingEntries = basePath.split(":").filter(Boolean);
+    const preferredEntries = [];
+    if (process.platform === "darwin") {
+      preferredEntries.push("/opt/homebrew/bin", "/opt/homebrew/sbin", "/usr/local/bin", "/usr/local/sbin");
+    } else if (process.platform !== "win32") {
+      preferredEntries.push("/usr/local/bin", "/usr/local/sbin");
+    }
+    const preferredSet = new Set(preferredEntries);
+    const merged = [...preferredEntries, ...existingEntries.filter((p) => !preferredSet.has(p))];
+    return { ...process.env, PATH: merged.join(":") };
+  })();
+  rpcHandlerManager.registerHandler("bash", async (data) => {
+    if (!bashEnabled) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "bash_disabled",
+        exitCode: 1,
+        error: "bash_disabled"
+      };
+    }
+    logger.debug("Shell command request:", data.command);
+    const cwd = (() => {
+      const requested = data.cwd || workingDirectory;
+      const validation = validatePath(requested, workingDirectory);
+      if (!validation.valid) return null;
+      return validation.resolvedPath || null;
+    })();
+    if (!cwd) {
+      const validation = validatePath(data.cwd || workingDirectory, workingDirectory);
+      return { success: false, error: validation.error || "Invalid cwd" };
+    }
+    try {
+      const timeoutMs = data.timeout || 3e4;
+      const MAX_CAPTURE_BYTES = 512 * 1024;
+      const stdoutTail = new TailBuffer(MAX_CAPTURE_BYTES);
+      const stderrTail = new TailBuffer(MAX_CAPTURE_BYTES);
+      const { exitCode, signal, timedOut } = await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(data.command, {
+          cwd,
+          shell: true,
+          env: spawnEnv,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        child.stdout?.on("data", (chunk) => stdoutTail.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        child.stderr?.on("data", (chunk) => stderrTail.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        let didTimeout = false;
+        const timeoutHandle = setTimeout(() => {
+          didTimeout = true;
+          try {
+            child.kill("SIGTERM");
+          } catch (error) {
+            logNonSilent(`[registerCommonHandlers] Failed to SIGTERM child process (${data.command})`, error, ["ESRCH"]);
+          }
+          setTimeout(() => {
+            try {
+              child.kill("SIGKILL");
+            } catch (error) {
+              logNonSilent(`[registerCommonHandlers] Failed to SIGKILL child process (${data.command})`, error, ["ESRCH"]);
+            }
+          }, 5e3).unref();
+        }, timeoutMs);
+        timeoutHandle.unref();
+        child.on("error", (err) => {
+          clearTimeout(timeoutHandle);
+          rejectPromise(err);
+        });
+        child.on("close", (code, sig) => {
+          clearTimeout(timeoutHandle);
+          resolvePromise({
+            exitCode: typeof code === "number" ? code : null,
+            signal: sig ?? null,
+            timedOut: didTimeout
+          });
+        });
+      });
+      const stdout = stdoutTail.toString();
+      const stderr = stderrTail.toString();
+      if (timedOut) {
+        return {
+          success: false,
+          stdout,
+          stderr,
+          exitCode: typeof exitCode === "number" ? exitCode : -1,
+          error: "Command timed out",
+          stdoutTruncated: stdoutTail.isTruncated(),
+          stderrTruncated: stderrTail.isTruncated()
+        };
+      }
+      const ok = exitCode === 0;
+      return {
+        success: ok,
+        stdout,
+        stderr,
+        exitCode: typeof exitCode === "number" ? exitCode : ok ? 0 : 1,
+        ...ok ? {} : { error: signal ? `Command failed (signal ${signal})` : "Command failed" },
+        stdoutTruncated: stdoutTail.isTruncated(),
+        stderrTruncated: stderrTail.isTruncated()
+      };
+    } catch (error) {
+      const execError = error;
+      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(
+    "unreal-mcp-bridge-status",
+    async (params) => {
+      const checkedAtMs = Date.now();
+      const host = typeof params?.host === "string" && params.host.trim() ? params.host.trim() : "127.0.0.1";
+      const port = Number.isFinite(params?.port) ? Number(params?.port) : 55557;
+      const timeoutMs = Number.isFinite(params?.timeoutMs) ? Math.max(250, Number(params?.timeoutMs)) : 1250;
+      const requiredCommands = [
+        "ping",
+        "get_plugin_info",
+        "get_play_in_editor_status",
+        "play_in_editor",
+        "play_in_editor_windowed",
+        "stop_play_in_editor",
+        "take_screenshot",
+        "spawn_actor",
+        "set_actor_transform"
+      ];
+      const expected = await readExpectedUnrealMcpUplugin().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        return { upluginPath: join$1(unrealMcpPluginSourceDir(), "UnrealMCP.uplugin"), versionName: null, version: null, error: message };
+      });
+      const baseResponse = {
+        success: true,
+        checkedAtMs,
+        status: "error",
+        reachable: false,
+        expected: {
+          upluginPath: expected.upluginPath,
+          versionName: expected.versionName ?? null,
+          version: expected.version ?? null,
+          requiredCommands
+        }
+      };
+      try {
+        await sendUnrealMcpTcpCommand({ type: "ping", host, port, timeoutMs });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          ...baseResponse,
+          status: "not_running",
+          reachable: false,
+          error: message
+        };
+      }
+      baseResponse.reachable = true;
+      let pluginInfo = null;
+      try {
+        pluginInfo = await sendUnrealMcpTcpCommand({ type: "get_plugin_info", host, port, timeoutMs: Math.max(timeoutMs, 2e3) });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (isUnrealMcpUnknownCommandError(err)) {
+          return {
+            ...baseResponse,
+            status: "update_available",
+            error: message,
+            missingCommands: requiredCommands
+          };
+        }
+        return {
+          ...baseResponse,
+          status: "error",
+          error: message
+        };
+      }
+      const running = pluginInfo?.result && typeof pluginInfo.result === "object" ? pluginInfo.result : pluginInfo;
+      const baseDir = typeof running?.baseDir === "string" ? running.baseDir : null;
+      const versionName = typeof running?.versionName === "string" ? running.versionName : null;
+      const version = typeof running?.version === "number" ? running.version : null;
+      const commands = Array.isArray(running?.commands) ? running.commands.filter((c) => typeof c === "string").map((c) => c.trim()).filter(Boolean) : [];
+      const missingCommands = requiredCommands.filter((c) => !commands.includes(c));
+      const inferredEngineRoot = baseDir ? inferEngineRootFromPluginBaseDir(baseDir) : null;
+      let play = null;
+      if (commands.includes("get_play_in_editor_status")) {
+        try {
+          const playInfo = await sendUnrealMcpTcpCommand({ type: "get_play_in_editor_status", host, port, timeoutMs: Math.max(timeoutMs, 2e3) });
+          const playResult = playInfo?.result && typeof playInfo.result === "object" ? playInfo.result : playInfo;
+          play = {
+            isPlaying: typeof playResult?.isPlaying === "boolean" ? playResult.isPlaying : null,
+            mode: typeof playResult?.mode === "string" ? playResult.mode : null
+          };
+        } catch {
+        }
+      }
+      const conflict = baseDir ? isMarketplacePluginDir(baseDir) : false;
+      const status = missingCommands.length > 0 ? conflict ? "conflicting_install" : "update_available" : "ok";
+      return {
+        ...baseResponse,
+        status,
+        inferredEngineRoot,
+        running: {
+          baseDir,
+          versionName,
+          version,
+          commands,
+          ...play ? { play } : {}
+        },
+        missingCommands
+      };
+    }
+  );
+  rpcHandlerManager.registerHandler("delete-project-folder", async (data) => {
+    const inputPath = typeof data?.path === "string" ? data.path.trim() : "";
+    if (!inputPath) return { success: false, deleted: false, path: "", error: "Missing path" };
+    const requireUproject = data?.requireUproject !== false;
+    const projectsRootInput = typeof data?.projectsRoot === "string" ? data.projectsRoot.trim() : "";
+    if (!projectsRootInput) {
+      return {
+        success: false,
+        deleted: false,
+        path: inputPath,
+        error: "projectsRoot is required (refusing to delete without an explicit machine projects root)"
+      };
+    }
+    let resolvedPath;
+    try {
+      resolvedPath = await realpath(inputPath);
+    } catch (e) {
+      return { success: false, deleted: false, path: inputPath, error: e?.message || "Path not found" };
+    }
+    const st = await stat$1(resolvedPath).catch(() => null);
+    if (!st || !st.isDirectory()) {
+      return { success: false, deleted: false, path: inputPath, resolvedPath, error: "Path is not a directory" };
+    }
+    if (resolvedPath === "/" || resolvedPath.length < 4) {
+      return { success: false, deleted: false, path: inputPath, resolvedPath, error: "Refusing to delete unsafe path" };
+    }
+    let projectsRootResolved = null;
+    try {
+      projectsRootResolved = await realpath(projectsRootInput);
+    } catch (e) {
+      return {
+        success: false,
+        deleted: false,
+        path: inputPath,
+        resolvedPath,
+        projectsRootResolved: null,
+        error: e?.message || "projectsRoot not found"
+      };
+    }
+    if (!resolvedPath.startsWith(projectsRootResolved + "/")) {
+      return {
+        success: false,
+        deleted: false,
+        path: inputPath,
+        resolvedPath,
+        projectsRootResolved,
+        error: `Refusing to delete outside projects root: ${projectsRootResolved}`
+      };
+    }
+    if (requireUproject) {
+      const entries = await readdir(resolvedPath).catch(() => []);
+      const hasUproject = entries.some((n) => String(n || "").toLowerCase().endsWith(".uproject"));
+      if (!hasUproject) {
+        return {
+          success: false,
+          deleted: false,
+          path: inputPath,
+          resolvedPath,
+          projectsRootResolved,
+          error: "Refusing to delete: no *.uproject found in folder"
+        };
+      }
+    }
+    if (data?.dryRun) return { success: true, deleted: false, path: inputPath, resolvedPath, projectsRootResolved };
+    try {
+      await rm(resolvedPath, { recursive: true, force: false, maxRetries: 0 });
+      return { success: true, deleted: true, path: inputPath, resolvedPath, projectsRootResolved };
+    } catch (e) {
+      return { success: false, deleted: false, path: inputPath, resolvedPath, projectsRootResolved, error: e?.message || "Delete failed" };
+    }
+  });
+  rpcHandlerManager.registerHandler("git", async (data) => {
+    const action = asText(data?.action);
+    if (!action) return { success: false, error: "missing_action" };
+    const cwd = (() => {
+      const requested = asText(data.cwd || workingDirectory);
+      const validation = validatePath(requested, workingDirectory);
+      if (!validation.valid) return null;
+      return validation.resolvedPath || null;
+    })();
+    if (!cwd) {
+      const validation = validatePath(asText(data.cwd || workingDirectory), workingDirectory);
+      return { success: false, error: validation.error || "Invalid cwd" };
+    }
+    try {
+      ensureConfirmed(action, data.confirm);
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "confirmation_required" };
+    }
+    const timeoutMs = Math.max(1e3, Math.min(10 * 6e4, Number(data.timeout || 3e4) || 3e4));
+    try {
+      if (action === "init_repo") {
+        return await runProcess({
+          command: "git",
+          args: ["init"],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 3e4)
+        });
+      }
+      if (action === "status_porcelain_v2") {
+        await ensureGitRepo(cwd);
+        return await runProcess({
+          command: "git",
+          args: ["status", "--porcelain=v2", "--branch", "--untracked-files=all"],
+          cwd,
+          timeoutMs
+        });
+      }
+      if (action === "diff_numstat") {
+        await ensureGitRepo(cwd);
+        const unstaged = await runProcess({ command: "git", args: ["diff", "--numstat", "HEAD"], cwd, timeoutMs });
+        if (!unstaged.success) return unstaged;
+        const staged = await runProcess({ command: "git", args: ["diff", "--cached", "--numstat"], cwd, timeoutMs });
+        if (!staged.success) return staged;
+        return {
+          success: true,
+          stdout: `${(unstaged.stdout || "").trim()}
+---STAGED---
+${(staged.stdout || "").trim()}`.trim(),
+          stderr: [unstaged.stderr, staged.stderr].filter(Boolean).join("\n").trim(),
+          exitCode: 0,
+          stdoutTruncated: !!(unstaged.stdoutTruncated || staged.stdoutTruncated),
+          stderrTruncated: !!(unstaged.stderrTruncated || staged.stderrTruncated)
+        };
+      }
+      if (action === "list_remotes") {
+        await ensureGitRepo(cwd);
+        return await runProcess({
+          command: "git",
+          args: ["remote"],
+          cwd,
+          timeoutMs
+        });
+      }
+      if (action === "list_branches") {
+        await ensureGitRepo(cwd);
+        return await runProcess({
+          command: "git",
+          args: ["for-each-ref", "--format=%(refname:short)", "refs/heads"],
+          cwd,
+          timeoutMs
+        });
+      }
+      if (action === "log") {
+        await ensureGitRepo(cwd);
+        const format = "%H%x1f%an%x1f%ad%x1f%s%x1e";
+        return await runProcess({
+          command: "git",
+          args: ["log", "--date=relative", `--pretty=format:${format}`, "-n", "200"],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 1e4)
+        });
+      }
+      if (action === "diff_stat") {
+        await ensureGitRepo(cwd);
+        const unstaged = await runProcess({ command: "git", args: ["diff", "--stat"], cwd, timeoutMs });
+        if (!unstaged.success) return unstaged;
+        const staged = await runProcess({ command: "git", args: ["diff", "--cached", "--stat"], cwd, timeoutMs });
+        if (!staged.success) return staged;
+        return {
+          success: true,
+          stdout: `${(unstaged.stdout || "").trim()}
+---
+${(staged.stdout || "").trim()}`.trim(),
+          stderr: [unstaged.stderr, staged.stderr].filter(Boolean).join("\n").trim(),
+          exitCode: 0,
+          stdoutTruncated: !!(unstaged.stdoutTruncated || staged.stdoutTruncated),
+          stderrTruncated: !!(unstaged.stderrTruncated || staged.stderrTruncated)
+        };
+      }
+      if (action === "diff_file") {
+        await ensureGitRepo(cwd);
+        const safePaths = sanitizeRelativeGitPaths(data.paths);
+        if (safePaths.length !== 1) return { success: false, error: "diff_file_requires_one_path" };
+        const p = safePaths[0];
+        const check = validatePath(join$1(cwd, p), workingDirectory);
+        if (!check.valid) return { success: false, error: check.error || "invalid_path" };
+        const args = ["diff", "--no-ext-diff"];
+        if (data.staged) args.push("--cached");
+        args.push("--", p);
+        return await runProcess({ command: "git", args, cwd, timeoutMs: Math.max(timeoutMs, 1e4) });
+      }
+      if (action === "diff_to_file") {
+        await ensureGitRepo(cwd);
+        const safePaths = data.paths ? sanitizeRelativeGitPaths(data.paths) : [];
+        if (data.paths && safePaths.length === 0) return { success: false, error: "missing_paths" };
+        const tmpDir = join$1(workingDirectory, ".flockbay", "tmp");
+        const validation = validatePath(tmpDir, workingDirectory);
+        if (!validation.valid) return { success: false, error: validation.error || "invalid_tmp_dir" };
+        const resolvedTmp = validation.resolvedPath || tmpDir;
+        await mkdir$1(resolvedTmp, { recursive: true });
+        const outPath = join$1(resolvedTmp, `git-diff-${Date.now()}-${Math.random().toString(16).slice(2)}.patch`);
+        const outValidation = validatePath(outPath, workingDirectory);
+        if (!outValidation.valid) return { success: false, error: outValidation.error || "invalid_output_path" };
+        const resolvedOut = outValidation.resolvedPath || outPath;
+        const args = ["diff"];
+        if (data.staged) args.push("--cached");
+        if (safePaths.length > 0) args.push("--", ...safePaths);
+        const res = await runProcessToFile({
+          command: "git",
+          args,
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4),
+          outputPath: resolvedOut
+        });
+        if (!res.success) return res;
+        const info = await stat$1(resolvedOut);
+        return { success: true, exitCode: 0, stderr: res.stderr, stderrTruncated: res.stderrTruncated, artifact: { path: resolvedOut, bytes: info.size } };
+      }
+      if (action === "repo_info") {
+        await ensureGitRepo(cwd);
+        const rootRes = await runProcess({ command: "git", args: ["rev-parse", "--show-toplevel"], cwd, timeoutMs: 1e4 });
+        if (!rootRes.success) return rootRes;
+        const branchRes = await runProcess({ command: "git", args: ["branch", "--show-current"], cwd, timeoutMs: 1e4 });
+        if (!branchRes.success) return branchRes;
+        const originRes = await runProcess({ command: "git", args: ["remote", "get-url", "origin"], cwd, timeoutMs: 1e4 });
+        const root = (rootRes.stdout || "").trim();
+        const branchRaw = (branchRes.stdout || "").trim();
+        const originUrlRaw = originRes.success ? (originRes.stdout || "").trim() : "";
+        return {
+          success: true,
+          stdout: "",
+          stderr: "",
+          exitCode: 0,
+          repo: {
+            root,
+            branch: branchRaw ? branchRaw : null,
+            originUrl: originUrlRaw ? originUrlRaw : null
+          }
+        };
+      }
+      if (action === "clone") {
+        const url = asText(data.repoUrl).trim();
+        if (!url) return { success: false, error: "missing_repo_url" };
+        const destFolder = sanitizeDestFolder(asText(data.destFolder));
+        const validation = validatePath(join$1(cwd, destFolder), workingDirectory);
+        if (!validation.valid) return { success: false, error: validation.error || "invalid_dest_folder" };
+        return await runProcess({
+          command: "git",
+          args: ["clone", url, destFolder],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 5 * 6e4)
+        });
+      }
+      if (action === "stage_paths") {
+        await ensureGitRepo(cwd);
+        const safePaths = sanitizeRelativeGitPaths(data.paths);
+        for (const p of safePaths) {
+          const check = validatePath(join$1(cwd, p), workingDirectory);
+          if (!check.valid) return { success: false, error: check.error || "invalid_path" };
+        }
+        return await runProcess({
+          command: "git",
+          args: ["add", "--", ...safePaths],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4)
+        });
+      }
+      if (action === "unstage_paths") {
+        await ensureGitRepo(cwd);
+        const safePaths = sanitizeRelativeGitPaths(data.paths);
+        for (const p of safePaths) {
+          const check = validatePath(join$1(cwd, p), workingDirectory);
+          if (!check.valid) return { success: false, error: check.error || "invalid_path" };
+        }
+        return await runProcess({
+          command: "git",
+          args: ["restore", "--staged", "--", ...safePaths],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4)
+        });
+      }
+      if (action === "unstage_all") {
+        await ensureGitRepo(cwd);
+        return await runProcess({
+          command: "git",
+          args: ["restore", "--staged", "--", "."],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4)
+        });
+      }
+      if (action === "restore_file") {
+        await ensureGitRepo(cwd);
+        const safePaths = sanitizeRelativeGitPaths(data.paths);
+        if (safePaths.length !== 1) return { success: false, error: "restore_file_requires_one_path" };
+        const p = safePaths[0];
+        const check = validatePath(join$1(cwd, p), workingDirectory);
+        if (!check.valid) return { success: false, error: check.error || "invalid_path" };
+        return await runProcess({
+          command: "git",
+          args: ["restore", "--source=HEAD", "--", p],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4)
+        });
+      }
+      if (action === "discard_unstaged") {
+        await ensureGitRepo(cwd);
+        return await runProcess({
+          command: "git",
+          args: ["restore", "--worktree", "--source=HEAD", "--", "."],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 2 * 6e4)
+        });
+      }
+      if (action === "discard_all") {
+        await ensureGitRepo(cwd);
+        const reset = await runProcess({
+          command: "git",
+          args: ["reset", "--hard", "HEAD"],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 2 * 6e4)
+        });
+        if (!reset.success) return reset;
+        return await runProcess({
+          command: "git",
+          args: ["clean", "-fd"],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 2 * 6e4)
+        });
+      }
+      if (action === "commit_all") {
+        await ensureGitRepo(cwd);
+        const msg = asText(data.message).trim();
+        if (!msg) return { success: false, error: "missing_commit_message" };
+        const add = await runProcess({ command: "git", args: ["add", "-A"], cwd, timeoutMs: Math.max(timeoutMs, 6e4) });
+        if (!add.success) return add;
+        const committed = await runProcess({
+          command: "git",
+          args: ["commit", "-m", msg],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4)
+        });
+        if (!committed.success) return committed;
+        const shipped = await maybeAutoShipWorkItemAfterCommit({ coordination, cwd });
+        if (!shipped.ok) {
+          return {
+            ...committed,
+            success: false,
+            error: `auto_ship_failed: ${shipped.error}`,
+            stderr: `${committed.stderr || ""}
+AUTO_SHIP_FAILED: ${shipped.error}`.trim()
+          };
+        }
+        return committed;
+      }
+      if (action === "commit_staged") {
+        await ensureGitRepo(cwd);
+        const msg = asText(data.message).trim();
+        if (!msg) return { success: false, error: "missing_commit_message" };
+        const committed = await runProcess({
+          command: "git",
+          args: ["commit", "-m", msg],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6e4)
+        });
+        if (!committed.success) return committed;
+        const shipped = await maybeAutoShipWorkItemAfterCommit({ coordination, cwd });
+        if (!shipped.ok) {
+          return {
+            ...committed,
+            success: false,
+            error: `auto_ship_failed: ${shipped.error}`,
+            stderr: `${committed.stderr || ""}
+AUTO_SHIP_FAILED: ${shipped.error}`.trim()
+          };
+        }
+        return committed;
+      }
+      if (action === "revert_commit") {
+        await ensureGitRepo(cwd);
+        const commit = sanitizeGitCommitHash(data.commitHash);
+        const reverted = await runProcess({
+          command: "git",
+          args: ["revert", "--no-edit", commit],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 5 * 6e4)
+        });
+        if (!reverted.success) return reverted;
+        return reverted;
+      }
+      if (action === "reapply_commit") {
+        await ensureGitRepo(cwd);
+        const commit = sanitizeGitCommitHash(data.commitHash);
+        const applied = await runProcess({
+          command: "git",
+          args: ["cherry-pick", "-x", commit],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 5 * 6e4)
+        });
+        if (!applied.success) return applied;
+        return applied;
+      }
+      if (action === "push_head") {
+        await ensureGitRepo(cwd);
+        const remote = asText(data.remote || "origin").trim();
+        if (!remote) return { success: false, error: "missing_remote" };
+        return await runProcess({
+          command: "git",
+          args: ["push", "-u", remote, "HEAD"],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 5 * 6e4)
+        });
+      }
+      if (action === "pr_create") {
+        await ensureGitRepo(cwd);
+        const title = asText(data.title).trim();
+        const body = asText(data.body).trim();
+        const base = asText(data.base).trim();
+        if (!title) return { success: false, error: "missing_pr_title" };
+        const ghExists = await runProcess({ command: "gh", args: ["--version"], cwd, timeoutMs: 1e4 });
+        if (!ghExists.success) return { success: false, error: "gh_not_installed", stderr: ghExists.stderr };
+        const ghAuth = await runProcess({ command: "gh", args: ["auth", "status"], cwd, timeoutMs: 2e4 });
+        if (!ghAuth.success) return { success: false, error: "gh_not_authenticated", stderr: ghAuth.stderr || ghAuth.stdout };
+        const args = ["pr", "create", "--title", title, "--body", body];
+        if (data.draft) args.push("--draft");
+        if (base) args.push("--base", base);
+        return await runProcess({ command: "gh", args, cwd, timeoutMs: Math.max(timeoutMs, 6e4) });
+      }
+      if (action === "github_snapshot_push" || action === "github_snapshot_pr_create") {
+        await ensureGitRepo(cwd);
+        if (!coordination) return { success: false, error: "coordination_required" };
+        const projectId = String(asText(data.workspaceProjectId || coordination.workspaceProjectId)).trim();
+        if (!projectId) return { success: false, error: "missing_project_id" };
+        const repoUrl = await (async () => {
+          const explicit = asText(data.repoUrl).trim();
+          if (explicit) return explicit;
+          try {
+            const listed = await apiJsonPost({
+              serverUrl: coordination.serverUrl,
+              token: coordination.token,
+              path: "/v1/workspace/projects/list",
+              body: {}
+            });
+            const projects = Array.isArray(listed?.projects) ? listed.projects : [];
+            const match = projects.find((p) => String(p?.id || "").trim() === projectId);
+            const url = match?.repoUrl ? String(match.repoUrl || "").trim() : "";
+            return url || null;
+          } catch {
+            return null;
+          }
+        })();
+        if (!repoUrl) return { success: false, error: "missing_repo_url" };
+        if (!isGithubRemoteUrl(repoUrl)) return { success: false, error: "repo_url_not_github" };
+        const baseBranch = await resolveBaseBranch({ cwd });
+        const head = await runProcess({ command: "git", args: ["rev-parse", baseBranch], cwd, timeoutMs: 15e3 });
+        if (!head.success) return { success: false, error: head.stderr || head.error || "failed_to_read_base_head" };
+        const commitHash = String(head.stdout || "").trim();
+        if (!commitHash) return { success: false, error: "missing_commit_hash" };
+        let githubToken = null;
+        let githubScope = null;
+        let githubConnected = false;
+        try {
+          const githubRes = await apiJsonGet({
+            serverUrl: coordination.serverUrl,
+            token: coordination.token,
+            path: "/v1/connect/github/token"
+          });
+          githubToken = typeof githubRes?.token === "string" ? githubRes.token.trim() : null;
+          githubConnected = !!githubRes?.present;
+          githubScope = typeof githubRes?.scope === "string" ? githubRes.scope : null;
+        } catch (e) {
+          return { success: false, error: e instanceof Error ? e.message : "github_token_fetch_failed" };
+        }
+        if (!githubToken) return { success: false, error: githubConnected ? "github_token_unavailable" : "github_not_connected" };
+        const snapshotBranch = `flockbay/snapshot/${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15)}-${randomUUID().slice(0, 8)}`;
+        const askpass = await createGithubAskpassScript();
+        const pushEnv = {
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: askpass.askpassPath,
+          FLOCKBAY_GITHUB_TOKEN: githubToken
+        };
+        const pushRes = await runProcess({
+          command: "git",
+          args: ["push", repoUrl, `${commitHash}:refs/heads/${snapshotBranch}`],
+          cwd,
+          timeoutMs: Math.max(timeoutMs, 6 * 6e4),
+          env: pushEnv
+        });
+        await askpass.cleanup();
+        if (!pushRes.success) {
+          const detail = String(pushRes.stderr || pushRes.stdout || "").trim();
+          try {
+            await appendCoordinationActivity({
+              coordination,
+              projectId,
+              event: {
+                kind: "github_publish_failed",
+                title: "GitHub publish failed",
+                detail: detail ? detail.slice(0, 2e3) : null,
+                data: { step: "push", repoUrl, baseBranch, snapshotBranch, exitCode: pushRes.exitCode, githubScope }
+              }
+            });
+          } catch (error) {
+            logNonSilent("[registerCommonHandlers] Failed to append coordination activity (github_publish_failed: push)", error);
+          }
+          return { success: false, error: detail || "git_push_failed" };
+        }
+        try {
+          await appendCoordinationActivity({
+            coordination,
+            projectId,
+            event: {
+              kind: "github_snapshot_pushed",
+              title: "Snapshot pushed to GitHub",
+              detail: snapshotBranch,
+              data: { repoUrl, baseBranch, snapshotBranch, commitHash, githubScope }
+            }
+          });
+        } catch (error) {
+          logNonSilent("[registerCommonHandlers] Failed to append coordination activity (github_snapshot_pushed)", error);
+        }
+        if (action === "github_snapshot_push") {
+          return {
+            success: true,
+            stdout: `Pushed ${snapshotBranch}`,
+            stderr: "",
+            exitCode: 0,
+            github: { branch: snapshotBranch, baseBranch, commitHash }
+          };
+        }
+        const repoFullName = parseGithubRepoFullName(repoUrl);
+        if (!repoFullName) return { success: false, error: "invalid_github_repo_url" };
+        const prTitle = asText(data.title).trim() || `Flockbay snapshot (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)})`;
+        const prBody = (() => {
+          const explicit = asText(data.body).trim();
+          if (explicit) return explicit;
+          return [
+            "Flockbay snapshot PR (manual publish).",
+            "",
+            `Base: \`${baseBranch}\``,
+            `Commit: \`${commitHash}\``,
+            `Branch: \`${snapshotBranch}\``
+          ].join("\n");
+        })();
+        const prRes = await fetch(`https://api.github.com/repos/${repoFullName}/pulls`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${githubToken}`,
+            Accept: "application/vnd.github+json",
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            title: prTitle,
+            body: prBody,
+            head: snapshotBranch,
+            base: baseBranch,
+            draft: !!data.draft
+          })
+        });
+        const prData = await prRes.json().catch(() => null);
+        if (!prRes.ok) {
+          const msg = typeof prData?.message === "string" ? prData.message : `GitHub API error (${prRes.status})`;
+          try {
+            await appendCoordinationActivity({
+              coordination,
+              projectId,
+              event: {
+                kind: "github_publish_failed",
+                title: "GitHub publish failed",
+                detail: msg,
+                data: { step: "pr_create", repoFullName, baseBranch, snapshotBranch, status: prRes.status }
+              }
+            });
+          } catch (error) {
+            logNonSilent("[registerCommonHandlers] Failed to append coordination activity (github_publish_failed: pr_create)", error);
+          }
+          return { success: false, error: msg };
+        }
+        const prUrl = typeof prData?.html_url === "string" ? prData.html_url : "";
+        const prNumber = Number.isFinite(Number(prData?.number)) ? Number(prData.number) : void 0;
+        try {
+          await appendCoordinationActivity({
+            coordination,
+            projectId,
+            event: {
+              kind: "github_pr_created",
+              title: "PR created on GitHub",
+              detail: prUrl || `${repoFullName}#${prNumber ?? ""}`.trim(),
+              data: { repoFullName, baseBranch, snapshotBranch, prUrl: prUrl || null, prNumber: prNumber ?? null }
+            }
+          });
+        } catch (error) {
+          logNonSilent("[registerCommonHandlers] Failed to append coordination activity (github_pr_created)", error);
+        }
+        return {
+          success: true,
+          stdout: prUrl || `Created PR on ${repoFullName}`,
+          stderr: "",
+          exitCode: 0,
+          github: { repoFullName, branch: snapshotBranch, prUrl: prUrl || void 0, prNumber, baseBranch, commitHash }
+        };
+      }
+      return { success: false, error: `unknown_action:${action}` };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "git_action_failed" };
+    }
+  });
+  rpcHandlerManager.registerHandler("readFile", async (data) => {
+    logger.debug("Read file request:", data.path);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath || data.path;
+    try {
+      const buffer = await readFile$1(resolvedPath);
+      const content = buffer.toString("base64");
+      return { success: true, content };
+    } catch (error) {
+      logger.debug("Failed to read file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
+    }
+  });
+  rpcHandlerManager.registerHandler("readFileChunk", async (data) => {
+    logger.debug("Read file chunk request:", { path: data.path, offset: data.offset, maxBytes: data.maxBytes });
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error, done: true };
+    }
+    const resolvedPath = validation.resolvedPath || data.path;
+    const offset = Math.max(0, Math.floor(Number(data.offset ?? 0)));
+    const DEFAULT_MAX_BYTES = 262143;
+    const requested = Number(data.maxBytes ?? DEFAULT_MAX_BYTES);
+    const aligned = Math.floor(requested / 3) * 3;
+    const maxBytes = Math.max(3, Math.min(9e5, aligned || DEFAULT_MAX_BYTES));
+    try {
+      const st = await stat$1(resolvedPath);
+      const totalSize = st.size;
+      if (offset >= totalSize) {
+        return { success: true, content: "", offset, nextOffset: offset, totalSize, done: true };
+      }
+      const remaining = totalSize - offset;
+      const toRead = Math.min(maxBytes, remaining);
+      const handle = await open$1(resolvedPath, "r");
+      try {
+        const buffer = Buffer.allocUnsafe(toRead);
+        const { bytesRead } = await handle.read(buffer, 0, toRead, offset);
+        const slice = bytesRead === buffer.length ? buffer : buffer.subarray(0, Math.max(0, bytesRead));
+        const nextOffset = offset + slice.length;
+        const done = nextOffset >= totalSize;
+        return {
+          success: true,
+          content: slice.toString("base64"),
+          offset,
+          nextOffset,
+          totalSize,
+          done
+        };
+      } finally {
+        await handle.close();
+      }
+    } catch (error) {
+      logger.debug("Failed to read file chunk:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file chunk", done: true };
+    }
+  });
+  rpcHandlerManager.registerHandler("coordinationClaimFiles", async (data) => {
+    const projectId = String(coordination?.workspaceProjectId || "").trim();
+    const workItemId = String(coordination?.workItemId || "").trim();
+    const leaseGuard = coordination?.leaseGuard;
+    if (!coordination || !leaseGuard) return { success: true, claimedFiles: [] };
+    if (!projectId || !workItemId) return { success: false, error: "coordination_required" };
+    const rawFiles = Array.isArray(data?.files) ? data.files : [];
+    const files = rawFiles.map((f) => normalizeCoordinationFilePath(String(f || ""))).filter((v) => Boolean(v));
+    if (files.length === 0) return { success: false, error: "missing_files" };
+    try {
+      const repoRootRes = await runProcess({
+        command: "git",
+        args: ["rev-parse", "--show-toplevel"],
+        cwd: workingDirectory,
+        timeoutMs: 1e4,
+        env: { GIT_TERMINAL_PROMPT: "0" }
+      });
+      if (!repoRootRes.success) {
+        return { success: false, error: repoRootRes.stderr || repoRootRes.error || "not_a_git_repo" };
+      }
+      const repoRoot = String(repoRootRes.stdout || "").trim();
+      if (!repoRoot) return { success: false, error: "not_a_git_repo" };
+      const needsRefresh = files.filter((f) => !leaseGuard.has(f));
+      const preferredBaseBranch = null;
+      const showRefExists = async (ref) => {
+        const r = String(ref || "").trim();
+        if (!r) return false;
+        const res2 = await runProcess({
+          command: "git",
+          args: ["show-ref", "--verify", "--quiet", r],
+          cwd: repoRoot,
+          timeoutMs: 1e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+        return res2.success;
+      };
+      const remoteName = await (async () => {
+        const res2 = await runProcess({
+          command: "git",
+          args: ["remote"],
+          cwd: repoRoot,
+          timeoutMs: 1e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+        if (!res2.success) return null;
+        const remotes = String(res2.stdout || "").split("\n").map((l) => l.trim()).filter(Boolean);
+        if (remotes.includes("origin")) return "origin";
+        return remotes[0] ?? null;
+      })();
+      const branchExists = async (branch) => {
+        const b = String(branch || "").trim();
+        if (!b) return false;
+        if (await showRefExists(`refs/heads/${b}`)) return true;
+        if (remoteName && await showRefExists(`refs/remotes/${remoteName}/${b}`)) return true;
+        return false;
+      };
+      const candidates = Array.from(new Set([preferredBaseBranch, "main", "master"].map((b) => String(b || "").trim()).filter(Boolean)));
+      let baseBranch = null;
+      for (const candidate of candidates) {
+        if (await branchExists(candidate)) {
+          baseBranch = candidate;
+          break;
+        }
+      }
+      if (!baseBranch) {
+        const heads = await runProcess({ command: "git", args: ["for-each-ref", "--format=%(refname:short)", "refs/heads"], cwd: repoRoot, timeoutMs: 1e4 });
+        const available = String(heads.stdout || "").split("\n").map((l) => l.trim()).filter(Boolean).slice(0, 20).join(", ");
+        return {
+          success: false,
+          error: `Invalid base branch '${preferredBaseBranch || "main"}' (no local branch found). Set coordination settings mergeBaseBranch, or create the branch. Available local branches: ${available || "(none)"}`
+        };
+      }
+      const baseRemoteRef = remoteName ? `${remoteName}/${baseBranch}` : null;
+      const hasRemoteBaseRef = async () => {
+        if (!remoteName) return false;
+        return await showRefExists(`refs/remotes/${remoteName}/${baseBranch}`);
+      };
+      if (remoteName) {
+        const fetched = await runProcess({
+          command: "git",
+          args: ["fetch", "--prune", remoteName, baseBranch],
+          cwd: repoRoot,
+          timeoutMs: 12e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+        if (!fetched.success) {
+          return {
+            success: false,
+            error: `Cannot claim files safely because the base branch could not be refreshed.
+
+git fetch ${remoteName} ${baseBranch}
+${String(fetched.stderr || fetched.error || "").trim() || "fetch failed"}`
+          };
+        }
+      }
+      const baseRef = await hasRemoteBaseRef() && baseRemoteRef ? baseRemoteRef : baseBranch;
+      const refreshable = [];
+      for (const filePath of needsRefresh) {
+        const inBase = await runProcess({
+          command: "git",
+          args: ["cat-file", "-e", `${baseRef}:${filePath}`],
+          cwd: repoRoot,
+          timeoutMs: 1e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+        if (!inBase.success) continue;
+        const st = await runProcess({
+          command: "git",
+          args: ["status", "--porcelain=v1", "--", filePath],
+          cwd: repoRoot,
+          timeoutMs: 1e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+        if (!st.success) {
+          return { success: false, error: st.stderr || st.error || `status_failed: ${filePath}` };
+        }
+        if (String(st.stdout || "").trim()) {
+          return {
+            success: false,
+            error: `Cannot safely refresh "${filePath}" from ${baseBranch} because it has local changes.
+
+Fix: revert/commit your local changes for this path, then claim again.
+
+git status -- ${filePath}
+${String(st.stdout || "").trim()}`
+          };
+        }
+        refreshable.push(filePath);
+      }
+      const url = `${coordination.serverUrl.replace(/\/+$/, "")}/v1/coordination/work-items/claim-files`;
+      const body = {
+        projectId,
+        workItemId,
+        files,
+        mode: data?.mode ?? "active",
+        leaseMs: typeof data?.leaseMs === "number" ? data.leaseMs : void 0
+      };
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${coordination.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      const payload = await res.json().catch(() => null);
+      if (!res.ok) {
+        const msg = typeof payload?.error === "string" ? payload.error : `claim failed (${res.status})`;
+        return { success: false, error: msg };
+      }
+      if (!payload?.success) {
+        return {
+          success: false,
+          error: typeof payload?.error === "string" ? payload.error : "conflict",
+          claimedFiles: Array.isArray(payload?.claimedFiles) ? payload.claimedFiles : files,
+          conflicts: Array.isArray(payload?.conflicts) ? payload.conflicts : void 0
+        };
+      }
+      const claimedFiles = Array.isArray(payload?.claimedFiles) ? payload.claimedFiles.map((v) => normalizeCoordinationFilePath(String(v || ""))).filter((v) => Boolean(v)) : files;
+      const claimedSet = new Set(claimedFiles);
+      const toRefresh = refreshable.filter((p) => claimedSet.has(p));
+      const pre = await runProcess({
+        command: "git",
+        args: ["status", "--porcelain=v1", "--untracked-files=no"],
+        cwd: repoRoot,
+        timeoutMs: 1e4,
+        env: { GIT_TERMINAL_PROMPT: "0" }
+      });
+      if (pre.success && !String(pre.stdout || "").trim()) {
+        await runProcess({
+          command: "git",
+          args: ["merge", "--ff-only", baseRef],
+          cwd: repoRoot,
+          timeoutMs: 12e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+      }
+      if (toRefresh.length > 0) {
+        const restored = await runProcess({
+          command: "git",
+          args: ["restore", "--source", baseRef, "--worktree", "--", ...toRefresh],
+          cwd: repoRoot,
+          timeoutMs: 6e4,
+          env: { GIT_TERMINAL_PROMPT: "0" }
+        });
+        if (!restored.success) {
+          try {
+            await apiJsonPost({
+              serverUrl: coordination.serverUrl,
+              token: coordination.token,
+              path: "/v1/coordination/work-items/update",
+              body: { projectId, workItemId, leaseMs: 6e4 }
+            });
+          } catch (error) {
+            logNonSilent("[registerCommonHandlers] Failed to bump coordination lease after refresh failure", error);
+          }
+          return { success: false, error: restored.stderr || restored.error || "refresh_failed" };
+        }
+      }
+      leaseGuard.grant(claimedFiles, typeof body.leaseMs === "number" ? body.leaseMs : void 0);
+      return { success: true, claimedFiles };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : "claim_failed" };
+    }
+  });
+  rpcHandlerManager.registerHandler("writeFile", async (data) => {
+    logger.debug("Write file request:", data.path);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath || data.path;
+    const relPath = relative(workingDirectory, resolvedPath).replace(/\\/g, "/");
+    try {
+      const leaseGuard = coordination?.leaseGuard;
+      const isUserUpload = relPath === ".flockbay/user-uploads" || relPath.startsWith(".flockbay/user-uploads/");
+      if (leaseGuard && !isUserUpload && !leaseGuard.has(relPath)) {
+        return {
+          success: false,
+          error: `File write blocked (coordination claim required).
+
+Before editing a file, call \`mcp__flockbay__coordination_claim_files\` with:
+  files: ["${relPath}"]
+
+If the claim conflicts, call \`mcp__flockbay__coordination_check_files\` and wait/retry.`
+        };
+      }
+      const expectedHash = data.expectedHash;
+      if (expectedHash === void 0) {
+        try {
+          await stat$1(resolvedPath);
+          return {
+            success: false,
+            error: `Missing expectedHash for existing file.
+
+Fix: read the current file contents, compute sha256, and retry with expectedHash set.
+This prevents stale-overwrite bugs when the base branch advances.`
+          };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") throw error;
+        }
+      } else if (expectedHash === null) {
+        try {
+          await stat$1(resolvedPath);
+          return { success: false, error: "File already exists but was expected to be new" };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") throw error;
+        }
+      } else {
+        try {
+          const existingBuffer = await readFile$1(resolvedPath);
+          const existingHash = createHash("sha256").update(existingBuffer).digest("hex");
+          if (existingHash !== expectedHash) {
+            return {
+              success: false,
+              error: `File hash mismatch.
+
+Expected: ${expectedHash}
+Actual:   ${existingHash}
+
+Fix: re-read the file and retry (the file changed since you last read it).`
+            };
+          }
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") throw error;
+          return { success: false, error: "File does not exist but hash was provided" };
+        }
+      }
+      await mkdir$1(dirname(resolvedPath), { recursive: true });
+      const buffer = Buffer.from(data.content, "base64");
+      await writeFile$1(resolvedPath, buffer);
+      const hash = 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);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    const resolvedPath = validation.resolvedPath || data.path;
+    try {
+      const entries = await readdir(resolvedPath, { withFileTypes: true });
+      const directoryEntries = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = join$1(resolvedPath, entry.name);
+          let type = "other";
+          let size;
+          let modified;
+          if (entry.isDirectory()) {
+            type = "directory";
+          } else if (entry.isFile()) {
+            type = "file";
+          }
+          try {
+            const stats = await stat$1(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);
+    const validation = validatePath(data.path, workingDirectory);
+    if (!validation.valid) {
+      return { success: false, error: validation.error };
+    }
+    const rootPath = validation.resolvedPath || data.path;
+    async function buildTree(path, name, currentDepth) {
+      try {
+        const stats = await stat$1(path);
+        const node = {
+          name,
+          path,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.getTime()
+        };
+        if (stats.isDirectory() && currentDepth < data.maxDepth) {
+          const entries = await readdir(path, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                logger.debug(`Skipping symlink: ${join$1(path, entry.name)}`);
+                return;
+              }
+              const childPath = join$1(path, 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}:`, 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 = rootPath === "/" ? "/" : rootPath.split("/").pop() || rootPath;
+      const tree = await buildTree(rootPath, 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);
+    let cwd = workingDirectory;
+    if (data.cwd) {
+      const validation = validatePath(data.cwd, workingDirectory);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+      cwd = validation.resolvedPath || data.cwd;
+    }
+    try {
+      const result = await run$1(data.args, { 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);
+    if (data.cwd) {
+      const validation = validatePath(data.cwd, workingDirectory);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+    }
+    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"
+      };
+    }
+  });
+}
+
+const DEFAULT_TTL_MS = 2 * 60 * 6e4;
+function normalizeLedgerFilePath(input) {
+  const raw = String(input || "").trim();
+  if (!raw) return null;
+  let candidate = raw.replace(/\\/g, "/");
+  candidate = candidate.replace(/^\.\/+/, "").replace(/^\/+/, "");
+  if (!candidate) return null;
+  const parts = candidate.split("/").filter(Boolean);
+  const out = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") return null;
+    out.push(part);
+  }
+  return out.join("/") || null;
+}
+class CoordinationLeaseGuard {
+  expiresByFile = /* @__PURE__ */ new Map();
+  grant(files, ttlMs) {
+    const clampedTtl = Math.max(6e4, Math.min(24 * 60 * 6e4, Number(ttlMs ?? DEFAULT_TTL_MS) || DEFAULT_TTL_MS));
+    const expiresAt = Date.now() + clampedTtl;
+    const granted = [];
+    for (const f of Array.isArray(files) ? files : []) {
+      const normalized = normalizeLedgerFilePath(String(f || ""));
+      if (!normalized) continue;
+      const existing = Number(this.expiresByFile.get(normalized) || 0);
+      this.expiresByFile.set(normalized, Math.max(existing, expiresAt));
+      granted.push(normalized);
+    }
+    granted.sort((a, b) => a.localeCompare(b));
+    return { granted, expiresAt };
+  }
+  has(filePath, nowMs = Date.now()) {
+    const normalized = normalizeLedgerFilePath(filePath);
+    if (!normalized) return false;
+    const expiresAt = Number(this.expiresByFile.get(normalized) || 0);
+    if (!Number.isFinite(expiresAt) || expiresAt <= nowMs) {
+      this.expiresByFile.delete(normalized);
+      return false;
+    }
+    return true;
+  }
+  revoke(files) {
+    const revoked = [];
+    for (const f of Array.isArray(files) ? files : []) {
+      const normalized = normalizeLedgerFilePath(String(f || ""));
+      if (!normalized) continue;
+      if (this.expiresByFile.delete(normalized)) {
+        revoked.push(normalized);
+      }
+    }
+    revoked.sort((a, b) => a.localeCompare(b));
+    return { revoked };
+  }
+  clear() {
+    this.expiresByFile.clear();
+  }
+  /**
+   * Debug-only: return current granted files and expiry.
+   * This intentionally leaks coordination state for diagnosis (safe for prelaunch).
+   */
+  snapshot(nowMs = Date.now()) {
+    const out = [];
+    for (const [file, expiresAtRaw] of this.expiresByFile.entries()) {
+      const expiresAt = Number(expiresAtRaw || 0);
+      if (!Number.isFinite(expiresAt) || expiresAt <= nowMs) continue;
+      out.push({ file, expiresAt, expiresInMs: expiresAt - nowMs });
+    }
+    out.sort((a, b) => a.file.localeCompare(b.file));
+    return out;
+  }
+}
+
+class ApiSessionClient extends EventEmitter {
+  token;
+  sessionId;
+  metadata;
+  metadataVersion;
+  agentState;
+  agentStateVersion;
+  socket;
+  pendingMessages = [];
+  pendingMessageCallback = null;
+  pendingOutboundMessages = [];
+  rpcHandlerManager;
+  agentStateLock = new AsyncLock();
+  metadataLock = new AsyncLock();
+  encryptionKey;
+  coordinationLeaseGuard;
+  coordinationLedgerReadAt = 0;
+  docsIndexReadAt = 0;
+  constructor(token, session) {
+    super();
+    this.token = token;
+    this.sessionId = session.id;
+    this.metadata = session.metadata;
+    this.metadataVersion = session.metadataVersion;
+    this.agentState = session.agentState;
+    this.agentStateVersion = session.agentStateVersion;
+    this.encryptionKey = session.encryptionKey;
+    this.coordinationLeaseGuard = new CoordinationLeaseGuard();
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.sessionId,
+      encryptionKey: this.encryptionKey,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    registerCommonHandlers(this.rpcHandlerManager, this.metadata.path, {
+      serverUrl: configuration.serverUrl,
+      token: this.token,
+      sessionId: this.sessionId,
+      machineId: this.metadata.machineId || "",
+      projectRootPath: this.metadata?.projectRootPath ? String(this.metadata.projectRootPath) : this.metadata.path,
+      workItemId: this.metadata?.workItemId ? String(this.metadata.workItemId) : null,
+      workspaceProjectId: this.metadata?.workspaceProjectId ? String(this.metadata.workspaceProjectId) : null,
+      leaseGuard: this.coordinationLeaseGuard
+    }, { bashEnabled: false });
+    this.startCoordinationAutopilot();
+    this.socket = 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.flushOutboundQueue();
+    });
+    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(this.encryptionKey, decodeBase64(data.body.message.content.c));
+          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          const userResult = UserMessageSchema.safeParse(body);
+          if (userResult.success) {
+            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(this.encryptionKey, decodeBase64(data.body.metadata.value));
+            this.metadataVersion = data.body.metadata.version;
+          }
+          if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+            this.agentState = data.body.agentState.value ? decrypt(this.encryptionKey, decodeBase64(data.body.agentState.value)) : 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();
+  }
+  /**
+   * Returns the session client's bearer token for calling authenticated HTTP endpoints.
+   * Intended for internal integrations (e.g. uploading artifacts for this session).
+   */
+  getAuthToken() {
+    return this.token;
+  }
+  /**
+   * True when this session has workspaceProjectId/workItemId metadata
+   * (i.e. ledger tools are available and claim enforcement makes sense).
+   */
+  hasCoordinationContext() {
+    const meta = this.metadata;
+    if (!meta) return false;
+    const projectId = String(meta.workspaceProjectId || "").trim();
+    const workItemId = String(meta.workItemId || "").trim();
+    return Boolean(projectId && workItemId);
+  }
+  markCoordinationLedgerRead(atMs = Date.now()) {
+    this.coordinationLedgerReadAt = Number.isFinite(atMs) ? atMs : Date.now();
+  }
+  getCoordinationLedgerReadAt() {
+    return Number(this.coordinationLedgerReadAt || 0);
+  }
+  didReadCoordinationLedgerWithin(ms) {
+    const last = Number(this.coordinationLedgerReadAt || 0);
+    if (!Number.isFinite(last) || last <= 0) return false;
+    return Date.now() - last <= ms;
+  }
+  markDocsIndexRead(atMs = Date.now()) {
+    this.docsIndexReadAt = Number.isFinite(atMs) ? atMs : Date.now();
+  }
+  getDocsIndexReadAt() {
+    return Number(this.docsIndexReadAt || 0);
+  }
+  didReadDocsIndexWithin(ms) {
+    const last = Number(this.docsIndexReadAt || 0);
+    if (!Number.isFinite(last) || last <= 0) return false;
+    return Date.now() - last <= ms;
+  }
+  startCoordinationAutopilot() {
+    const meta = this.metadata;
+    if (!meta) return;
+    const projectId = String(meta.workspaceProjectId || "").trim();
+    const workItemId = String(meta.workItemId || "").trim();
+    const machineId = String(meta.machineId || "").trim();
+    const projectRootPath = String(meta.projectRootPath || meta.path || "").trim();
+    const cwd = String(meta.path || "").trim();
+    if (!projectId || !workItemId || !machineId || !projectRootPath || !cwd) return;
+    String(process.env.FLOCKBAY_COORDINATION_AUTO_SHIP_ON_COMMIT || "").trim() === "1";
+    const serverUrl = configuration.serverUrl.replace(/\/+$/, "");
+    const token = this.token;
+    const sessionId = this.sessionId;
+    const postJson = async (path, body) => {
+      const res = await fetch(`${serverUrl}${path}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body ?? {})
+      });
+      const data = await res.json().catch(() => null);
+      if (!res.ok) {
+        const msg = typeof data?.error === "string" ? data.error : `Request failed (${res.status})`;
+        throw new Error(msg);
+      }
+      return data;
+    };
+    void postJson(
+      "/v1/coordination/work-items/update",
+      { projectId, workItemId, sessionId }
+    ).catch((err) => logger.debug("[coordination-autopilot] Failed to attach session to work item:", err));
+    logger.debug("[coordination] Enabled", { projectId, workItemId, cwd });
+    return;
+  }
+  flushOutboundQueue() {
+    if (!this.socket.connected) return;
+    if (this.pendingOutboundMessages.length === 0) return;
+    const batch = this.pendingOutboundMessages;
+    this.pendingOutboundMessages = [];
+    logger.debug("[API] Flushing queued outbound messages", { count: batch.length });
+    for (const item of batch) {
+      this.socket.emit("message", { sid: item.sid, message: item.message });
+    }
+  }
+  emitMessageOrQueue(args) {
+    if (this.socket.connected) {
+      this.socket.emit("message", { sid: args.sid, message: args.message });
+      return;
+    }
+    const MAX_QUEUED = 200;
+    if (this.pendingOutboundMessages.length >= MAX_QUEUED) {
+      const head = this.pendingOutboundMessages[0];
+      throw new Error(
+        `Socket not connected; outbound queue full (${MAX_QUEUED}). Oldest=${head?.kind ?? "unknown"} queuedAt=${head?.queuedAt ?? "unknown"}`
+      );
+    }
+    this.pendingOutboundMessages.push({ ...args, queuedAt: Date.now() });
+    logger.debug("[API] Socket not connected; queued outbound message", {
+      kind: args.kind,
+      queued: this.pendingOutboundMessages.length
+    });
+  }
+  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" && typeof body.message.content === "string" && body.isSidechain !== true && body.isMeta !== true) {
+      content = {
+        role: "user",
+        content: {
+          type: "text",
+          text: body.message.content
+        },
+        meta: {
+          sentFrom: "cli"
+        }
+      };
+    } else {
+      content = {
+        role: "agent",
+        content: {
+          type: "output",
+          data: body
+          // This wraps the entire Claude message
+        },
+        meta: {
+          sentFrom: "cli"
+        }
+      };
+    }
+    logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
+    const encrypted = encodeBase64(encrypt(this.encryptionKey, content));
+    this.emitMessageOrQueue({ sid: this.sessionId, message: encrypted, kind: "claude" });
+    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) {
+    let content = {
+      role: "agent",
+      content: {
+        type: "codex",
+        data: body
+        // This wraps the entire Claude message
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    const encrypted = encodeBase64(encrypt(this.encryptionKey, content));
+    this.emitMessageOrQueue({ sid: this.sessionId, message: encrypted, kind: `codex:${String(body?.type ?? "unknown")}` });
+  }
+  /**
+   * Send a generic agent message to the session.
+   * Works for any agent type (Gemini, Codex, Claude, etc.)
+   * 
+   * @param agentType - The type of agent sending the message (e.g., 'gemini', 'codex', 'claude')
+   * @param body - The message payload
+   */
+  sendAgentMessage(agentType, body) {
+    let content = {
+      role: "agent",
+      content: {
+        type: agentType,
+        data: body
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    logger.debug(`[SOCKET] Sending ${agentType} message:`, { type: body.type, hasMessage: !!body.message });
+    const encrypted = encodeBase64(encrypt(this.encryptionKey, content));
+    this.emitMessageOrQueue({ sid: this.sessionId, message: encrypted, kind: `${agentType}:${String(body?.type ?? "unknown")}` });
+  }
+  sendSessionEvent(event, id) {
+    let content = {
+      role: "agent",
+      content: {
+        id: id ?? randomUUID$1(),
+        type: "event",
+        data: event
+      }
+    };
+    const encrypted = encodeBase64(encrypt(this.encryptionKey, content));
+    this.emitMessageOrQueue({ sid: this.sessionId, message: encrypted, kind: `event:${event.type}` });
+  }
+  /**
+   * 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(this.encryptionKey, updated)) });
+        if (answer.result === "success") {
+          this.metadata = decrypt(this.encryptionKey, decodeBase64(answer.metadata));
+          this.metadataVersion = answer.version;
+        } else if (answer.result === "version-mismatch") {
+          if (answer.version > this.metadataVersion) {
+            this.metadataVersion = answer.version;
+            this.metadata = decrypt(this.encryptionKey, decodeBase64(answer.metadata));
+          }
+          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(this.encryptionKey, updated)) : null });
+        if (answer.result === "success") {
+          this.agentState = answer.agentState ? decrypt(this.encryptionKey, decodeBase64(answer.agentState)) : 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(this.encryptionKey, decodeBase64(answer.agentState)) : 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();
+  }
+}
+
+function looksLikeEngineRoot(engineRoot) {
+  if (!engineRoot) return false;
+  return fs__default.existsSync(path.join(engineRoot, "Engine")) && fs__default.existsSync(path.join(engineRoot, "Engine", "Plugins"));
+}
+function findFilesNamedUnderDir(options) {
+  const rootDir = options.rootDir;
+  const filename = options.filename;
+  const maxDepth = Math.max(0, Math.floor(options.maxDepth));
+  const results = [];
+  const visit = (dir, depth) => {
+    if (depth > maxDepth) return;
+    let entries = [];
+    try {
+      entries = fs__default.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === ".DS_Store") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(full, depth + 1);
+        continue;
+      }
+      if (entry.isFile() && entry.name === filename) results.push(full);
+    }
+  };
+  visit(rootDir, 0);
+  return results;
+}
+function installUnrealMcpPluginToEngine(engineRootRaw) {
+  const engineRoot = (engineRootRaw || "").trim();
+  if (!looksLikeEngineRoot(engineRoot)) {
+    return {
+      ok: false,
+      errorMessage: `Invalid engine root (expected an Unreal Engine install folder containing Engine/\u2026): ${engineRoot || "(empty)"}`
+    };
+  }
+  const srcDir = unrealMcpPluginSourceDir();
+  if (!fs__default.existsSync(srcDir)) {
+    return { ok: false, errorMessage: `Missing UnrealMCP plugin source folder: ${srcDir}` };
+  }
+  const destDir = path.join(engineRoot, "Engine", "Plugins", "UnrealMCP");
+  try {
+    const enginePluginsDir = path.join(engineRoot, "Engine", "Plugins");
+    const candidates = findFilesNamedUnderDir({ rootDir: enginePluginsDir, filename: "UnrealMCP.uplugin", maxDepth: 6 });
+    const otherCopies = candidates.map((p) => path.resolve(p)).filter((p) => !p.startsWith(path.resolve(destDir) + path.sep));
+    if (otherCopies.length > 0) {
+      return {
+        ok: false,
+        errorMessage: `Found another UnrealMCP plugin install inside this engine folder.
+
+Unreal cannot load two plugins with the same name, so another copy can shadow Flockbay's plugin and cause errors like:
+- Unknown command: play_in_editor
+
+Engine: ${engineRoot}
+Conflicting plugin(s):
+` + otherCopies.map((p) => `- ${p}`).join("\n") + `
+
+Fix:
+- Close Unreal Editor
+- Delete/rename the conflicting plugin folder(s) above (common: Engine/Plugins/Marketplace/UnrealMCP)
+- Re-run the UnrealMCP install, then restart Unreal Editor so it rebuilds the plugin`
+      };
+    }
+    if (fs__default.existsSync(destDir)) {
+      fs__default.rmSync(destDir, { recursive: true, force: true });
+    }
+    fs__default.mkdirSync(destDir, { recursive: true });
+    fs__default.cpSync(srcDir, destDir, { recursive: true, force: true });
+    const destUpluginPath = path.join(destDir, "UnrealMCP.uplugin");
+    if (!fs__default.existsSync(destUpluginPath)) {
+      return {
+        ok: false,
+        errorMessage: `UnrealMCP install completed but the plugin descriptor is missing.
+Expected: ${destUpluginPath}`
+      };
+    }
+    const raw = fs__default.readFileSync(destUpluginPath, "utf8");
+    let parsed = null;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+    }
+    const friendlyName = typeof parsed?.FriendlyName === "string" ? parsed.FriendlyName : null;
+    const createdBy = typeof parsed?.CreatedBy === "string" ? parsed.CreatedBy : null;
+    if (friendlyName !== "Flockbay MCP" || createdBy !== "Respaced Inc.") {
+      return {
+        ok: false,
+        errorMessage: `UnrealMCP install verification failed: the engine plugin descriptor does not match what Flockbay ships.
+
+Path: ${destUpluginPath}
+Observed:
+- FriendlyName: ${friendlyName ?? "(missing)"}
+- CreatedBy: ${createdBy ?? "(missing)"}
+
+Expected:
+- FriendlyName: Flockbay MCP
+- CreatedBy: Respaced Inc.
+
+This usually means you're running an older Flockbay CLI build, or the engine folder wasn't updated.`
+      };
+    }
+    return { ok: true, engineRoot, destDir };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      errorMessage: `Failed to copy UnrealMCP plugin into the engine install.
+From: ${srcDir}
+To:   ${destDir}
+Error: ${message}`
+    };
+  }
+}
+
+function setEnabledByDefault(upluginPath, enabled) {
+  try {
+    const raw = fs__default.readFileSync(upluginPath, "utf8");
+    const json = JSON.parse(raw);
+    json.EnabledByDefault = enabled;
+    fs__default.writeFileSync(upluginPath, JSON.stringify(json, null, "	") + "\n", "utf8");
+    return { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+function runUatPath(engineRoot) {
+  if (process.platform === "win32") {
+    return path.join(engineRoot, "Engine", "Build", "BatchFiles", "RunUAT.bat");
+  }
+  return path.join(engineRoot, "Engine", "Build", "BatchFiles", "RunUAT.sh");
+}
+function targetPlatform() {
+  if (process.platform === "win32") return "Win64";
+  if (process.platform === "darwin") return "Mac";
+  return "Linux";
+}
+function resolvePackagedPluginDir(packageDir) {
+  const nested = path.join(packageDir, "UnrealMCP");
+  if (fs__default.existsSync(path.join(nested, "UnrealMCP.uplugin"))) return { ok: true, dir: nested };
+  if (fs__default.existsSync(path.join(packageDir, "UnrealMCP.uplugin"))) return { ok: true, dir: packageDir };
+  return {
+    ok: false,
+    error: `Build completed, but the packaged plugin output was not found.
+Expected either:
+- ${path.join(nested, "UnrealMCP.uplugin")}
+- ${path.join(packageDir, "UnrealMCP.uplugin")}`
+  };
+}
+async function buildAndInstallUnrealMcpPlugin(options) {
+  const engineRoot = options.engineRoot.trim();
+  const pluginDir = path.join(engineRoot, "Engine", "Plugins", "UnrealMCP");
+  const pluginUpluginPath = path.join(pluginDir, "UnrealMCP.uplugin");
+  if (!fs__default.existsSync(pluginUpluginPath)) {
+    return { ok: false, errorMessage: `Missing plugin file: ${pluginUpluginPath}` };
+  }
+  const uat = runUatPath(engineRoot);
+  if (!fs__default.existsSync(uat)) {
+    return { ok: false, errorMessage: `Missing Unreal build tool (RunUAT): ${uat}` };
+  }
+  const runtimeDir = path.join(options.flockbayHomeDir, "unreal-mcp");
+  fs__default.mkdirSync(runtimeDir, { recursive: true });
+  const buildLogPath = path.join(runtimeDir, `unreal_mcp_build_${Date.now()}.log`);
+  const packageDir = path.join(runtimeDir, `plugin_package_${Date.now()}`);
+  const args = [
+    "BuildPlugin",
+    `-Plugin=${pluginUpluginPath}`,
+    `-Package=${packageDir}`,
+    "-Rocket",
+    `-TargetPlatforms=${targetPlatform()}`
+  ];
+  const logStream = fs__default.createWriteStream(buildLogPath, { flags: "a" });
+  logStream.write(`engineRoot: ${engineRoot}
+`);
+  logStream.write(`uat: ${uat}
+`);
+  logStream.write(`args: ${JSON.stringify(args)}
+
+`);
+  const child = process.platform === "win32" ? spawn$1("cmd.exe", ["/c", uat, ...args], { stdio: ["ignore", "pipe", "pipe"] }) : spawn$1(uat, args, { stdio: ["ignore", "pipe", "pipe"] });
+  child.stdout?.on("data", (chunk) => logStream.write(chunk));
+  child.stderr?.on("data", (chunk) => logStream.write(chunk));
+  const exitCode = await new Promise((resolve) => child.on("close", resolve));
+  logStream.end(`
+exitCode: ${exitCode}
+`);
+  if (exitCode !== 0) {
+    return {
+      ok: false,
+      buildLogPath,
+      errorMessage: `Failed to build the Unreal bridge.
+Log: ${buildLogPath}
+Make sure your compiler tools are installed (Xcode on macOS, Visual Studio Build Tools on Windows).`
+    };
+  }
+  const resolved = resolvePackagedPluginDir(packageDir);
+  if (!resolved.ok) return { ok: false, buildLogPath, errorMessage: resolved.error };
+  const packagedPluginDir = resolved.dir;
+  try {
+    fs__default.cpSync(packagedPluginDir, pluginDir, { recursive: true, force: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      buildLogPath,
+      errorMessage: `Built the plugin, but failed to copy the compiled output into the engine install.
+From: ${packagedPluginDir}
+To:   ${pluginDir}
+Error: ${message}`
+    };
+  }
+  const binariesDir = path.join(pluginDir, "Binaries");
+  if (!fs__default.existsSync(binariesDir)) {
+    return {
+      ok: false,
+      buildLogPath,
+      errorMessage: `Build reported success, but the plugin binaries folder is missing.
+Expected: ${binariesDir}
+Log: ${buildLogPath}`
+    };
+  }
+  const setEnabled = setEnabledByDefault(pluginUpluginPath, true);
+  if (!setEnabled.ok) {
+    return {
+      ok: false,
+      buildLogPath,
+      errorMessage: `Built the plugin, but failed to enable it.
+Plugin: ${pluginUpluginPath}
+Error: ${setEnabled.error}
+Log: ${buildLogPath}`
+    };
+  }
+  return { ok: true, buildLogPath };
+}
+
+class ApiMachineClient {
+  constructor(token, machine) {
+    this.token = token;
+    this.machine = machine;
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.machine.id,
+      encryptionKey: this.machine.encryptionKey,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    const rootDir = this.machine?.metadata?.homeDir || os.homedir() || process.cwd();
+    registerCommonHandlers(this.rpcHandlerManager, rootDir, {
+      serverUrl: configuration.serverUrl,
+      token: this.token,
+      sessionId: "",
+      machineId: this.machine.id,
+      projectRootPath: rootDir
+    });
+    this.rpcHandlerManager.registerHandler(
+      "unreal-mcp-install-engine-plugin",
+      async (params) => {
+        const engineRoot = String(params?.engineRoot || "").trim();
+        const result = installUnrealMcpPluginToEngine(engineRoot);
+        if (result.ok) {
+          if (Boolean(params?.build)) {
+            const built = await buildAndInstallUnrealMcpPlugin({
+              engineRoot: result.engineRoot,
+              flockbayHomeDir: this.machine?.metadata?.flockbayHomeDir || os.homedir()
+            });
+            if (!built.ok) {
+              return { success: false, error: built.errorMessage };
+            }
+            return {
+              success: true,
+              engineRoot: result.engineRoot,
+              destDir: result.destDir,
+              buildLogPath: built.buildLogPath
+            };
+          }
+          return { success: true, engineRoot: result.engineRoot, destDir: result.destDir };
+        }
+        return { success: false, error: result.errorMessage };
+      }
+    );
+  }
+  socket;
+  keepAliveInterval = null;
+  rpcHandlerManager;
+  setRPCHandlers({
+    spawnSession,
+    stopSession,
+    requestShutdown
+  }) {
+    const spawnHandler = async (params) => {
+      const { directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, coordination } = params || {};
+      logger.debug(`[API MACHINE] Spawning session with params: ${JSON.stringify(params)}`);
+      if (!directory) {
+        throw new Error("Directory is required");
+      }
+      const result = await spawnSession({ directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, coordination });
+      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("spawn-session", spawnHandler);
+    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(this.machine.encryptionKey, updated)),
+        expectedVersion: this.machine.metadataVersion
+      });
+      if (answer.result === "success") {
+        this.machine.metadata = decrypt(this.machine.encryptionKey, decodeBase64(answer.metadata));
+        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(this.machine.encryptionKey, decodeBase64(answer.metadata));
+        }
+        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(this.machine.encryptionKey, updated)),
+        expectedVersion: this.machine.daemonStateVersion
+      });
+      if (answer.result === "success") {
+        this.machine.daemonState = decrypt(this.machine.encryptionKey, decodeBase64(answer.daemonState));
+        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(this.machine.encryptionKey, decodeBase64(answer.daemonState));
+        }
+        throw new Error("Daemon state version mismatch");
+      }
+    });
+  }
+  connect() {
+    const serverUrl = configuration.serverUrl.replace(/^http/, "ws");
+    logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
+    const machineMetadataEncrypted = encodeBase64(encrypt(this.machine.encryptionKey, this.machine.metadata));
+    const daemonStateEncrypted = this.machine.daemonState ? encodeBase64(encrypt(this.machine.encryptionKey, this.machine.daemonState)) : "";
+    const dataEncryptionKey = String(this.machine.dataEncryptionKey || "").trim();
+    if (!dataEncryptionKey) {
+      throw new Error("Missing machine dataEncryptionKey (DEK)");
+    }
+    this.socket = io(serverUrl, {
+      transports: ["websocket"],
+      auth: {
+        token: this.token,
+        clientType: "machine-scoped",
+        machineId: this.machine.id,
+        dataEncryptionKey,
+        machineMetadata: machineMetadataEncrypted,
+        daemonState: daemonStateEncrypted
+      },
+      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.socket.on("disconnect", () => {
+      logger.debug("[API MACHINE] Disconnected from server");
+      this.rpcHandlerManager.onSocketDisconnect();
+      this.stopKeepAlive();
+    });
+    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(this.machine.encryptionKey, decodeBase64(update.metadata.value));
+          this.machine.metadataVersion = update.metadata.version;
+        }
+        if (update.daemonState) {
+          logger.debug("[API MACHINE] Received external daemon state update");
+          this.machine.daemonState = decrypt(this.machine.encryptionKey, decodeBase64(update.daemonState.value));
+          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);
+    });
+  }
+  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();
+    if (this.socket) {
+      this.socket.close();
+      logger.debug("[API MACHINE] Socket closed");
+    }
+  }
+}
+
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expo;
+  constructor(token, baseUrl = "https://api-internal.flockbay.com") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+    this.expo = new 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}, 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) => Expo.isExpoPushToken(token));
+      }
+      return 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}`);
+        });
+        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`);
+          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 {
+  static async create(credential) {
+    return new ApiClient(credential);
+  }
+  credential;
+  pushClient;
+  constructor(credential) {
+    this.credential = credential;
+    this.pushClient = new PushNotificationClient(credential.token, configuration.serverUrl);
+  }
+  /**
+   * Create a new session or load existing one with the given tag
+   */
+  async getOrCreateSession(opts) {
+    const encryptionKey = getRandomBytes(32);
+    const encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
+    const dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
+    dataEncryptionKey.set([0], 0);
+    dataEncryptionKey.set(encryptedDataKey, 1);
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions`,
+        {
+          tag: opts.tag,
+          metadata: encodeBase64(encrypt(encryptionKey, opts.metadata)),
+          agentState: opts.state ? encodeBase64(encrypt(encryptionKey, opts.state)) : null,
+          dataEncryptionKey: encodeBase64(dataEncryptionKey)
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "Content-Type": "application/json"
+          },
+          timeout: 6e4
+          // 1 minute timeout for very bad network connections
+        }
+      );
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      let raw = response.data.session;
+      let session = {
+        id: raw.id,
+        seq: raw.seq,
+        metadata: decrypt(encryptionKey, decodeBase64(raw.metadata)),
+        metadataVersion: raw.metadataVersion,
+        agentState: raw.agentState ? decrypt(encryptionKey, decodeBase64(raw.agentState)) : null,
+        agentStateVersion: raw.agentStateVersion,
+        encryptionKey
+      };
+      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"}`);
+    }
+  }
+  /**
+   * Register or update machine with the server
+   * Returns the current machine state from the server with decrypted metadata and daemonState
+   */
+  async getOrCreateMachine(opts) {
+    const encryptionKey = this.credential.encryption.machineKey;
+    const encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
+    const dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
+    dataEncryptionKey.set([0], 0);
+    dataEncryptionKey.set(encryptedDataKey, 1);
+    const response = await axios.post(
+      `${configuration.serverUrl}/v1/machines`,
+      {
+        id: opts.machineId,
+        metadata: encodeBase64(encrypt(encryptionKey, opts.metadata)),
+        daemonState: opts.daemonState ? encodeBase64(encrypt(encryptionKey, opts.daemonState)) : void 0,
+        dataEncryptionKey: encodeBase64(dataEncryptionKey)
+      },
+      {
+        headers: {
+          "Authorization": `Bearer ${this.credential.token}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 6e4
+        // 1 minute timeout for very bad network connections
+      }
+    );
+    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 'flockbay doctor clean' to clean up your local 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,
+      dataEncryptionKey: String(raw.dataEncryptionKey || ""),
+      encryptionKey,
+      metadata: raw.metadata ? decrypt(encryptionKey, decodeBase64(raw.metadata)) : null,
+      metadataVersion: raw.metadataVersion || 0,
+      daemonState: raw.daemonState ? decrypt(encryptionKey, decodeBase64(raw.daemonState)) : null,
+      daemonStateVersion: raw.daemonStateVersion || 0
+    };
+    return machine;
+  }
+  /**
+   * Fetch an existing machine by id.
+   * Useful when the daemon needs the latest server-side machine metadata (e.g. dev toggles).
+   */
+  async getMachine(machineId) {
+    const id = String(machineId || "").trim();
+    if (!id) {
+      throw new Error("Machine id is required");
+    }
+    const encryptionKey = this.credential.encryption.machineKey;
+    const response = await axios.get(
+      `${configuration.serverUrl}/v1/machines/${encodeURIComponent(id)}`,
+      {
+        headers: {
+          "Authorization": `Bearer ${this.credential.token}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 6e4
+      }
+    );
+    if (response.status !== 200) {
+      throw new Error(`Failed to fetch machine: ${response.statusText}`);
+    }
+    const raw = response.data?.machine;
+    if (!raw?.id) {
+      throw new Error("Invalid machine response");
+    }
+    const machine = {
+      id: raw.id,
+      dataEncryptionKey: String(raw.dataEncryptionKey || ""),
+      encryptionKey,
+      metadata: raw.metadata ? decrypt(encryptionKey, decodeBase64(raw.metadata)) : null,
+      metadataVersion: raw.metadataVersion || 0,
+      daemonState: raw.daemonState ? decrypt(encryptionKey, decodeBase64(raw.daemonState)) : null,
+      daemonStateVersion: raw.daemonStateVersion || 0
+    };
+    return machine;
+  }
+  sessionSyncClient(session) {
+    return new ApiSessionClient(this.credential.token, session);
+  }
+  machineSyncClient(machine) {
+    return new ApiMachineClient(this.credential.token, 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.credential.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"}`);
+    }
+  }
+  /**
+   * Get vendor API token from the server
+   * Returns the token if it exists, null otherwise
+   */
+  async getVendorToken(vendor) {
+    try {
+      const response = await axios.get(
+        `${configuration.serverUrl}/v1/connect/${vendor}/token`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "Content-Type": "application/json"
+          },
+          timeout: 5e3
+        }
+      );
+      if (response.status === 404) {
+        logger.debug(`[API] No vendor token found for ${vendor}`);
+        return null;
+      }
+      if (response.status !== 200) {
+        throw new Error(`Server returned status ${response.status}`);
+      }
+      logger.debug(`[API] Raw vendor token response:`, {
+        status: response.status,
+        dataKeys: Object.keys(response.data || {}),
+        hasToken: "token" in (response.data || {}),
+        tokenType: typeof response.data?.token,
+        present: response.data?.present
+      });
+      const present = typeof response.data?.present === "boolean" ? response.data.present : null;
+      const tokenField = response.data?.token;
+      if (present === true && (tokenField === null || tokenField === void 0 || tokenField === "")) {
+        logger.debug(`[API] Vendor token for ${vendor} is present but redacted by the server (FLOCKBAY_REDACT_CONNECTED_TOKENS=1).`);
+        return null;
+      }
+      let tokenData = null;
+      if (response.data?.token) {
+        if (typeof response.data.token === "string") {
+          try {
+            tokenData = JSON.parse(response.data.token);
+          } catch (parseError) {
+            logger.debug(`[API] Failed to parse token as JSON, using as string:`, parseError);
+            tokenData = response.data.token;
+          }
+        } else if (response.data.token !== null) {
+          tokenData = response.data.token;
+        } else {
+          logger.debug(`[API] Token is null for ${vendor}, treating as not found`);
+          return null;
+        }
+      } else if (response.data && typeof response.data === "object") {
+        if (response.data.token === null && response.data.present === false) {
+          logger.debug(`[API] Response contains present=false and null token for ${vendor}, treating as not found`);
+          return null;
+        }
+        if (response.data.token === null && Object.keys(response.data).length === 1) {
+          logger.debug(`[API] Response contains only null token for ${vendor}, treating as not found`);
+          return null;
+        }
+        tokenData = response.data;
+      }
+      if (tokenData === null || tokenData && typeof tokenData === "object" && tokenData.token === null && Object.keys(tokenData).length === 1) {
+        logger.debug(`[API] Token data is null for ${vendor}`);
+        return null;
+      }
+      if (tokenData && typeof tokenData === "object" && "token" in tokenData && "present" in tokenData) {
+        logger.debug(`[API] Received token metadata object for ${vendor}; returning parsed token field only.`);
+        return tokenData.token ? tokenData.token : null;
+      }
+      logger.debug(`[API] Vendor token for ${vendor} retrieved successfully`, {
+        tokenDataType: typeof tokenData,
+        tokenDataKeys: tokenData && typeof tokenData === "object" ? Object.keys(tokenData) : "not an object"
+      });
+      return tokenData;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        logger.debug(`[API] No vendor token found for ${vendor}`);
+        return null;
+      }
+      logger.debug(`[API] [ERROR] Failed to get vendor token:`, error);
+      return null;
+    }
+  }
+}
+
+const UsageSchema = z$1.object({
+  input_tokens: z$1.number().int().nonnegative(),
+  cache_creation_input_tokens: z$1.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z$1.number().int().nonnegative().optional(),
+  output_tokens: z$1.number().int().nonnegative(),
+  service_tier: z$1.string().nullish()
+}).passthrough();
+const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
+  // User message - validates uuid and message.content
+  z$1.object({
+    type: z$1.literal("user"),
+    isSidechain: z$1.boolean().optional(),
+    isMeta: z$1.boolean().optional(),
+    uuid: z$1.string(),
+    // Used in getMessageKey()
+    message: z$1.object({
+      content: z$1.union([z$1.string(), z$1.any()])
+      // Used in sessionScanner.ts
+    }).passthrough()
+  }).passthrough(),
+  // Assistant message - only validates uuid and type
+  // message object is optional to handle synthetic error messages (isApiErrorMessage: true)
+  // which may have different structure than normal assistant messages
+  z$1.object({
+    uuid: z$1.string(),
+    type: z$1.literal("assistant"),
+    message: z$1.object({
+      usage: UsageSchema.optional()
+      // Used in apiSession.ts
+    }).passthrough().optional()
+  }).passthrough(),
+  // Summary message - validates summary and leafUuid
+  z$1.object({
+    type: z$1.literal("summary"),
+    summary: z$1.string(),
+    // Used in apiSession.ts
+    leafUuid: z$1.string()
+    // Used in getMessageKey()
+  }).passthrough(),
+  // System message - validates uuid
+  z$1.object({
+    type: z$1.literal("system"),
+    uuid: z$1.string()
+    // Used in getMessageKey()
+  }).passthrough()
+]);
+
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, packageJson as b, configuration as c, backoff as d, delay as e, AsyncLock as f, readDaemonState as g, clearDaemonState as h, readCredentials as i, encodeBase64 as j, encodeBase64Url as k, logger as l, decodeBase64 as m, unrealMcpPythonDir as n, acquireDaemonLock as o, projectPath as p, writeDaemonState as q, readSettings as r, releaseDaemonLock as s, sendUnrealMcpTcpCommand as t, updateSettings as u, clearCredentials as v, writeCredentialsDataKey as w, clearMachineId as x, installUnrealMcpPluginToEngine as y, getLatestDaemonLog as z };