@buda-ai/connector 0.1.1 → 0.1.4

package/dist/cli.js

@@ -1,19 +1,180 @@
 #!/usr/bin/env node
 
 // src/config.ts
-import { randomUUID } from "crypto";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir, hostname, platform } from "os";
+import { createHash as createHash2, randomBytes, randomUUID } from "crypto";
+import { chmod, mkdir, readFile as readFile2, rename, unlink as unlink2, writeFile } from "fs/promises";
+import { homedir, hostname, platform as platform2 } from "os";
 import path from "path";
-var CONFIG_DIR = path.join(homedir(), ".buda");
-var CONFIG_PATH = path.join(CONFIG_DIR, "device.json");
-var LOG_PATH = path.join(CONFIG_DIR, "connector.log");
+
+// src/exclusive-file-lock.ts
+import { open, readFile, stat, unlink } from "fs/promises";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_STALE_MS = 12e4;
+var DEFAULT_POLL_MS = 25;
+async function acquireExclusiveFileLock(targetPath, options = {}) {
+  const lockPath = `${targetPath}.lock`;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+  const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    let handle;
+    try {
+      handle = await open(lockPath, "wx", 384);
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+      if (await shouldRecoverLock(lockPath, staleMs)) {
+        await unlink(lockPath).catch(() => void 0);
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for exclusive access to ${targetPath}`);
+      }
+      await wait(pollMs);
+      continue;
+    }
+    await handle.writeFile(`${JSON.stringify({ pid: process.pid, createdAt: Date.now() })}
+`);
+    await handle.sync();
+    let released = false;
+    return {
+      release: async () => {
+        if (released) return;
+        released = true;
+        await handle.close();
+        await unlink(lockPath).catch(() => void 0);
+      }
+    };
+  }
+}
+async function withExclusiveFileLock(targetPath, operation, options = {}) {
+  const lock = await acquireExclusiveFileLock(targetPath, options);
+  try {
+    return await operation();
+  } finally {
+    await lock.release();
+  }
+}
+var wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+var isAlreadyExists = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+var shouldRecoverLock = async (lockPath, staleMs) => {
+  const [raw, lockStat] = await Promise.all([
+    readFile(lockPath, "utf8").catch(() => ""),
+    stat(lockPath).catch(() => null)
+  ]);
+  if (!lockStat) return false;
+  try {
+    const metadata = JSON.parse(raw);
+    if (typeof metadata.pid === "number" && Number.isInteger(metadata.pid) && metadata.pid > 0) {
+      return !isProcessAlive(metadata.pid);
+    }
+  } catch {
+  }
+  return Date.now() - lockStat.mtimeMs >= staleMs;
+};
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH");
+  }
+};
+
+// src/system-device-id.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { platform } from "os";
+var defaultDependencies = {
+  platform: platform(),
+  readFile: (filePath) => readFileSync(filePath, "utf8"),
+  execFile: (file, args) => execFileSync(file, args, { encoding: "utf8" })
+};
+var readRawSystemId = (dependencies) => {
+  if (dependencies.platform === "darwin") {
+    const output = dependencies.execFile("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
+    return output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)?.[1];
+  }
+  if (dependencies.platform === "linux") {
+    for (const filePath of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+      try {
+        const value = dependencies.readFile(filePath).trim();
+        if (value) return value;
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  if (dependencies.platform === "win32") {
+    const output = dependencies.execFile("reg", [
+      "query",
+      String.raw`HKLM\SOFTWARE\Microsoft\Cryptography`,
+      "/v",
+      "MachineGuid"
+    ]);
+    return output.match(/MachineGuid\s+REG_SZ\s+([^\r\n]+)/i)?.[1];
+  }
+  return void 0;
+};
+var hashSystemDeviceId = (rawSystemId) => {
+  const normalized = rawSystemId.trim().toLowerCase();
+  if (!normalized) return void 0;
+  const digest = createHash("sha256").update(`buda:system-device:v1:${normalized}`, "utf8").digest("hex");
+  return `dvc_${digest}`;
+};
+var resolveSystemDeviceId = (dependencies = defaultDependencies) => {
+  try {
+    const rawSystemId = readRawSystemId(dependencies);
+    return rawSystemId ? hashSystemDeviceId(rawSystemId) : void 0;
+  } catch {
+    return void 0;
+  }
+};
+
+// src/config.ts
 var DEFAULT_SERVER_URL = "https://buda.im";
-var DEFAULT_WORKDIR_ROOT = path.join(CONFIG_DIR, "agents");
 var DEFAULT_BUNNY_DAEMON_HOST = "127.0.0.1";
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var RELAY_RECONNECT_INTERVAL_MS = 3e3;
 var LAUNCH_CONFIG_STDIN_FLAG = "--launch-config-stdin";
+function normalizeServerOrigin(serverUrl) {
+  return new URL(serverUrl).origin;
+}
+function getServerOriginKey(serverUrl) {
+  const origin = normalizeServerOrigin(serverUrl);
+  const hostnameKey = new URL(origin).hostname.replace(/[^a-z0-9.-]+/gi, "-").toLowerCase();
+  const digest = createHash2("sha256").update(origin).digest("hex").slice(0, 12);
+  return `${hostnameKey}-${digest}`;
+}
+function getConnectorTokenFingerprint(token) {
+  return createHash2("sha256").update(`buda:connector-profile:v1:${token.trim()}`, "utf8").digest("hex");
+}
+function getConnectorProfileKey(serverUrl, token) {
+  const discriminator = token?.trim() ? getConnectorTokenFingerprint(token) : "legacy-no-token";
+  return `${getServerOriginKey(serverUrl)}--${discriminator}`;
+}
+function getConnectorPaths(serverUrl, configRoot = path.join(homedir(), ".buda")) {
+  const scopedLegacyDir = path.join(configRoot, "servers", getServerOriginKey(serverUrl));
+  return {
+    configDir: configRoot,
+    configPath: path.join(configRoot, "device.json"),
+    logPath: path.join(configRoot, "connector.log"),
+    workdirRoot: path.join(configRoot, "agents"),
+    scopedLegacyConfigPath: path.join(scopedLegacyDir, "device.json"),
+    scopedLegacyWorkdirRoot: path.join(scopedLegacyDir, "agents")
+  };
+}
+function getConnectorDaemonLockTarget(serverUrl, connectorId, configRoot = path.join(homedir(), ".buda")) {
+  const connectorKey = connectorId.replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
+  return path.join(
+    configRoot,
+    "daemons",
+    getServerOriginKey(serverUrl),
+    connectorKey,
+    "connector-daemon"
+  );
+}
 function getServerUrl(launchConfig) {
   return (launchConfig?.serverUrl || process.env.BUDA_CONNECTOR_SERVER_URL || process.env.BUDA_SERVER_URL || process.env.NEXT_PUBLIC_APP_URL || DEFAULT_SERVER_URL).replace(/\/$/, "");
 }
@@ -24,7 +185,7 @@ function getConnectorRelayUrl(serverUrl, connectorId) {
   return url.toString();
 }
 function getWorkdirRoot(launchConfig) {
-  return launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || DEFAULT_WORKDIR_ROOT;
+  return launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || getConnectorPaths(getServerUrl(launchConfig)).workdirRoot;
 }
 function getBunnyDaemonHost(launchConfig) {
   return launchConfig?.bunnyDaemonHost || process.env.BUDA_CONNECTOR_BUNNY_DAEMON_HOST || DEFAULT_BUNNY_DAEMON_HOST;
@@ -36,46 +197,194 @@ function getBunnyDaemonPort(launchConfig) {
   const parsed = Number(raw);
   return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
 }
-function getSpaceId(launchConfig) {
-  return launchConfig?.spaceId || process.env.BUDA_CONNECTOR_SPACE_ID;
+function getConnectorToken(launchConfig) {
+  return launchConfig?.token?.trim() || process.env.BUDA_CONNECTOR_TOKEN?.trim() || void 0;
 }
-function buildDeviceConfig(launchConfig) {
+function buildDeviceConfig(launchConfig, deviceId = `dvc_${randomUUID()}`) {
   const host = hostname();
+  const token = getConnectorToken(launchConfig);
   return {
     connectorId: `cnr_${randomUUID()}`,
-    deviceId: `dev_${randomUUID()}`,
+    deviceId,
     deviceName: host,
-    hostLabel: `${host} (${platform()})`,
+    hostLabel: `${host} (${platform2()})`,
     serverUrl: getServerUrl(launchConfig),
     workdirRoot: getWorkdirRoot(launchConfig),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    deviceToken: randomBytes(32).toString("base64url"),
+    ...token ? { token } : {}
   };
 }
-async function readDeviceConfig() {
+function isDeviceConfig(value) {
+  if (!value || typeof value !== "object") return false;
+  const config = value;
+  return typeof config.connectorId === "string" && typeof config.deviceId === "string" && typeof config.serverUrl === "string";
+}
+async function readJsonFile(configPath) {
   try {
-    const raw = await readFile(CONFIG_PATH, "utf8");
+    const raw = await readFile2(configPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
-async function writeDeviceConfig(config) {
-  await mkdir(CONFIG_DIR, { recursive: true });
-  await mkdir(config.workdirRoot, { recursive: true });
-  await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
+function migrateLegacyProfiles(values) {
+  const profiles = {};
+  for (const value of values) {
+    if (!isDeviceConfig(value)) continue;
+    try {
+      profiles[getConnectorProfileKey(value.serverUrl, value.token)] = value;
+    } catch {
+    }
+  }
+  return profiles;
 }
-async function ensureDeviceConfig(launchConfig) {
-  const existing = await readDeviceConfig();
-  if (existing) {
+async function loadDeviceConfigStore(configPath) {
+  const parsed = await readJsonFile(configPath);
+  const candidate = parsed;
+  if (candidate?.version === 3 && candidate.profiles && typeof candidate.profiles === "object") {
     return {
-      ...existing,
-      serverUrl: getServerUrl(launchConfig),
-      workdirRoot: launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || existing.workdirRoot || getWorkdirRoot(launchConfig)
+      store: {
+        version: 3,
+        ...typeof candidate.systemDeviceId === "string" ? { systemDeviceId: candidate.systemDeviceId } : {},
+        profiles: candidate.profiles
+      },
+      needsWrite: false
     };
   }
-  const config = buildDeviceConfig(launchConfig);
-  await writeDeviceConfig(config);
+  if (candidate && (candidate.version === 1 || candidate.version === 2) && candidate.servers && typeof candidate.servers === "object") {
+    return {
+      store: {
+        version: 3,
+        ...typeof candidate.systemDeviceId === "string" ? { systemDeviceId: candidate.systemDeviceId } : {},
+        profiles: migrateLegacyProfiles(Object.values(candidate.servers))
+      },
+      needsWrite: true
+    };
+  }
+  if (isDeviceConfig(parsed)) {
+    return {
+      store: {
+        version: 3,
+        profiles: migrateLegacyProfiles([parsed])
+      },
+      needsWrite: true
+    };
+  }
+  return { store: { version: 3, profiles: {} }, needsWrite: false };
+}
+function normalizeStoredWorkdirRoot(config, paths) {
+  const configuredRoot = config.workdirRoot?.trim();
+  if (!configuredRoot) {
+    return { config: { ...config, workdirRoot: paths.workdirRoot }, changed: true };
+  }
+  const relativeToLegacyServers = path.relative(
+    path.join(paths.configDir, "servers"),
+    path.resolve(configuredRoot)
+  );
+  const segments = relativeToLegacyServers.split(path.sep);
+  const isServerScopedDefault = !path.isAbsolute(relativeToLegacyServers) && segments.length === 2 && segments[0] !== ".." && segments[1] === "agents";
+  if (!isServerScopedDefault) return { config, changed: false };
+  return { config: { ...config, workdirRoot: paths.workdirRoot }, changed: true };
+}
+async function writeDeviceConfigStore(configPath, store) {
+  await mkdir(path.dirname(configPath), { recursive: true });
+  const temporaryPath = `${configPath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(store, null, 2)}
+`, { mode: 384 });
+    await rename(temporaryPath, configPath);
+    await chmod(configPath, 384);
+  } finally {
+    await unlink2(temporaryPath).catch(() => void 0);
+  }
+}
+async function readDeviceConfig(launchConfig, configRoot) {
+  const serverUrl = getServerUrl(launchConfig);
+  const paths = getConnectorPaths(serverUrl, configRoot);
+  const launchToken = getConnectorToken(launchConfig);
+  await mkdir(paths.configDir, { recursive: true });
+  return withExclusiveFileLock(paths.configPath, async () => {
+    const { store, needsWrite } = await loadDeviceConfigStore(paths.configPath);
+    const profileKey = getConnectorProfileKey(serverUrl, launchToken);
+    const storedConfig = store.profiles[profileKey];
+    let config = isDeviceConfig(storedConfig) ? storedConfig : null;
+    let normalizedWorkdirRoot = false;
+    if (config) {
+      const normalized = normalizeStoredWorkdirRoot(config, paths);
+      config = normalized.config;
+      normalizedWorkdirRoot = normalized.changed;
+      store.profiles[getConnectorProfileKey(config.serverUrl, config.token)] = config;
+    }
+    if (needsWrite || normalizedWorkdirRoot) {
+      await writeDeviceConfigStore(paths.configPath, store);
+    }
+    return config;
+  });
+}
+async function writeDeviceConfig(config, configRoot) {
+  const paths = getConnectorPaths(config.serverUrl, configRoot);
+  await mkdir(config.workdirRoot, { recursive: true });
+  await mkdir(paths.configDir, { recursive: true });
+  await withExclusiveFileLock(paths.configPath, async () => {
+    const { store } = await loadDeviceConfigStore(paths.configPath);
+    store.profiles[getConnectorProfileKey(config.serverUrl, config.token)] = config;
+    await writeDeviceConfigStore(paths.configPath, store);
+  });
+}
+async function getOrCreateSystemDeviceId(configRoot, resolver = resolveSystemDeviceId) {
+  const paths = getConnectorPaths(DEFAULT_SERVER_URL, configRoot);
+  await mkdir(paths.configDir, { recursive: true });
+  return withExclusiveFileLock(paths.configPath, async () => {
+    const { store, needsWrite } = await loadDeviceConfigStore(paths.configPath);
+    if (store.systemDeviceId) {
+      if (needsWrite) await writeDeviceConfigStore(paths.configPath, store);
+      return store.systemDeviceId;
+    }
+    const existingDeviceId = Object.values(store.profiles).find(isDeviceConfig)?.deviceId;
+    store.systemDeviceId = resolver() || existingDeviceId || `dvc_${randomUUID()}`;
+    await writeDeviceConfigStore(paths.configPath, store);
+    return store.systemDeviceId;
+  });
+}
+async function createDeviceConfig(launchConfig, configRoot, resolver) {
+  const deviceId = await getOrCreateSystemDeviceId(configRoot, resolver);
+  return buildDeviceConfig(launchConfig, deviceId);
+}
+async function ensureDeviceConfig(launchConfig, configRoot, resolver = resolveSystemDeviceId) {
+  const serverUrl = getServerUrl(launchConfig);
+  const paths = getConnectorPaths(serverUrl, configRoot);
+  const token = getConnectorToken(launchConfig);
+  const profileKey = getConnectorProfileKey(serverUrl, token);
+  await mkdir(paths.configDir, { recursive: true });
+  const config = await withExclusiveFileLock(paths.configPath, async () => {
+    const { store, needsWrite } = await loadDeviceConfigStore(paths.configPath);
+    const storedConfig = store.profiles[profileKey];
+    if (isDeviceConfig(storedConfig)) {
+      const normalized = normalizeStoredWorkdirRoot(storedConfig, paths);
+      if (needsWrite || normalized.changed) {
+        store.profiles[profileKey] = normalized.config;
+        await writeDeviceConfigStore(paths.configPath, store);
+      }
+      const existing = normalized.config;
+      const overrideToken = getConnectorToken(launchConfig);
+      return {
+        ...existing,
+        serverUrl,
+        workdirRoot: launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || existing.workdirRoot || getWorkdirRoot(launchConfig),
+        ...overrideToken ? { token: overrideToken } : {}
+      };
+    }
+    if (!store.systemDeviceId) {
+      const existingDeviceId = Object.values(store.profiles).find(isDeviceConfig)?.deviceId;
+      store.systemDeviceId = resolver() || existingDeviceId || `dvc_${randomUUID()}`;
+    }
+    const created = buildDeviceConfig(launchConfig, store.systemDeviceId);
+    store.profiles[profileKey] = created;
+    await writeDeviceConfigStore(paths.configPath, store);
+    return created;
+  });
+  await mkdir(config.workdirRoot, { recursive: true });
   return config;
 }
 function parseLaunchConfig(raw) {
@@ -86,12 +395,15 @@ function parseLaunchConfig(raw) {
     serverUrl: typeof parsed.serverUrl === "string" ? parsed.serverUrl : void 0,
     workdirRoot: typeof parsed.workdirRoot === "string" ? parsed.workdirRoot : void 0,
     oauthToken: typeof parsed.oauthToken === "string" ? parsed.oauthToken : void 0,
-    spaceId: typeof parsed.spaceId === "string" ? parsed.spaceId : void 0,
+    token: typeof parsed.token === "string" ? parsed.token : void 0,
     bunnyDaemonHost: typeof parsed.bunnyDaemonHost === "string" ? parsed.bunnyDaemonHost : void 0,
     bunnyDaemonPort
   };
 }
 
+// src/onboard.ts
+import { cancel, intro, isCancel, log, note, outro, spinner, text } from "@clack/prompts";
+
 // src/bunny-daemon.ts
 import { mkdir as mkdir3 } from "fs/promises";
 import { createDaemon } from "@bunny-agent/daemon";
@@ -108,8 +420,9 @@ async function writeLog(level, message, metadata) {
   };
   pendingLogs.push(entry);
   if (pendingLogs.length > 100) pendingLogs.splice(0, pendingLogs.length - 100);
-  await mkdir2(CONFIG_DIR, { recursive: true }).catch(() => void 0);
-  await appendFile(LOG_PATH, `${JSON.stringify(entry)}
+  const paths = getConnectorPaths(getServerUrl());
+  await mkdir2(paths.configDir, { recursive: true }).catch(() => void 0);
+  await appendFile(paths.logPath, `${JSON.stringify(entry)}
 `).catch(() => void 0);
   const line = `[buda-connector] ${message}`;
   if (level === "error") console.error(line);
@@ -165,14 +478,627 @@ async function stopEmbeddedBunnyDaemon(daemon) {
 }
 
 // src/cloud-client.ts
-import { platform as platform2, release } from "os";
-function buildPayload(config, extra) {
+import { createHash as createHash4 } from "crypto";
+import { platform as platform3, release } from "os";
+
+// src/browser.ts
+import { accessSync, constants, statSync } from "fs";
+import { mkdir as mkdir4 } from "fs/promises";
+import { platform as getPlatform, homedir as homedir2 } from "os";
+import path2 from "path";
+var DEFAULT_VIEWPORT = { width: 1280, height: 800 };
+var MAX_SCREENCAST_DIMENSION = 2560;
+var SESSION_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,320}$/;
+var sessions = /* @__PURE__ */ new Map();
+var sessionPromises = /* @__PURE__ */ new Map();
+var getBrowserMode = () => {
+  const configured = process.env.BUDA_CONNECTOR_BROWSER_MODE?.trim().toLowerCase();
+  return configured === "auto" || configured === "headed" || configured === "headless" ? configured : "headless";
+};
+var getSystemBrowserCandidates = (platform4, homeDirectory, env) => {
+  if (platform4 === "darwin") {
+    return [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+      `${homeDirectory}/Applications/Google Chrome.app/Contents/MacOS/Google Chrome`,
+      `${homeDirectory}/Applications/Chromium.app/Contents/MacOS/Chromium`,
+      `${homeDirectory}/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge`
+    ];
+  }
+  if (platform4 === "win32") {
+    const localAppData = env.LOCALAPPDATA;
+    const programFiles = env.PROGRAMFILES;
+    const programFilesX86 = env["PROGRAMFILES(X86)"];
+    return [
+      localAppData ? `${localAppData}\\Google\\Chrome\\Application\\chrome.exe` : "",
+      localAppData ? `${localAppData}\\Chromium\\Application\\chrome.exe` : "",
+      programFiles ? `${programFiles}\\Google\\Chrome\\Application\\chrome.exe` : "",
+      programFilesX86 ? `${programFilesX86}\\Google\\Chrome\\Application\\chrome.exe` : "",
+      programFiles ? `${programFiles}\\Microsoft\\Edge\\Application\\msedge.exe` : "",
+      programFilesX86 ? `${programFilesX86}\\Microsoft\\Edge\\Application\\msedge.exe` : ""
+    ];
+  }
+  return [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+    "/usr/bin/microsoft-edge",
+    "/usr/bin/microsoft-edge-stable"
+  ];
+};
+var resolveBrowserAvailability = (options = {}) => {
+  const env = options.env ?? process.env;
+  const platform4 = options.platform ?? getPlatform();
+  const homeDirectory = options.homeDirectory ?? homedir2();
+  const pathIsExecutable = options.pathIsExecutable ?? ((candidate) => {
+    try {
+      if (!statSync(candidate).isFile()) return false;
+      accessSync(candidate, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const configuredPath = env.BUDA_CONNECTOR_BROWSER_PATH?.trim();
+  if (configuredPath) {
+    if (pathIsExecutable(configuredPath)) {
+      return { available: true, executablePath: configuredPath };
+    }
+    return {
+      available: false,
+      error: `BUDA_CONNECTOR_BROWSER_PATH is missing or not executable: ${configuredPath}. Set it to a Chrome, Chromium, or Edge executable.`
+    };
+  }
+  const executablePath = getSystemBrowserCandidates(platform4, homeDirectory, env).find(
+    (candidate) => candidate && pathIsExecutable(candidate)
+  );
+  if (executablePath) {
+    return { available: true, executablePath };
+  }
+  return {
+    available: false,
+    error: "No supported system browser was found. Install Google Chrome, Chromium, or Microsoft Edge, or set BUDA_CONNECTOR_BROWSER_PATH to its executable. The connector browser capability will not be advertised."
+  };
+};
+async function launchPlaywright(viewport = DEFAULT_VIEWPORT) {
+  const availability = resolveBrowserAvailability();
+  if (!availability.available) throw new Error(availability.error);
+  const { chromium } = await import("playwright-core");
+  const mode = getBrowserMode();
+  const executablePath = availability.executablePath;
+  let browser = null;
+  if (mode !== "headless") {
+    try {
+      await writeLog("info", `launching headed system browser ${executablePath}`);
+      browser = await chromium.launch({
+        executablePath,
+        headless: false,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"]
+      });
+    } catch (error) {
+      if (mode === "headed") throw error;
+      await writeLog(
+        "warn",
+        `headed browser launch failed, falling back to headless: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!browser) {
+    await writeLog("info", `launching headless system browser ${executablePath}`);
+    browser = await chromium.launch({
+      executablePath,
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-gpu"]
+    });
+  }
+  const context = await browser.newContext({ viewport, deviceScaleFactor: 1 });
+  const page = await context.newPage();
+  const cdpSession = await context.newCDPSession(page);
+  return { browser, page, cdpSession };
+}
+var normalizeSessionId = (value) => {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return SESSION_ID_PATTERN.test(normalized) ? normalized : null;
+};
+async function ensureSession(sessionId, initialViewport = DEFAULT_VIEWPORT) {
+  const activeSession = sessions.get(sessionId);
+  if (activeSession) return activeSession;
+  let sessionPromise = sessionPromises.get(sessionId);
+  if (!sessionPromise) {
+    sessionPromise = (async () => {
+      await writeLog("info", `launching local browser session ${sessionId}`);
+      const { browser, page, cdpSession } = await launchPlaywright(initialViewport);
+      const nextSession = {
+        page,
+        browser,
+        cdpSession,
+        screencastClients: /* @__PURE__ */ new Set(),
+        isScreencasting: false,
+        screencastListenerAttached: false,
+        resizeQueue: Promise.resolve(),
+        inputQueue: Promise.resolve(),
+        navigationQueue: Promise.resolve(),
+        clientIds: /* @__PURE__ */ new Set()
+      };
+      sessions.set(sessionId, nextSession);
+      browser.on("disconnected", () => {
+        if (sessions.get(sessionId) === nextSession) sessions.delete(sessionId);
+      });
+      return nextSession;
+    })();
+    sessionPromises.set(sessionId, sessionPromise);
+  }
+  try {
+    return await sessionPromise;
+  } finally {
+    if (sessionPromises.get(sessionId) === sessionPromise) sessionPromises.delete(sessionId);
+  }
+}
+async function startScreencast(s) {
+  if (s.isScreencasting) return;
+  if (!s.screencastListenerAttached) {
+    s.screencastListenerAttached = true;
+    s.cdpSession.on("Page.screencastFrame", (params) => {
+      const metadata = params.metadata;
+      const viewport = s.page.viewportSize() ?? DEFAULT_VIEWPORT;
+      const frame = {
+        data: params.data,
+        viewportWidth: metadata.deviceWidth ?? viewport.width,
+        viewportHeight: metadata.deviceHeight ?? viewport.height
+      };
+      for (const listener of s.screencastClients) listener(frame);
+      void s.cdpSession.send("Page.screencastFrameAck", { sessionId: params.sessionId }).catch(() => {
+      });
+    });
+  }
+  await s.cdpSession.send("Page.startScreencast", {
+    format: "jpeg",
+    quality: 90,
+    maxWidth: MAX_SCREENCAST_DIMENSION,
+    maxHeight: MAX_SCREENCAST_DIMENSION,
+    everyNthFrame: 2
+  });
+  s.isScreencasting = true;
+}
+async function stopScreencast(s) {
+  if (!s.isScreencasting) return;
+  await s.cdpSession.send("Page.stopScreencast").catch(() => {
+  });
+  s.isScreencasting = false;
+}
+async function closeSession(sessionId) {
+  const activeSession = sessions.get(sessionId) ?? await sessionPromises.get(sessionId)?.catch(() => null);
+  if (!activeSession) return;
+  if (sessions.get(sessionId) === activeSession) sessions.delete(sessionId);
+  await stopScreencast(activeSession);
+  await activeSession.cdpSession.detach().catch(() => {
+  });
+  await activeSession.browser.close().catch(() => {
+  });
+  await writeLog("info", `browser session stopped ${sessionId}`);
+}
+async function closeAllBrowserSessions() {
+  const sessionIds = /* @__PURE__ */ new Set([...sessions.keys(), ...sessionPromises.keys()]);
+  await Promise.all([...sessionIds].map((sessionId) => closeSession(sessionId)));
+}
+async function resizeBrowser(s, viewport) {
+  const resize = s.resizeQueue.catch(() => {
+  }).then(async () => {
+    const current = s.page.viewportSize();
+    if (current?.width === viewport.width && current.height === viewport.height) return;
+    const wasScreencasting = s.isScreencasting;
+    if (wasScreencasting) await stopScreencast(s);
+    await s.page.setViewportSize(viewport);
+    if (wasScreencasting) await startScreencast(s);
+    await writeLog("info", `browser resized to ${viewport.width}x${viewport.height}`);
+  });
+  s.resizeQueue = resize;
+  await resize;
+}
+async function navigateBrowser(s, url, options) {
+  const navigation = s.navigationQueue.catch(() => {
+  }).then(async () => {
+    if (s.page.url() === url) return null;
+    return s.page.goto(url, options);
+  });
+  s.navigationQueue = navigation.then(() => {
+  });
+  return navigation;
+}
+var normalizeViewportDimension = (value, min, max, fallback) => {
+  const dimension = typeof value === "number" && Number.isFinite(value) ? Math.round(value) : fallback;
+  return Math.min(max, Math.max(min, dimension));
+};
+var normalizeTimeout = (value, fallback, max) => typeof value === "number" && Number.isFinite(value) ? Math.min(max, Math.max(1e3, Math.round(value))) : fallback;
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+var getRequestSessionId = (context) => normalizeSessionId(context.sessionId);
+async function handleBrowserInput(sessionIdValue, body) {
+  const sessionId = normalizeSessionId(sessionIdValue);
+  if (!sessionId) throw new Error("A valid browser session id is required.");
+  const ev = body ?? {};
+  const s = await ensureSession(sessionId);
+  const input = s.inputQueue.catch(() => {
+  }).then(async () => {
+    switch (ev.type) {
+      case "mouseMove":
+        await s.cdpSession.send("Input.dispatchMouseEvent", {
+          type: "mouseMoved",
+          x: ev.x,
+          y: ev.y
+        });
+        return;
+      case "mouseDown":
+        await s.cdpSession.send("Input.dispatchMouseEvent", {
+          type: "mousePressed",
+          x: ev.x,
+          y: ev.y,
+          button: "left",
+          clickCount: 1
+        });
+        return;
+      case "mouseUp":
+        await s.cdpSession.send("Input.dispatchMouseEvent", {
+          type: "mouseReleased",
+          x: ev.x,
+          y: ev.y,
+          button: "left",
+          clickCount: 1
+        });
+        return;
+      case "keyDown":
+        await s.cdpSession.send("Input.dispatchKeyEvent", {
+          type: "keyDown",
+          key: ev.key,
+          text: ev.text ?? ""
+        });
+        return;
+      case "keyUp":
+        await s.cdpSession.send("Input.dispatchKeyEvent", {
+          type: "keyUp",
+          key: ev.key
+        });
+        return;
+      case "scroll":
+        await s.cdpSession.send("Input.dispatchMouseEvent", {
+          type: "mouseWheel",
+          x: ev.x,
+          y: ev.y,
+          deltaX: 0,
+          deltaY: ev.deltaY
+        });
+        return;
+      default:
+        throw new Error(`Unknown browser input event: ${String(ev.type)}`);
+    }
+  });
+  s.inputQueue = input;
+  await input;
+}
+var getPageResult = async (s) => ({
+  url: s.page.url(),
+  title: await s.page.title().catch(() => "")
+});
+var resolveScreenshotPath = (workdirRoot, filePath) => {
+  if (!workdirRoot) throw new Error("Connector workdir is unavailable for screenshots.");
+  const raw = typeof filePath === "string" ? filePath.trim() : "";
+  if (!raw) throw new Error("file_path is required");
+  const agentRoot = path2.resolve(workdirRoot, "agent");
+  const relativeInput = raw === "/agent" ? "" : raw.startsWith("/agent/") ? raw.slice(7) : raw;
+  const absolutePath = path2.resolve(agentRoot, relativeInput);
+  if (absolutePath === agentRoot || !absolutePath.startsWith(`${agentRoot}${path2.sep}`)) {
+    throw new Error("file_path must stay under the connector agent drive");
+  }
+  return {
+    absolutePath,
+    relativePath: path2.relative(agentRoot, absolutePath).split(path2.sep).join("/")
+  };
+};
+async function handleBrowserRequest(requestPath, method, body, context = {}) {
+  const route = new URL(requestPath, "http://connector.local").pathname.replace(
+    /^\/browser\/?/,
+    ""
+  );
+  const sessionId = getRequestSessionId(context);
+  if (!sessionId)
+    return jsonResponse(400, { ok: false, error: "valid browser session id required" });
+  if (route === "start" && method === "POST") {
+    const input = body ?? {};
+    const viewport = {
+      width: normalizeViewportDimension(input.width, 320, 2560, DEFAULT_VIEWPORT.width),
+      height: normalizeViewportDimension(input.height, 240, 2560, DEFAULT_VIEWPORT.height)
+    };
+    const s = await ensureSession(sessionId, viewport);
+    const clientId = normalizeSessionId(input.clientId);
+    if (clientId) s.clientIds.add(clientId);
+    await resizeBrowser(s, viewport);
+    const url = input.url?.trim() || "about:blank";
+    await writeLog("info", `browser viewport ${viewport.width}x${viewport.height}`);
+    await navigateBrowser(s, url);
+    await writeLog("info", `browser ready at ${s.page.url()}`);
+    return jsonResponse(200, { ok: true, ...await getPageResult(s) });
+  }
+  if (route === "stop" && method === "POST") {
+    await closeSession(sessionId);
+    return jsonResponse(200, { ok: true });
+  }
+  if (route === "release" && method === "POST") {
+    const input = body ?? {};
+    const clientId = normalizeSessionId(input.clientId);
+    if (!clientId) return jsonResponse(400, { ok: false, error: "valid client id required" });
+    const s = sessions.get(sessionId);
+    if (!s) return jsonResponse(200, { ok: true, closed: false });
+    s.clientIds.delete(clientId);
+    if (s.clientIds.size > 0) return jsonResponse(200, { ok: true, closed: false });
+    await closeSession(sessionId);
+    return jsonResponse(200, { ok: true, closed: true });
+  }
+  if (route === "navigate" && method === "POST") {
+    const input = body ?? {};
+    const url = input.url?.trim();
+    if (!url) return jsonResponse(400, { ok: false, error: "url required" });
+    const s = await ensureSession(sessionId);
+    const response = await navigateBrowser(s, url, {
+      waitUntil: input.waitUntil ?? "domcontentloaded",
+      timeout: normalizeTimeout(input.timeoutMs, 3e4, 6e4)
+    });
+    return jsonResponse(200, {
+      ok: true,
+      action: "navigate",
+      ...await getPageResult(s),
+      status: response?.status() ?? null
+    });
+  }
+  if (route === "click" && method === "POST") {
+    const input = body ?? {};
+    const selector = input.selector?.trim();
+    if (!selector) return jsonResponse(400, { ok: false, error: "selector required" });
+    const s = await ensureSession(sessionId);
+    const button = input.button === "right" || input.button === "middle" ? input.button : "left";
+    await s.page.locator(selector).click({
+      button,
+      timeout: normalizeTimeout(input.timeoutMs, 1e4, 3e4)
+    });
+    await s.page.waitForLoadState("domcontentloaded", { timeout: 5e3 }).catch(() => {
+    });
+    return jsonResponse(200, {
+      ok: true,
+      action: "click",
+      ...await getPageResult(s),
+      message: `Clicked ${selector}`
+    });
+  }
+  if (route === "type" && method === "POST") {
+    const input = body ?? {};
+    const selector = input.selector?.trim();
+    if (!selector) return jsonResponse(400, { ok: false, error: "selector required" });
+    const s = await ensureSession(sessionId);
+    const locator = s.page.locator(selector);
+    const text2 = typeof input.text === "string" ? input.text : String(input.text ?? "");
+    const timeout = normalizeTimeout(input.timeoutMs, 1e4, 3e4);
+    if (input.clear !== false) {
+      await locator.fill("", { timeout });
+      await locator.fill(text2, { timeout });
+    } else {
+      await locator.type(text2, { timeout });
+    }
+    return jsonResponse(200, {
+      ok: true,
+      action: "type",
+      ...await getPageResult(s),
+      message: `Typed into ${selector}`
+    });
+  }
+  if (route === "extract" && method === "POST") {
+    const input = body ?? {};
+    const selector = input.selector?.trim() || "body";
+    const s = await ensureSession(sessionId);
+    const locator = s.page.locator(selector).first();
+    const text2 = (await locator.innerText({ timeout: 1e4 }).catch(async () => s.page.locator("body").innerText({ timeout: 1e4 }))).trim();
+    const maxChars = typeof input.maxChars === "number" && Number.isFinite(input.maxChars) ? Math.min(2e4, Math.max(500, Math.round(input.maxChars))) : 8e3;
+    return jsonResponse(200, {
+      ok: true,
+      action: "extract",
+      ...await getPageResult(s),
+      text: text2.slice(0, maxChars)
+    });
+  }
+  if (route === "screenshot" && method === "POST") {
+    const input = body ?? {};
+    const s = await ensureSession(sessionId);
+    const screenshotPath = resolveScreenshotPath(context.workdirRoot, input.file_path);
+    await mkdir4(path2.dirname(screenshotPath.absolutePath), { recursive: true });
+    await s.page.screenshot({
+      path: screenshotPath.absolutePath,
+      fullPage: input.fullPage !== false
+    });
+    return jsonResponse(200, {
+      ok: true,
+      action: "screenshot",
+      ...await getPageResult(s),
+      filePath: screenshotPath.relativePath,
+      message: "Screenshot saved"
+    });
+  }
+  if (route === "resize" && method === "POST") {
+    const input = body ?? {};
+    const viewport = {
+      width: normalizeViewportDimension(input.width, 320, 2560, DEFAULT_VIEWPORT.width),
+      height: normalizeViewportDimension(input.height, 240, 2560, DEFAULT_VIEWPORT.height)
+    };
+    const s = await ensureSession(sessionId);
+    await resizeBrowser(s, viewport);
+    return jsonResponse(200, { ok: true, ...viewport });
+  }
+  if (route === "input" && method === "POST") {
+    await handleBrowserInput(sessionId, body);
+    return jsonResponse(200, { ok: true });
+  }
+  if (route === "location" && method === "GET") {
+    const s = sessions.get(sessionId);
+    if (!s) return jsonResponse(200, { ok: true, url: "", title: "" });
+    return jsonResponse(200, { ok: true, ...await getPageResult(s) });
+  }
+  if (route === "screencast" && method === "GET") {
+    const s = await ensureSession(sessionId);
+    let cleanup = () => {
+    };
+    const stream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+        const listener = (frame) => {
+          const line = `data:${JSON.stringify({
+            type: "frame",
+            ...frame,
+            mimeType: "image/jpeg"
+          })}
+
+`;
+          controller.enqueue(encoder.encode(line));
+        };
+        s.screencastClients.add(listener);
+        void startScreencast(s).catch((error) => controller.error(error));
+        let checkInterval = null;
+        cleanup = () => {
+          s.screencastClients.delete(listener);
+          if (checkInterval) clearInterval(checkInterval);
+          checkInterval = null;
+          if (s.screencastClients.size === 0) void stopScreencast(s);
+        };
+        checkInterval = setInterval(() => {
+          if (sessions.get(sessionId) !== s) {
+            cleanup();
+            controller.close();
+          }
+        }, 1e3);
+      },
+      cancel() {
+        cleanup();
+      }
+    });
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive"
+      }
+    });
+  }
+  return jsonResponse(404, { ok: false, error: "not found" });
+}
+
+// src/bundled.ts
+import { createHash as createHash3 } from "crypto";
+import { cpSync, existsSync, rmSync } from "fs";
+import { readdir, readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var PKG_ROOT = path3.resolve(fileURLToPath(import.meta.url), "../..");
+var BUNDLED_DIR = path3.join(PKG_ROOT, "agent-templates");
+var SYSTEM_SKILLS_DIR = path3.join(BUNDLED_DIR, "system-skills");
+var SCRIPTS_DIR = path3.join(BUNDLED_DIR, "scripts");
+var SHARED_DIR = path3.join(BUNDLED_DIR, "shared");
+var MONOREPO_SRC = path3.resolve(PKG_ROOT, "../buda/agent-templates");
+function syncTemplatesFromMonorepo() {
+  if (!existsSync(MONOREPO_SRC)) {
+    throw new Error(`Cannot sync agent-templates: source missing at ${MONOREPO_SRC}`);
+  }
+  rmSync(BUNDLED_DIR, { recursive: true, force: true });
+  cpSync(MONOREPO_SRC, BUNDLED_DIR, {
+    recursive: true,
+    dereference: true,
+    filter: (src) => !src.split(path3.sep).includes("extensions")
+  });
+}
+ensureBundledDir();
+function ensureBundledDir() {
+  const missingRequiredTemplate = !existsSync(path3.join(SHARED_DIR, "BOOTSTRAP.md"));
+  if (existsSync(BUNDLED_DIR) && !missingRequiredTemplate) return;
+  if (!existsSync(MONOREPO_SRC)) {
+    console.warn(
+      `[buda-connector] agent-templates not found at ${BUNDLED_DIR} \u2014 system skills will be empty. Reinstall @buda-ai/connector to restore.`
+    );
+    return;
+  }
+  syncTemplatesFromMonorepo();
+  console.log(`[buda-connector] synced agent-templates from ${MONOREPO_SRC}`);
+}
+var cached = null;
+async function readBundledManifest() {
+  if (cached) return cached;
+  const systemSkillNames = (await readdir(SYSTEM_SKILLS_DIR, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  const version = await hashDir(BUNDLED_DIR);
+  cached = {
+    version,
+    bundledDir: BUNDLED_DIR,
+    systemSkillsDir: SYSTEM_SKILLS_DIR,
+    systemSkillNames,
+    scriptsDir: SCRIPTS_DIR,
+    sharedDir: SHARED_DIR
+  };
+  return cached;
+}
+async function hashDir(dir) {
+  const hash = createHash3("sha256");
+  await walk(dir, async (relPath, abs) => {
+    hash.update(`${relPath}:`).update(await readFile3(abs));
+  });
+  return hash.digest("hex");
+}
+async function walk(dir, visit, base = dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const abs = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walk(abs, visit, base);
+    } else if (entry.isFile()) {
+      await visit(path3.relative(base, abs), abs);
+    }
+  }
+}
+
+// src/types.ts
+var CONNECTOR_RELAY_PROTOCOL_VERSION = 1;
+var CONNECTOR_EXECUTION_IDENTITY_CAPABILITY = "execution-identity:ed25519-v1";
+
+// src/cloud-client.ts
+var BASE_CONNECTOR_CAPABILITIES = [
+  "connector",
+  "bunny-daemon",
+  "coding",
+  "filesystem",
+  "shell",
+  "git"
+];
+var browserAvailabilityWarningLogged = false;
+var getAdvertisedCapabilities = (browserAvailability = resolveBrowserAvailability(), deviceToken) => [
+  ...BASE_CONNECTOR_CAPABILITIES,
+  ...browserAvailability.available ? ["browser"] : [],
+  ...deviceToken ? [CONNECTOR_EXECUTION_IDENTITY_CAPABILITY] : []
+];
+async function buildPayload(config, extra) {
+  const bundle = await readBundledManifest();
+  const browserAvailability = resolveBrowserAvailability();
+  if (!browserAvailability.available && !browserAvailabilityWarningLogged) {
+    browserAvailabilityWarningLogged = true;
+    await writeLog("warn", browserAvailability.error);
+  }
   return {
     connectorId: config.connectorId,
     deviceId: config.deviceId,
     deviceName: config.deviceName,
     hostLabel: config.hostLabel,
-    platform: `${platform2()} ${release()}`,
+    platform: `${platform3()} ${release()}`,
     version: "dev",
     pid: process.pid,
     workdirRoot: config.workdirRoot,
@@ -184,61 +1110,109 @@ function buildPayload(config, extra) {
       root: extra.bunnyDaemon.root,
       status: "online"
     } : void 0,
-    capabilities: ["connector", "bunny-daemon", "coding", "filesystem", "shell", "git"],
-    ...extra?.logs?.length ? { logs: extra.logs } : {}
+    paths: {
+      workdir: config.workdirRoot,
+      systemSkillsDir: bundle.systemSkillsDir,
+      scriptsDir: bundle.scriptsDir,
+      sharedDir: bundle.sharedDir
+    },
+    bundle: {
+      version: bundle.version,
+      systemSkillNames: bundle.systemSkillNames
+    },
+    capabilities: getAdvertisedCapabilities(browserAvailability, config.deviceToken),
+    deviceCredential: config.deviceToken ? {
+      version: 1,
+      tokenHash: createHash4("sha256").update(config.deviceToken, "utf8").digest("base64url")
+    } : void 0,
+    ...extra?.logs?.length ? { logs: extra.logs } : {},
+    ...extra?.recovery ? { recovery: extra.recovery } : {}
   };
 }
-async function postJson(serverUrl, pathname, body, launchConfig) {
-  const token = launchConfig?.oauthToken?.trim();
-  const spaceId = getSpaceId(launchConfig)?.trim();
+function buildAuthHeaders(config, launchConfig) {
+  const headers = {
+    "X-Buda-Connector-Id": config.connectorId
+  };
+  const token = config.token?.trim() || getConnectorToken(launchConfig);
+  if (token) headers["X-Buda-Connector-Token"] = token;
+  if (config.deviceToken) headers["X-Buda-Connector-Device-Token"] = config.deviceToken;
+  return headers;
+}
+async function postJson(serverUrl, pathname, body, config, launchConfig) {
   const response = await fetch(`${serverUrl}${pathname}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      ...token ? { Authorization: `Bearer ${token}` } : {},
-      ...!token && spaceId ? { "X-Buda-Space-Id": spaceId } : {}
+      ...buildAuthHeaders(config, launchConfig)
     },
     body: JSON.stringify(body)
   });
   if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(`${pathname} failed: ${response.status} ${text}`);
+    const text2 = await response.text().catch(() => "");
+    let errorCode;
+    let errorMessage3 = text2;
+    try {
+      const payload = JSON.parse(text2);
+      errorCode = typeof payload.code === "string" ? payload.code : void 0;
+      errorMessage3 = typeof payload.error === "string" ? payload.error : text2;
+    } catch {
+    }
+    if (errorCode === "device_revoked") {
+      throw new Error(
+        `This device is prohibited/revoked and cannot reconnect. Contact support. (${errorMessage3})`
+      );
+    }
+    throw new Error(`${pathname} failed: ${response.status} ${errorMessage3}`);
   }
   return await response.json();
 }
 function formatConnectorOwner(connector) {
   return connector.userEmail ?? connector.userId ?? "anonymous";
 }
-async function registerConnector(config, launchConfig, bunnyDaemon) {
+async function warnIfStaleBundle(result) {
+  if (!result.bundle?.staleClient) return;
+  await writeLog(
+    "warn",
+    `connector bundle out of date \u2014 server expects ${result.bundle.expectedVersion ?? "newer"}; run \`pnpm up @buda-ai/connector\``
+  );
+}
+async function registerConnector(config, launchConfig, bunnyDaemon, options) {
   const result = await postJson(
     config.serverUrl,
     "/api/connectors/register",
-    buildPayload(config, { bunnyDaemon }),
+    await buildPayload(config, {
+      bunnyDaemon,
+      ...options?.recoverMissingProfile ? { recovery: "missing_local_profile" } : {}
+    }),
+    config,
     launchConfig
   );
   await writeLog(
     "info",
     `registered connector=${result.connector.connectorId} status=${result.connector.status} owner=${formatConnectorOwner(result.connector)}`
   );
+  await warnIfStaleBundle(result);
+  return {
+    connectorId: result.connector.connectorId,
+    relayProtocol: result.relayProtocol
+  };
 }
 async function heartbeatConnector(config, launchConfig, bunnyDaemon) {
   const logs = takePendingLogs();
   const result = await postJson(
     config.serverUrl,
     "/api/connectors/heartbeat",
-    buildPayload(config, {
+    await buildPayload(config, {
       bunnyDaemon,
       logs
     }),
+    config,
     launchConfig
   ).catch((error) => {
     restorePendingLogs(logs);
     throw error;
   });
-  await writeLog(
-    "info",
-    `heartbeat connector=${result.connector.connectorId} status=${result.connector.status} owner=${formatConnectorOwner(result.connector)}`
-  );
+  return { relayProtocol: result.relayProtocol };
 }
 async function unregisterConnector(config, launchConfig) {
   await postJson(
@@ -247,160 +1221,1260 @@ async function unregisterConnector(config, launchConfig) {
     {
       connectorId: config.connectorId
     },
+    config,
     launchConfig
   ).catch((error) => {
     void writeLog("warn", `unregister failed: ${error instanceof Error ? error.message : error}`);
   });
 }
 
-// ../../packages/relaylib/src/protocol.ts
-var utf8Encoder = new TextEncoder();
-function bytesToBase64(bytes) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
+// src/legacy-workspace-migration.ts
+import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
+import { constants as constants2, createReadStream } from "fs";
+import {
+  chmod as chmod2,
+  copyFile,
+  lstat,
+  mkdir as mkdir5,
+  open as open2,
+  readdir as readdir2,
+  readFile as readFile4,
+  readlink,
+  realpath,
+  rename as rename2,
+  rm,
+  symlink,
+  unlink as unlink3
+} from "fs/promises";
+import path4 from "path";
+var MIGRATION_VERSION = 1;
+var MIGRATION_DIRECTORY = path4.join(".buda", "migrations", "legacy-workspace-v1");
+var JOURNAL_FILENAME = "journal.json";
+var IMMUTABLE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+var LEGACY_TEMPLATE_FILES = [
+  "AGENTS.md",
+  "HEARTBEAT.md",
+  "IDENTITY.md",
+  "MEMORY.md",
+  "SOUL.md",
+  "TOOLS.md",
+  "USER.md"
+];
+var JOURNAL_STATUSES = /* @__PURE__ */ new Set([
+  "planned",
+  "migrating",
+  "complete",
+  "rolling-back",
+  "rolled-back"
+]);
+var ITEM_PHASES = /* @__PURE__ */ new Set([
+  "pending",
+  "copying",
+  "copied",
+  "verified",
+  "committed",
+  "rolled-back"
+]);
+var LegacyWorkspaceMigrationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LegacyWorkspaceMigrationError";
   }
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
+  recoverable = true;
+};
+var migrateLegacyWorkspaceRoot = async (storageRoot, options = {}) => {
+  await mkdir5(storageRoot, { recursive: true, mode: 448 });
+  const rootInfo = await lstat(storageRoot);
+  if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) {
+    throw new LegacyWorkspaceMigrationError(
+      "MIGRATION_SOURCE_UNSAFE",
+      "Legacy migration storage root must be a real directory"
+    );
   }
-  return btoa(binary);
-}
-
-// ../../packages/relaylib/src/relay-client.ts
-function attachRelayClient(socket, handler, options = {}) {
-  const chunkEncoding = options.chunkEncoding ?? "base64";
-  socket.on("message", (raw) => {
-    let message;
-    try {
-      message = JSON.parse(raw.toString());
-    } catch {
+  const canonicalRoot = await realpath(storageRoot);
+  const migrationDirectory = path4.join(canonicalRoot, MIGRATION_DIRECTORY);
+  await ensurePrivateDirectoryWithin(canonicalRoot, migrationDirectory);
+  const journalPath = path4.join(migrationDirectory, JOURNAL_FILENAME);
+  let journal = await readJournal(journalPath);
+  if (journal) validateJournalPaths(journal, canonicalRoot, migrationDirectory);
+  if (journal?.status === "complete") {
+    await verifyCommittedItems(journal);
+    return toResult(journal);
+  }
+  if (journal) await checkpoint(options, "restart", null);
+  if (journal?.status === "rolling-back") {
+    await resumeRollback(journalPath, journal, options);
+    journal = void 0;
+  }
+  if (journal?.status === "rolled-back") journal = void 0;
+  if (!journal) {
+    journal = await createJournal(canonicalRoot, migrationDirectory, options.owner);
+    await writeJournal(journalPath, journal);
+  } else {
+    assertOwnerMatches(journal, options.owner);
+  }
+  if (journal.status === "planned") {
+    journal.status = "migrating";
+    await writeJournal(journalPath, journal);
+  }
+  for (const item of journal.items) {
+    await migrateItem(canonicalRoot, journalPath, journal, item, options);
+  }
+  journal.status = "complete";
+  journal.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeJournal(journalPath, journal);
+  return toResult(journal);
+};
+var migrateItem = async (storageRoot, journalPath, journal, item, options) => {
+  if (item.phase === "committed") return;
+  if (await exists(item.target)) {
+    if (!await exists(item.staging) && ["verified", "copied", "copying"].includes(item.phase)) {
+      await verifyTree(item.source, item.target);
+      item.phase = "committed";
+      await writeJournal(journalPath, journal);
       return;
     }
-    if (message.type !== "request") return;
-    void handleRequest(socket, message.requestId, message.request, handler, chunkEncoding);
-  });
-}
-async function handleRequest(socket, requestId, request, handler, chunkEncoding) {
-  const send = (message) => {
-    if (socket.readyState === 1) socket.send(JSON.stringify(message));
+    throw new LegacyWorkspaceMigrationError(
+      "MIGRATION_TARGET_CONFLICT",
+      `Legacy migration target already exists for ${item.id}`
+    );
+  }
+  if (item.phase === "pending" || item.phase === "copying") {
+    item.phase = "copying";
+    await writeJournal(journalPath, journal);
+    await checkpoint(options, "before-copy", item.id);
+    await rm(item.staging, { recursive: true, force: true });
+    await ensurePrivateDirectoryWithin(storageRoot, path4.dirname(item.staging));
+    await copyTree(item.source, item.staging, () => checkpoint(options, "during-copy", item.id));
+    await checkpoint(options, "after-copy", item.id);
+    item.phase = "copied";
+    await writeJournal(journalPath, journal);
+  }
+  if (item.phase === "copied") {
+    await checkpoint(options, "before-verify", item.id);
+    try {
+      await verifyTree(item.source, item.staging);
+    } catch (error) {
+      await rm(item.staging, { recursive: true, force: true });
+      item.phase = "copying";
+      await writeJournal(journalPath, journal);
+      throw error;
+    }
+    await checkpoint(options, "after-verify", item.id);
+    item.phase = "verified";
+    await writeJournal(journalPath, journal);
+  }
+  if (item.phase === "verified") {
+    await checkpoint(options, "before-rename", item.id);
+    await ensurePrivateDirectoryWithin(storageRoot, path4.dirname(item.target));
+    await rename2(item.staging, item.target);
+    await syncDirectory(path4.dirname(item.target));
+    await checkpoint(options, "after-rename", item.id);
+    item.phase = "committed";
+    await writeJournal(journalPath, journal);
+  }
+};
+var resumeRollback = async (journalPath, journal, options) => {
+  for (const item of [...journal.items].reverse()) {
+    if (item.phase === "rolled-back") continue;
+    await checkpoint(options, "before-rollback", item.id);
+    if (!await exists(item.source)) {
+      throw new LegacyWorkspaceMigrationError(
+        "MIGRATION_VERIFY_FAILED",
+        `Cannot roll back ${item.id}: the preserved legacy source is missing`
+      );
+    }
+    await rm(item.staging, { recursive: true, force: true });
+    await rm(item.target, { recursive: true, force: true });
+    await checkpoint(options, "after-rollback", item.id);
+    item.phase = "rolled-back";
+    await writeJournal(journalPath, journal);
+  }
+  journal.status = "rolled-back";
+  delete journal.completedAt;
+  await writeJournal(journalPath, journal);
+};
+var createJournal = async (storageRoot, migrationDirectory, owner) => {
+  if (owner) validateOwner(owner);
+  const ownership = owner ? "explicit-owner" : "shared-legacy";
+  const label = owner ? `Legacy Connector root assigned to ${owner.spaceId}/${owner.agentId}` : "Shared legacy Connector root (ownership unassigned)";
+  const sources = await inventoryLegacySources(storageRoot);
+  const stagingRoot = path4.join(migrationDirectory, "staging", randomUUID2());
+  const items = sources.map(({ id, source }) => ({
+    id,
+    source,
+    target: deriveTarget(storageRoot, id, owner),
+    staging: path4.join(stagingRoot, id),
+    phase: "pending"
+  }));
+  assertDistinctTargets(items);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: MIGRATION_VERSION,
+    status: "planned",
+    ownership,
+    label,
+    ...owner ? { owner } : {},
+    createdAt: now,
+    updatedAt: now,
+    items
   };
-  let response;
-  try {
-    response = await handler(request);
-  } catch (error) {
-    send({ type: "error", requestId, error: errorMessage(error) });
+};
+var inventoryLegacySources = async (storageRoot) => {
+  const rootEntries = await readdir2(storageRoot, { withFileTypes: true });
+  const templateNames = new Set(LEGACY_TEMPLATE_FILES);
+  for (const entry of rootEntries) {
+    if (entry.name.endsWith(".md")) templateNames.add(entry.name);
+  }
+  const candidates = [
+    { id: "agent", source: path4.join(storageRoot, "agent") },
+    { id: "space", source: path4.join(storageRoot, "space") },
+    { id: "logs", source: path4.join(storageRoot, "logs") },
+    { id: "connector-log", source: path4.join(storageRoot, "connector.log") },
+    { id: "runtime-config", source: path4.join(storageRoot, "runtime-config") },
+    { id: "runtime-config-hidden", source: path4.join(storageRoot, ".runtime-config") },
+    { id: "runtime-config-file", source: path4.join(storageRoot, "runtime-config.json") },
+    { id: "runtime-config-hidden-file", source: path4.join(storageRoot, ".runtime-config.json") },
+    { id: "bunny-runtime", source: path4.join(storageRoot, ".bunny") },
+    ...[...templateNames].sort().map((name) => ({
+      id: `template-${name}`,
+      source: path4.join(storageRoot, name)
+    }))
+  ];
+  const found = [];
+  for (const candidate of candidates) {
+    if (!await exists(candidate.source)) continue;
+    const info = await lstat(candidate.source);
+    if (info.isSymbolicLink()) {
+      throw new LegacyWorkspaceMigrationError(
+        "MIGRATION_SOURCE_UNSAFE",
+        `Legacy migration source ${candidate.id} must not be a symbolic link`
+      );
+    }
+    if (info.isDirectory() && (await readdir2(candidate.source)).length === 0) continue;
+    found.push(candidate);
+  }
+  return found;
+};
+var deriveTarget = (storageRoot, id, owner) => {
+  if (!owner) return path4.join(storageRoot, ".buda", "legacy", "shared", id);
+  const spaceRoot = path4.join(storageRoot, ".buda", "spaces", owner.spaceId);
+  const agentRoot = path4.join(spaceRoot, "agents", owner.agentId);
+  if (id === "agent") return path4.join(agentRoot, "workspace", "legacy-connector-root");
+  if (id === "space") return path4.join(spaceRoot, "shared", "legacy-connector-root");
+  if (id.startsWith("template-")) {
+    return path4.join(spaceRoot, "shared", "legacy-templates", id.slice("template-".length));
+  }
+  return path4.join(agentRoot, "state", "legacy-connector-root", id);
+};
+var copyTree = async (source, destination, onEntryCopied) => {
+  const info = await lstat(source);
+  if (info.isDirectory()) {
+    await mkdir5(destination, { mode: info.mode & 4095 });
+    const entries = (await readdir2(source)).sort();
+    for (const entry of entries) {
+      await copyTree(path4.join(source, entry), path4.join(destination, entry), onEntryCopied);
+    }
+    await chmod2(destination, info.mode & 4095);
     return;
   }
-  send({
-    type: "start",
-    requestId,
-    status: response.status,
-    headers: headersToRecord(response.headers)
+  if (info.isFile()) {
+    await copyFile(source, destination, constants2.COPYFILE_EXCL);
+    await chmod2(destination, info.mode & 4095);
+    await onEntryCopied();
+    return;
+  }
+  if (info.isSymbolicLink()) {
+    await symlink(await readlink(source), destination);
+    await onEntryCopied();
+    return;
+  }
+  throw new LegacyWorkspaceMigrationError(
+    "MIGRATION_SOURCE_UNSAFE",
+    "Legacy migration supports only files, directories, and symbolic links"
+  );
+};
+var verifyTree = async (source, destination) => {
+  const [sourceInfo, destinationInfo] = await Promise.all([lstat(source), lstat(destination)]);
+  if (sourceInfo.isDirectory() !== destinationInfo.isDirectory()) {
+    throw verifyFailure("entry types differ");
+  }
+  if (sourceInfo.isFile() !== destinationInfo.isFile()) throw verifyFailure("entry types differ");
+  if (sourceInfo.isSymbolicLink() !== destinationInfo.isSymbolicLink()) {
+    throw verifyFailure("entry types differ");
+  }
+  if (!sourceInfo.isSymbolicLink() && (sourceInfo.mode & 4095) !== (destinationInfo.mode & 4095)) {
+    throw verifyFailure("permission bits differ");
+  }
+  if (sourceInfo.isDirectory()) {
+    const [sourceEntries, destinationEntries] = await Promise.all([
+      readdir2(source),
+      readdir2(destination)
+    ]);
+    sourceEntries.sort();
+    destinationEntries.sort();
+    if (JSON.stringify(sourceEntries) !== JSON.stringify(destinationEntries)) {
+      throw verifyFailure("directory entries differ");
+    }
+    for (const entry of sourceEntries) {
+      await verifyTree(path4.join(source, entry), path4.join(destination, entry));
+    }
+    return;
+  }
+  if (sourceInfo.isFile()) {
+    if (sourceInfo.size !== destinationInfo.size) throw verifyFailure("file sizes differ");
+    const [sourceHash, destinationHash] = await Promise.all([
+      hashFile(source),
+      hashFile(destination)
+    ]);
+    if (sourceHash !== destinationHash) throw verifyFailure("file bytes differ");
+    return;
+  }
+  if (await readlink(source) !== await readlink(destination)) {
+    throw verifyFailure("symbolic link targets differ");
+  }
+};
+var hashFile = async (filePath) => {
+  const hash = createHash5("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.once("error", reject);
+    stream.once("end", resolve);
   });
+  return hash.digest("hex");
+};
+var readJournal = async (journalPath) => {
+  let raw;
   try {
-    const body = response.body;
-    if (body) {
-      const reader = body.getReader();
-      if (chunkEncoding === "utf8") {
-        const decoder = new TextDecoder();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const text = decoder.decode(value, { stream: true });
-          if (text) send({ type: "chunk", requestId, data: text });
-        }
-        const tail = decoder.decode();
-        if (tail) send({ type: "chunk", requestId, data: tail });
-      } else {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          if (value && value.length > 0) {
-            send({
-              type: "chunk",
-              requestId,
-              encoding: "base64",
-              data: bytesToBase64(value)
-            });
-          }
-        }
-      }
+    raw = await readFile4(journalPath, "utf8");
+  } catch (error) {
+    if (isMissing(error)) return void 0;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw corrupt("Legacy migration journal contains invalid JSON");
+  }
+  if (!isJournal(value)) throw corrupt("Legacy migration journal is malformed");
+  await chmod2(journalPath, 384);
+  return value;
+};
+var writeJournal = async (journalPath, journal) => {
+  journal.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ensurePrivateDirectory(path4.dirname(journalPath));
+  const temporaryPath = `${journalPath}.${process.pid}.${randomUUID2()}.tmp`;
+  const handle = await open2(
+    temporaryPath,
+    constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY,
+    384
+  );
+  try {
+    await handle.writeFile(`${JSON.stringify(journal, null, 2)}
+`, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await rename2(temporaryPath, journalPath);
+    await chmod2(journalPath, 384);
+    await syncDirectory(path4.dirname(journalPath));
+  } finally {
+    await unlink3(temporaryPath).catch(() => void 0);
+  }
+};
+var syncDirectory = async (directory) => {
+  const handle = await open2(directory, constants2.O_RDONLY);
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+};
+var ensurePrivateDirectory = async (directory) => {
+  await mkdir5(directory, { mode: 448 }).catch((error) => {
+    if (!isAlreadyExists2(error)) throw error;
+  });
+  const info = await lstat(directory);
+  if (info.isSymbolicLink() || !info.isDirectory()) {
+    throw new LegacyWorkspaceMigrationError(
+      "MIGRATION_SOURCE_UNSAFE",
+      "Legacy migration control path must be a real directory"
+    );
+  }
+  await chmod2(directory, 448);
+};
+var ensurePrivateDirectoryWithin = async (storageRoot, directory) => {
+  if (directory !== storageRoot && !isPathInside(storageRoot, directory)) {
+    throw corrupt("Legacy migration control path escapes protected storage");
+  }
+  const relative = path4.relative(storageRoot, directory);
+  let current = storageRoot;
+  for (const segment of relative.split(path4.sep).filter(Boolean)) {
+    current = path4.join(current, segment);
+    await ensurePrivateDirectory(current);
+  }
+};
+var checkpoint = async (options, stage, itemId) => options.faultInjector?.({ stage, itemId });
+var assertOwnerMatches = (journal, owner) => {
+  if (!owner) return;
+  const expected = owner ? `${owner.spaceId}:${owner.agentId}` : void 0;
+  const actual = journal.owner ? `${journal.owner.spaceId}:${journal.owner.agentId}` : void 0;
+  if (expected !== actual) {
+    throw new LegacyWorkspaceMigrationError(
+      "MIGRATION_TARGET_CONFLICT",
+      "Legacy migration ownership cannot change while a journal is active; roll back first"
+    );
+  }
+};
+var validateJournalPaths = (journal, storageRoot, migrationDirectory) => {
+  validateJournalOwnership(journal);
+  const stagingParents = /* @__PURE__ */ new Set();
+  const itemIds = /* @__PURE__ */ new Set();
+  const sources = /* @__PURE__ */ new Set();
+  const targets = /* @__PURE__ */ new Set();
+  const stagingPaths = /* @__PURE__ */ new Set();
+  for (const item of journal.items) {
+    const sourceRelative = sourceRelativePath(item.id);
+    if (!sourceRelative || item.source !== path4.join(storageRoot, sourceRelative)) {
+      throw corrupt("Legacy migration journal contains an unexpected source path");
+    }
+    if (item.target !== deriveTarget(storageRoot, item.id, journal.owner)) {
+      throw corrupt("Legacy migration journal target is not canonical");
     }
-    send({ type: "end", requestId });
+    if (!isPathInside(migrationDirectory, item.staging)) {
+      throw corrupt("Legacy migration journal staging path escapes the migration directory");
+    }
+    const stagingParent = path4.dirname(item.staging);
+    if (path4.dirname(stagingParent) !== path4.join(migrationDirectory, "staging") || item.staging !== path4.join(stagingParent, item.id)) {
+      throw corrupt("Legacy migration journal staging path is not canonical");
+    }
+    stagingParents.add(stagingParent);
+    if (itemIds.has(item.id) || sources.has(item.source) || targets.has(item.target) || stagingPaths.has(item.staging)) {
+      throw corrupt("Legacy migration journal contains duplicate items");
+    }
+    itemIds.add(item.id);
+    sources.add(item.source);
+    targets.add(item.target);
+    stagingPaths.add(item.staging);
+  }
+  if (stagingParents.size > 1) throw corrupt("Legacy migration journal has multiple staging roots");
+  validateJournalState(journal);
+};
+var sourceRelativePath = (id) => {
+  const known = {
+    agent: "agent",
+    space: "space",
+    logs: "logs",
+    "connector-log": "connector.log",
+    "runtime-config": "runtime-config",
+    "runtime-config-hidden": ".runtime-config",
+    "runtime-config-file": "runtime-config.json",
+    "runtime-config-hidden-file": ".runtime-config.json",
+    "bunny-runtime": ".bunny"
+  };
+  if (known[id]) return known[id];
+  if (!id.startsWith("template-")) return null;
+  const name = id.slice("template-".length);
+  return name.endsWith(".md") && path4.basename(name) === name ? name : null;
+};
+var validateJournalOwnership = (journal) => {
+  if (journal.ownership === "explicit-owner") {
+    if (!journal.owner) throw corrupt("Explicit legacy migration ownership is missing");
+    validateOwner(journal.owner);
+    return;
+  }
+  if (journal.ownership !== "shared-legacy" || journal.owner) {
+    throw corrupt("Legacy migration ownership is inconsistent");
+  }
+};
+var validateJournalState = (journal) => {
+  if (journal.status === "planned" && journal.items.some((item) => item.phase !== "pending")) {
+    throw corrupt("Planned legacy migration contains advanced items");
+  }
+  if (journal.status === "migrating" && journal.items.some((item) => item.phase === "rolled-back")) {
+    throw corrupt("Active legacy migration contains rolled-back items");
+  }
+  if (journal.status === "complete" && journal.items.some((item) => item.phase !== "committed")) {
+    throw corrupt("Completed legacy migration contains unfinished items");
+  }
+  if (journal.status === "rolled-back" && journal.items.some((item) => item.phase !== "rolled-back")) {
+    throw corrupt("Rolled-back legacy migration contains active items");
+  }
+};
+var verifyCommittedItems = async (journal) => {
+  try {
+    for (const item of journal.items) await verifyTree(item.source, item.target);
+  } catch (error) {
+    if (error instanceof LegacyWorkspaceMigrationError) throw error;
+    throw verifyFailure(`committed data is unavailable: ${errorMessage(error)}`);
+  }
+};
+var validateOwner = (owner) => {
+  if (!IMMUTABLE_ID_PATTERN.test(owner.spaceId) || !IMMUTABLE_ID_PATTERN.test(owner.agentId)) {
+    throw new LegacyWorkspaceMigrationError(
+      "MIGRATION_SOURCE_UNSAFE",
+      "Legacy migration owner must use immutable Space and Agent IDs"
+    );
+  }
+};
+var assertDistinctTargets = (items) => {
+  const targets = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (targets.has(item.target)) throw corrupt("Legacy migration targets collide");
+    targets.add(item.target);
+  }
+};
+var toResult = (journal) => ({
+  status: "complete",
+  ownership: journal.ownership,
+  label: journal.label,
+  migratedItems: journal.items.map((item) => item.id),
+  rollbackAvailable: true
+});
+var isJournal = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const journal = value;
+  return journal.version === MIGRATION_VERSION && typeof journal.status === "string" && JOURNAL_STATUSES.has(journal.status) && (journal.ownership === "explicit-owner" || journal.ownership === "shared-legacy") && typeof journal.label === "string" && typeof journal.createdAt === "string" && typeof journal.updatedAt === "string" && Array.isArray(journal.items) && journal.items.every(
+    (item) => item && typeof item === "object" && typeof item.id === "string" && typeof item.source === "string" && typeof item.target === "string" && typeof item.staging === "string" && typeof item.phase === "string" && ITEM_PHASES.has(item.phase)
+  );
+};
+var exists = async (filePath) => {
+  try {
+    await lstat(filePath);
+    return true;
   } catch (error) {
-    send({ type: "error", requestId, error: errorMessage(error) });
+    if (isMissing(error)) return false;
+    throw error;
+  }
+};
+var isPathInside = (parent, child) => {
+  const relative = path4.relative(parent, child);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
+};
+var isMissing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var isAlreadyExists2 = (error) => error instanceof Error && "code" in error && error.code === "EEXIST";
+var verifyFailure = (detail) => new LegacyWorkspaceMigrationError(
+  "MIGRATION_VERIFY_FAILED",
+  `Legacy migration verification failed: ${detail}`
+);
+var corrupt = (message) => new LegacyWorkspaceMigrationError("MIGRATION_CORRUPT", message);
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+
+// src/relay.ts
+import path6 from "path";
+import { createNextHandler } from "@bunny-agent/daemon/nextjs";
+import WebSocket from "ws";
+
+// src/execution-identity.ts
+import {
+  createHash as createHash6,
+  createPublicKey,
+  timingSafeEqual,
+  verify as verifySignature
+} from "crypto";
+var MAX_ISSUED_AT_FUTURE_SKEW_MS = 3e4;
+var ERROR_MESSAGES = {
+  IDENTITY_INVALID: "The Connector execution identity is invalid.",
+  IDENTITY_EXPIRED: "The Connector execution identity has expired or is not yet valid.",
+  WORKSPACE_MISMATCH: "The Connector execution identity targets a different workspace.",
+  REPLAY_REJECTED: "The Connector execution identity has already been used.",
+  PROTOCOL_UNSUPPORTED: "The Connector execution identity protocol is unsupported."
+};
+var ConnectorRelayProtocolError = class extends Error {
+  code;
+  constructor(code) {
+    super(ERROR_MESSAGES[code]);
+    this.name = "ConnectorRelayProtocolError";
+    this.code = code;
   }
+};
+var ConnectorExecutionReplayGuard = class {
+  nonces = /* @__PURE__ */ new Map();
+  runIds = /* @__PURE__ */ new Map();
+  assertUnusedAndRemember(identity, expiresAt, now) {
+    this.prune(now);
+    if (this.nonces.has(identity.nonce) || this.runIds.has(identity.runId)) {
+      throw new ConnectorRelayProtocolError("REPLAY_REJECTED");
+    }
+    this.nonces.set(identity.nonce, expiresAt);
+    this.runIds.set(identity.runId, expiresAt);
+  }
+  prune(now) {
+    for (const [nonce, expiresAt] of this.nonces) {
+      if (expiresAt <= now) this.nonces.delete(nonce);
+    }
+    for (const [runId, expiresAt] of this.runIds) {
+      if (expiresAt <= now) this.runIds.delete(runId);
+    }
+  }
+};
+function canonicalizeConnectorExecutionIdentity(identity) {
+  return Buffer.from(
+    JSON.stringify([
+      identity.version,
+      identity.keyId,
+      identity.connectorId,
+      identity.spaceId,
+      identity.agentId,
+      identity.runId,
+      identity.issuedAt,
+      identity.expiresAt,
+      identity.nonce,
+      identity.requestDigest
+    ]),
+    "utf8"
+  );
 }
-function headersToRecord(headers) {
-  const record = {};
-  headers.forEach((value, key) => {
-    record[key] = value;
-  });
-  return record;
+function verifyConnectorExecutionIdentity(options) {
+  const now = options.now ?? Date.now();
+  const protocol = assertSupportedProtocol(options.protocolVersion, options.protocol);
+  const identity = parseExecutionIdentity(options.executionIdentity);
+  if (identity.version !== CONNECTOR_RELAY_PROTOCOL_VERSION) {
+    throw new ConnectorRelayProtocolError("PROTOCOL_UNSUPPORTED");
+  }
+  if (identity.keyId !== protocol.keyId) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  if (identity.connectorId !== options.expectedConnectorId) {
+    throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
+  }
+  const issuedAt = Date.parse(identity.issuedAt);
+  const expiresAt = Date.parse(identity.expiresAt);
+  if (!Number.isFinite(issuedAt) || !Number.isFinite(expiresAt) || expiresAt <= issuedAt) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  if (issuedAt > now + MAX_ISSUED_AT_FUTURE_SKEW_MS || expiresAt <= now) {
+    throw new ConnectorRelayProtocolError("IDENTITY_EXPIRED");
+  }
+  const signature = decodeSignature(identity.signature);
+  let verified = false;
+  try {
+    const publicKey = createPublicKey({ key: protocol.publicKeyJwk, format: "jwk" });
+    if (publicKey.asymmetricKeyType !== "ed25519") {
+      throw new ConnectorRelayProtocolError("PROTOCOL_UNSUPPORTED");
+    }
+    verified = verifySignature(
+      null,
+      canonicalizeConnectorExecutionIdentity(identity),
+      publicKey,
+      signature
+    );
+  } catch (error) {
+    if (error instanceof ConnectorRelayProtocolError) throw error;
+    throw new ConnectorRelayProtocolError("PROTOCOL_UNSUPPORTED");
+  }
+  if (!verified) throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  const actualRequestDigest = digestConnectorRelayRequest(options.request);
+  if (!safeDigestEqual(identity.requestDigest, actualRequestDigest)) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  options.replayGuard.assertUnusedAndRemember(identity, expiresAt, now);
+  return identity;
+}
+function assertSupportedProtocol(protocolVersion, protocol) {
+  if (protocolVersion !== CONNECTOR_RELAY_PROTOCOL_VERSION || !protocol || protocol.version !== CONNECTOR_RELAY_PROTOCOL_VERSION || protocol.capability !== CONNECTOR_EXECUTION_IDENTITY_CAPABILITY || protocol.algorithm !== "Ed25519" || !isNonEmptyString(protocol.keyId) || !protocol.publicKeyJwk) {
+    throw new ConnectorRelayProtocolError("PROTOCOL_UNSUPPORTED");
+  }
+  return protocol;
+}
+function parseExecutionIdentity(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ConnectorRelayProtocolError("PROTOCOL_UNSUPPORTED");
+  }
+  const identity = value;
+  const requiredStringFields = [
+    "keyId",
+    "connectorId",
+    "spaceId",
+    "agentId",
+    "runId",
+    "issuedAt",
+    "expiresAt",
+    "nonce",
+    "requestDigest",
+    "signature"
+  ];
+  if (requiredStringFields.some((field) => !isNonEmptyString(identity[field]))) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  if (typeof identity.version !== "number") {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  return identity;
+}
+function digestConnectorRelayRequest(request) {
+  const serialized = JSON.stringify(request);
+  if (serialized === void 0) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  return createHash6("sha256").update(serialized, "utf8").digest("base64url");
+}
+function safeDigestEqual(expected, actual) {
+  const expectedBytes = Buffer.from(expected, "utf8");
+  const actualBytes = Buffer.from(actual, "utf8");
+  return expectedBytes.length === actualBytes.length && timingSafeEqual(expectedBytes, actualBytes);
+}
+function decodeSignature(value) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  const signature = Buffer.from(value, "base64url");
+  if (signature.length !== 64) {
+    throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+  }
+  return signature;
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
 }
 
+// src/workspace-volume-lifecycle.ts
+import { constants as constants3 } from "fs";
+import {
+  copyFile as copyFile2,
+  lstat as lstat2,
+  mkdir as mkdir6,
+  readdir as readdir3,
+  readFile as readFile5,
+  realpath as realpath2,
+  rm as rm2,
+  symlink as symlink2,
+  writeFile as writeFile2
+} from "fs/promises";
+import path5 from "path";
+var MOUNT_DIRECTORY = "mount";
+var ARCHIVE_MARKER = "archived.json";
+var AGENT_CONTEXT_TEMPLATE_FILES = [
+  "AGENTS.md",
+  "SOUL.md",
+  "IDENTITY.md",
+  "USER.md",
+  "TOOLS.md",
+  "BOOTSTRAP.md",
+  "MEMORY.md"
+];
+var deriveSystemVolume = (descriptor) => path5.join(
+  path5.dirname(path5.dirname(path5.dirname(path5.dirname(descriptor.sharedVolume)))),
+  "system"
+);
+var WorkspaceVolumeLifecycle = class {
+  constructor(descriptor) {
+    this.descriptor = descriptor;
+    this.systemVolume = deriveSystemVolume(descriptor);
+  }
+  systemVolume;
+  async mount() {
+    await this.ensureVolumes();
+    await this.bootstrapAgentTemplates((await readBundledManifest()).sharedDir);
+    const mountRoot = path5.join(this.descriptor.stateVolume, MOUNT_DIRECTORY);
+    await mkdir6(mountRoot, { recursive: true, mode: 448 });
+    const mounts = {
+      mountRoot,
+      agent: path5.join(mountRoot, "agent"),
+      space: path5.join(mountRoot, "space"),
+      system: path5.join(mountRoot, "system"),
+      temporary: path5.join(mountRoot, "tmp")
+    };
+    await Promise.all([
+      ensureVolumeLink(this.descriptor.privateVolume, mounts.agent),
+      ensureVolumeLink(this.descriptor.sharedVolume, mounts.space),
+      ensureVolumeLink(this.systemVolume, mounts.system),
+      ensureVolumeLink(this.descriptor.temporaryVolume, mounts.temporary)
+    ]);
+    const daemonVolumes = path5.join(mountRoot, "volumes");
+    await mkdir6(daemonVolumes, { recursive: true, mode: 448 });
+    await Promise.all([
+      ensureVolumeLink(this.descriptor.privateVolume, path5.join(daemonVolumes, "agent")),
+      ensureVolumeLink(this.descriptor.sharedVolume, path5.join(daemonVolumes, "space")),
+      ensureVolumeLink(this.systemVolume, path5.join(daemonVolumes, "system")),
+      ensureVolumeLink(this.descriptor.temporaryVolume, path5.join(daemonVolumes, "tmp"))
+    ]);
+    return mounts;
+  }
+  async unmount() {
+    await rm2(path5.join(this.descriptor.stateVolume, MOUNT_DIRECTORY), {
+      recursive: true,
+      force: true
+    });
+  }
+  async archiveAgent() {
+    await this.unmount();
+    await mkdir6(this.descriptor.stateVolume, { recursive: true, mode: 448 });
+    await writeFile2(
+      path5.join(this.descriptor.stateVolume, ARCHIVE_MARKER),
+      `${JSON.stringify({ archivedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+  }
+  async restoreAgent() {
+    await rm2(path5.join(this.descriptor.stateVolume, ARCHIVE_MARKER), { force: true });
+    return this.mount();
+  }
+  async deleteAgent(options) {
+    requireConfirmation(options);
+    await this.unmount();
+    const agentRoot = path5.dirname(this.descriptor.privateVolume);
+    await rm2(agentRoot, { recursive: true, force: true });
+  }
+  async archiveSpace() {
+    await mkdir6(this.descriptor.sharedVolume, { recursive: true, mode: 448 });
+    await writeFile2(
+      path5.join(this.descriptor.sharedVolume, ARCHIVE_MARKER),
+      `${JSON.stringify({ archivedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+  }
+  async restoreSpace() {
+    await rm2(path5.join(this.descriptor.sharedVolume, ARCHIVE_MARKER), { force: true });
+  }
+  async deleteSpace(options) {
+    requireConfirmation(options);
+    await this.unmount();
+    await rm2(this.descriptor.sharedVolume, { recursive: true, force: true });
+  }
+  async bootstrapAgentTemplates(templateDirectory) {
+    await mkdir6(this.descriptor.privateVolume, { recursive: true, mode: 448 });
+    const bootstrapped = [];
+    const skipped = [];
+    const entries = new Set(
+      (await readdir3(templateDirectory, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile()).map((entry) => entry.name)
+    );
+    for (const filename of AGENT_CONTEXT_TEMPLATE_FILES) {
+      if (!entries.has(filename)) continue;
+      const destination = path5.join(this.descriptor.privateVolume, filename);
+      try {
+        await lstat2(destination);
+        skipped.push(filename);
+      } catch (error) {
+        if (!isMissingFile(error)) throw error;
+        try {
+          await copyFile2(
+            path5.join(templateDirectory, filename),
+            destination,
+            constants3.COPYFILE_EXCL
+          );
+          bootstrapped.push(filename);
+        } catch (copyError) {
+          if (!isAlreadyExists3(copyError)) throw copyError;
+          skipped.push(filename);
+        }
+      }
+    }
+    return { bootstrapped, skipped };
+  }
+  async ensureVolumes() {
+    for (const volume of [
+      this.descriptor.privateVolume,
+      this.descriptor.sharedVolume,
+      this.descriptor.stateVolume,
+      this.descriptor.temporaryVolume,
+      this.systemVolume
+    ]) {
+      await mkdir6(volume, { recursive: true, mode: 448 });
+      const info = await lstat2(volume);
+      if (info.isSymbolicLink() || !info.isDirectory() || await realpath2(volume) !== volume) {
+        throw new Error("Workspace volume must be a canonical real directory");
+      }
+    }
+  }
+};
+var requireConfirmation = (options) => {
+  if (options.confirmed !== true) throw new Error("Workspace deletion requires confirmation");
+};
+var isMissingFile = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+var ensureVolumeLink = async (target, linkPath) => {
+  try {
+    const info = await lstat2(linkPath);
+    if (!info.isSymbolicLink() || await realpath2(linkPath) !== target) {
+      throw new Error("Workspace mount link does not match its canonical volume");
+    }
+  } catch (error) {
+    if (!isMissingFile(error)) throw error;
+    try {
+      await symlink2(target, linkPath, "dir");
+    } catch (createError) {
+      if (!isAlreadyExists3(createError)) throw createError;
+      const info = await lstat2(linkPath);
+      if (!info.isSymbolicLink() || await realpath2(linkPath) !== target) {
+        throw new Error("Workspace mount link raced with an invalid target");
+      }
+    }
+  }
+};
+var isAlreadyExists3 = (error) => error instanceof Error && "code" in error && error.code === "EEXIST";
+
 // src/relay.ts
-import WebSocket from "ws";
-function startConnectorRelay(config, bunnyDaemon, launchConfig) {
+var RELAY_PING_INTERVAL_MS = 2e4;
+var RELAY_PONG_TIMEOUT_MS = 1e4;
+var RELAY_RECONNECT_MAX_MS = 3e4;
+var RELAY_RECONNECT_JITTER = 0.2;
+var RELAY_FAST_RECONNECT_MS = 500;
+var CONNECTOR_SOCKET_REPLACED_CLOSE_CODE = 4001;
+var CONNECTOR_SOCKET_REVOKED_CLOSE_CODE = 4003;
+var shouldReconnectConnectorRelay = (closeCode) => closeCode !== CONNECTOR_SOCKET_REPLACED_CLOSE_CODE && closeCode !== CONNECTOR_SOCKET_REVOKED_CLOSE_CODE;
+var getConnectorRelayReconnectBaseDelay = (hadOpenConnection, backoffMs) => hadOpenConnection ? RELAY_FAST_RECONNECT_MS : backoffMs;
+function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegistry, launchConfig) {
   let socket = null;
   let reconnectTimer = null;
+  let pingTimer = null;
+  let pongTimer = null;
   let stopped = false;
-  const handler = createRelayHandler(bunnyDaemon);
+  let reconnectDelayMs = RELAY_RECONNECT_INTERVAL_MS;
+  let hadOpenConnection = false;
+  let activeRelayProtocol = relayProtocol;
+  const replayGuard = new ConnectorExecutionReplayGuard();
+  const clearTimers = () => {
+    if (pingTimer) {
+      clearInterval(pingTimer);
+      pingTimer = null;
+    }
+    if (pongTimer) {
+      clearTimeout(pongTimer);
+      pongTimer = null;
+    }
+  };
+  const nextReconnectDelay = () => {
+    const reconnectingEstablishedSocket = hadOpenConnection;
+    const base = getConnectorRelayReconnectBaseDelay(
+      reconnectingEstablishedSocket,
+      reconnectDelayMs
+    );
+    hadOpenConnection = false;
+    reconnectDelayMs = reconnectingEstablishedSocket ? RELAY_RECONNECT_INTERVAL_MS : Math.min(reconnectDelayMs * 2, RELAY_RECONNECT_MAX_MS);
+    const jitter = base * RELAY_RECONNECT_JITTER * (Math.random() * 2 - 1);
+    return Math.max(reconnectingEstablishedSocket ? 250 : 500, Math.round(base + jitter));
+  };
+  const scheduleReconnect = (reason) => {
+    if (stopped || reconnectTimer) return;
+    const delay = nextReconnectDelay();
+    void writeLog("info", `relay reconnecting in ${delay}ms (${reason})`);
+    clearTimers();
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      try {
+        connect();
+      } catch (error) {
+        void writeLog(
+          "warn",
+          `relay reconnect threw: ${error instanceof Error ? error.message : error}`
+        );
+        scheduleReconnect("connect-throw");
+      }
+    }, delay);
+  };
   const connect = () => {
     if (stopped) return;
     const relayUrl = getConnectorRelayUrl(config.serverUrl, config.connectorId);
-    const token = launchConfig?.oauthToken?.trim();
-    socket = new WebSocket(relayUrl, {
-      headers: token ? { Authorization: `Bearer ${token}` } : void 0
+    const oauthToken = launchConfig?.oauthToken?.trim();
+    const token = config.token?.trim() || getConnectorToken(launchConfig);
+    const headers = {};
+    if (oauthToken) headers.Authorization = `Bearer ${oauthToken}`;
+    if (token) headers["X-Buda-Connector-Token"] = token;
+    headers["X-Buda-Connector-Id"] = config.connectorId;
+    if (config.deviceToken) headers["X-Buda-Connector-Device-Token"] = config.deviceToken;
+    const ws = new WebSocket(relayUrl, {
+      headers: Object.keys(headers).length > 0 ? headers : void 0
     });
-    socket.on("open", () => {
+    socket = ws;
+    const inflight = /* @__PURE__ */ new Map();
+    let detached = false;
+    const detach = () => {
+      if (detached) return;
+      detached = true;
+      ws.removeAllListeners();
+      for (const controller of inflight.values()) controller.abort();
+      inflight.clear();
+    };
+    ws.on("open", () => {
       void writeLog("info", `relay connected ${relayUrl}`);
+      hadOpenConnection = true;
+      reconnectDelayMs = RELAY_RECONNECT_INTERVAL_MS;
+      pingTimer = setInterval(() => {
+        if (ws.readyState !== WebSocket.OPEN) return;
+        try {
+          ws.ping();
+        } catch (error) {
+          void writeLog(
+            "warn",
+            `relay ping failed: ${error instanceof Error ? error.message : error}`
+          );
+          ws.terminate();
+          return;
+        }
+        if (pongTimer) clearTimeout(pongTimer);
+        pongTimer = setTimeout(() => {
+          void writeLog("warn", "relay pong timeout, terminating");
+          ws.terminate();
+        }, RELAY_PONG_TIMEOUT_MS);
+      }, RELAY_PING_INTERVAL_MS);
+    });
+    ws.on("pong", () => {
+      if (pongTimer) {
+        clearTimeout(pongTimer);
+        pongTimer = null;
+      }
+    });
+    ws.on("message", (raw) => {
+      void handleRelayMessage(
+        ws,
+        bunnyDaemon,
+        raw.toString(),
+        inflight,
+        config.connectorId,
+        activeRelayProtocol,
+        replayGuard,
+        workspaceRegistry
+      );
     });
-    attachRelayClient(socket, handler, { chunkEncoding: "utf8" });
-    socket.on("close", () => {
+    ws.on("close", (code) => {
+      detach();
+      if (!shouldReconnectConnectorRelay(code)) {
+        stopped = true;
+        void writeLog(
+          "warn",
+          code === CONNECTOR_SOCKET_REPLACED_CLOSE_CODE ? "relay replaced by another process for this connector" : "relay access revoked; restore access and restart the Connector to reconnect"
+        );
+        return;
+      }
       void writeLog("warn", "relay disconnected");
-      if (stopped) return;
-      reconnectTimer = setTimeout(connect, RELAY_RECONNECT_INTERVAL_MS);
+      scheduleReconnect("close");
     });
-    socket.on("error", (error) => {
+    ws.on("error", (error) => {
       void writeLog("warn", `relay error: ${error instanceof Error ? error.message : error}`);
+      detach();
+      scheduleReconnect("error");
     });
   };
-  connect();
+  try {
+    connect();
+  } catch (error) {
+    void writeLog(
+      "warn",
+      `relay initial connect threw: ${error instanceof Error ? error.message : error}`
+    );
+    scheduleReconnect("connect-throw");
+  }
   return {
+    updateRelayProtocol(nextRelayProtocol) {
+      const previousKeyId = activeRelayProtocol?.keyId;
+      activeRelayProtocol = nextRelayProtocol;
+      if (nextRelayProtocol?.keyId && nextRelayProtocol.keyId !== previousKeyId) {
+        void writeLog("info", `relay protocol key updated ${nextRelayProtocol.keyId}`);
+      }
+    },
     stop() {
       stopped = true;
-      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      clearTimers();
       socket?.close();
     }
   };
 }
-function createRelayHandler(bunnyDaemon) {
-  const allowedOrigin = new URL(bunnyDaemon.baseUrl).origin;
-  return async (request) => {
-    const requestUrl = new URL(request.path, bunnyDaemon.baseUrl);
-    if (requestUrl.origin !== allowedOrigin) {
-      throw new Error("Relay request must target the embedded bunny daemon.");
-    }
-    await writeLog("info", `relay request ${request.method} ${requestUrl.pathname}`, {
-      actorEmail: getHeaderValue(request.headers, "x-buda-relay-actor-email") || null,
-      actorId: getHeaderValue(request.headers, "x-buda-relay-actor-id") || null,
-      source: getHeaderValue(request.headers, "x-buda-relay-source") || "unknown",
-      action: getHeaderValue(request.headers, "x-buda-relay-action") || "unknown",
-      target: requestUrl.toString()
+async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedConnectorId, relayProtocol, replayGuard, workspaceRegistry) {
+  if (!socket || socket.readyState !== WebSocket.OPEN) return;
+  let message;
+  try {
+    message = JSON.parse(raw);
+  } catch {
+    await writeLog("warn", "relay received invalid json");
+    return;
+  }
+  if (message.type === "abort") {
+    const controller2 = inflight.get(message.requestId);
+    if (controller2) {
+      void writeLog("info", `relay abort ${message.requestId}`);
+      controller2.abort();
+    }
+    return;
+  }
+  if (message.type === "event") {
+    await writeLog("warn", "relay rejected unsigned browser input event");
+    return;
+  }
+  if (message.type !== "request") return;
+  const hasProtocolVersion = message.protocolVersion !== void 0;
+  const hasExecutionIdentity = message.executionIdentity !== void 0;
+  let executionIdentity;
+  if (hasProtocolVersion || hasExecutionIdentity) {
+    try {
+      verifyConnectorExecutionIdentity({
+        protocolVersion: message.protocolVersion,
+        executionIdentity: message.executionIdentity,
+        request: message.request,
+        protocol: relayProtocol,
+        expectedConnectorId,
+        replayGuard
+      });
+      executionIdentity = message.executionIdentity;
+    } catch (error) {
+      sendRelayError(socket, message.requestId, error);
+      return;
+    }
+  }
+  const controller = new AbortController();
+  inflight.set(message.requestId, controller);
+  try {
+    const requestPath = message.request.path;
+    const isBrowserRequest = requestPath.startsWith("/browser/") || requestPath === "/browser";
+    const isWorkspaceDescriptorRequest = requestPath === "/workspace/descriptor";
+    const isAgentRequest = isBrowserRequest || requestPath.startsWith("/api/") || isWorkspaceDescriptorRequest;
+    if (isAgentRequest && (!executionIdentity || !workspaceRegistry)) {
+      throw new ConnectorRelayProtocolError("IDENTITY_INVALID");
+    }
+    const descriptor = executionIdentity ? await workspaceRegistry?.resolve(executionIdentity.spaceId, executionIdentity.agentId) : void 0;
+    if (descriptor && (descriptor.spaceId !== executionIdentity?.spaceId || descriptor.agentId !== executionIdentity.agentId)) {
+      throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
+    }
+    const mounts = descriptor ? await new WorkspaceVolumeLifecycle(descriptor).mount() : void 0;
+    let response;
+    if (isWorkspaceDescriptorRequest && descriptor) {
+      response = Response.json({
+        ok: true,
+        data: {
+          workspaceKey: descriptor.workspaceKey,
+          workspacePath: descriptor.privateVolume,
+          sharedPath: descriptor.sharedVolume,
+          systemPath: deriveSystemVolume(descriptor),
+          isolationMode: descriptor.isolationMode
+        }
+      });
+    } else if (isBrowserRequest) {
+      await writeLog("info", `relay browser ${message.request.method} ${requestPath}`);
+      response = await handleBrowserRequest(
+        requestPath,
+        message.request.method,
+        message.request.body,
+        {
+          sessionId: `${descriptor?.workspaceKey}:${getHeaderValue(message.request.headers, "x-buda-browser-session-id") ?? "default"}`,
+          workdirRoot: mounts?.mountRoot
+        }
+      );
+    } else if (descriptor && mounts) {
+      response = await handleWorkspaceDaemonRequest(message.request, mounts, controller.signal);
+    } else {
+      const requestUrl = new URL(requestPath, bunnyDaemon.baseUrl);
+      if (requestUrl.origin !== new URL(bunnyDaemon.baseUrl).origin) {
+        throw new Error("Relay request must target the embedded bunny daemon.");
+      }
+      await writeLog("info", `relay request ${message.request.method} ${requestUrl.pathname}`, {
+        actorEmail: getHeaderValue(message.request.headers, "x-buda-relay-actor-email") || null,
+        actorId: getHeaderValue(message.request.headers, "x-buda-relay-actor-id") || null,
+        source: getHeaderValue(message.request.headers, "x-buda-relay-source") || "unknown",
+        action: getHeaderValue(message.request.headers, "x-buda-relay-action") || "unknown",
+        target: requestUrl.toString()
+      });
+      response = await fetch(requestUrl, {
+        method: message.request.method,
+        headers: {
+          "Content-Type": "application/json",
+          ...message.request.headers ?? {}
+        },
+        body: message.request.body === void 0 ? void 0 : JSON.stringify(message.request.body),
+        signal: controller.signal
+      });
+    }
+    sendRelayMessage(socket, {
+      type: "start",
+      requestId: message.requestId,
+      status: response.status,
+      headers: headersToRecord(response.headers)
     });
-    return fetch(requestUrl, {
-      method: request.method,
-      headers: {
-        "Content-Type": "application/json",
-        ...request.headers ?? {}
-      },
-      body: request.body === void 0 ? void 0 : JSON.stringify(request.body)
+    if (response.body) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      const cancelReader = () => {
+        void reader.cancel().catch(() => {
+        });
+      };
+      controller.signal.addEventListener("abort", cancelReader, { once: true });
+      if (controller.signal.aborted) cancelReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          sendRelayMessage(socket, {
+            type: "chunk",
+            requestId: message.requestId,
+            data: decoder.decode(value, { stream: true })
+          });
+        }
+        const tail = decoder.decode();
+        if (tail) {
+          sendRelayMessage(socket, {
+            type: "chunk",
+            requestId: message.requestId,
+            data: tail
+          });
+        }
+      } finally {
+        controller.signal.removeEventListener("abort", cancelReader);
+        reader.releaseLock();
+      }
+    }
+    sendRelayMessage(socket, {
+      type: "end",
+      requestId: message.requestId
     });
-  };
+  } catch (error) {
+    sendRelayError(socket, message.requestId, error);
+  } finally {
+    inflight.delete(message.requestId);
+  }
+}
+var handleWorkspaceDaemonRequest = async (request, mounts, signal) => {
+  const normalized = normalizeWorkspaceRequest(request, mounts);
+  const handler = createNextHandler({ root: mounts.mountRoot });
+  return handler(
+    new Request(new URL(normalized.path, "http://connector.workspace"), {
+      method: normalized.method,
+      headers: normalized.headers,
+      body: normalized.body === void 0 ? void 0 : JSON.stringify(normalized.body),
+      signal
+    })
+  );
+};
+var normalizeWorkspaceRequest = (request, mounts) => {
+  if (request.path !== "/api/coding/run") return request;
+  if (!request.body || typeof request.body !== "object" || Array.isArray(request.body)) {
+    throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
+  }
+  const body = request.body;
+  const cwd = typeof body.cwd === "string" ? body.cwd : "/agent";
+  const normalized = path6.posix.normalize(cwd);
+  const [mount, relative] = normalized === "/agent" || normalized.startsWith("/agent/") ? [mounts.agent, normalized.slice("/agent".length)] : normalized === "/space" || normalized.startsWith("/space/") ? [mounts.space, normalized.slice("/space".length)] : [];
+  if (!mount || relative === void 0) {
+    throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
+  }
+  return { ...request, body: { ...body, cwd: path6.join(mount, relative) } };
+};
+function sendRelayError(socket, requestId, error) {
+  sendRelayMessage(socket, {
+    type: "error",
+    requestId,
+    error: error instanceof Error ? error.message : String(error),
+    ...error instanceof ConnectorRelayProtocolError ? { code: error.code } : {}
+  });
+}
+function sendRelayMessage(socket, message) {
+  if (socket.readyState !== WebSocket.OPEN) return;
+  socket.send(JSON.stringify(message));
+}
+function headersToRecord(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
 }
 function getHeaderValue(headers, name) {
   if (!headers) return void 0;
@@ -411,30 +2485,460 @@ function getHeaderValue(headers, name) {
   return void 0;
 }
 
-// src/runtime.ts
-async function runNewConnector(launchConfig) {
-  const config = buildDeviceConfig(launchConfig);
-  await writeDeviceConfig(config);
-  await registerConnector(config, launchConfig);
-  await writeLog("info", `wrote ${CONFIG_PATH}`);
-  await writeLog("info", `workdir root ${config.workdirRoot}`);
-  await writeLog("info", `log file ${LOG_PATH}`);
+// src/workdir-layout.ts
+import { lstat as lstat3, mkdir as mkdir7, symlink as symlink3, unlink as unlink4 } from "fs/promises";
+import path7 from "path";
+async function provisionWorkdirLayout(workdirRoot) {
+  const manifest = await readBundledManifest();
+  await mkdir7(workdirRoot, { recursive: true });
+  await mkdir7(path7.join(workdirRoot, "system", ".agents"), { recursive: true });
+  const systemSkillsLink = path7.join(workdirRoot, "system", ".agents", "skills");
+  const systemScriptsLink = path7.join(workdirRoot, "system", "scripts");
+  await ensureSymlink(manifest.systemSkillsDir, systemSkillsLink);
+  await ensureSymlink(manifest.scriptsDir, systemScriptsLink);
+  await writeLog("info", "workdir layout provisioned", {
+    workdirRoot,
+    systemSkillsLink,
+    systemScriptsLink,
+    bundleVersion: manifest.version
+  });
+  return {
+    workdirRoot,
+    systemSkillsLink,
+    systemScriptsLink,
+    bundleVersion: manifest.version
+  };
 }
-async function runConnectorDaemon(launchConfig) {
-  const config = await ensureDeviceConfig(launchConfig);
-  const bunnyDaemon = await startEmbeddedBunnyDaemon(config, launchConfig);
+async function ensureSymlink(target, linkPath) {
   try {
-    await registerConnector(config, launchConfig, bunnyDaemon);
+    const existing = await lstat3(linkPath);
+    if (existing.isSymbolicLink()) {
+      await unlink4(linkPath);
+    } else if (existing.isDirectory()) {
+      await writeLog(
+        "warn",
+        `skipping symlink ${linkPath}: existing directory at path; remove it to enable bundle`
+      );
+      return;
+    } else {
+      await unlink4(linkPath);
+    }
+  } catch {
+  }
+  await mkdir7(path7.dirname(linkPath), { recursive: true });
+  await symlink3(target, linkPath, "dir");
+}
+
+// src/workspace-registry.ts
+import { constants as constants4 } from "fs";
+import {
+  chmod as chmod3,
+  lstat as lstat4,
+  mkdir as mkdir8,
+  open as open3,
+  readFile as readFile6,
+  realpath as realpath3,
+  rename as rename3,
+  statfs,
+  unlink as unlink5
+} from "fs/promises";
+import path8 from "path";
+var REGISTRY_VERSION = 1;
+var REGISTRY_DIRECTORY = ".buda";
+var REGISTRY_FILENAME = "workspace-registry.json";
+var IMMUTABLE_ID_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+var UNSAFE_FILESYSTEM_TYPES = /* @__PURE__ */ new Set([26985, 20859, 4283649346, 4266872130]);
+var WorkspaceRegistryError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WorkspaceRegistryError";
+  }
+  recoverable = true;
+};
+var LocalWorkspaceRegistry = class _LocalWorkspaceRegistry {
+  constructor(registryPath, storageRoot, document) {
+    this.registryPath = registryPath;
+    this.storageRoot = storageRoot;
+    this.document = document;
+  }
+  static async open(storageRoot) {
+    await mkdir8(storageRoot, { recursive: true, mode: 448 });
+    await rejectUnsafeFilesystem(storageRoot);
+    const canonicalRoot = await canonicalDirectory(storageRoot, "storage root");
+    const registryDirectory = path8.join(canonicalRoot, REGISTRY_DIRECTORY);
+    await ensurePrivateDirectory2(registryDirectory);
+    const registryPath = path8.join(registryDirectory, REGISTRY_FILENAME);
+    const document = await withExclusiveFileLock(registryPath, async () => {
+      let current;
+      try {
+        current = parseRegistry(await readFile6(registryPath, "utf8"));
+      } catch (error) {
+        if (isMissingFile2(error)) {
+          current = { version: REGISTRY_VERSION, storageRoot: canonicalRoot, workspaces: {} };
+          await writeRegistryAtomically(registryPath, current);
+        } else if (error instanceof WorkspaceRegistryError) {
+          throw error;
+        } else {
+          throw corrupt2(`Cannot read local workspace registry: ${errorMessage2(error)}`);
+        }
+      }
+      if (current.storageRoot !== canonicalRoot) {
+        throw corrupt2("Registry storage root does not match the selected storage root");
+      }
+      await chmod3(registryPath, 384);
+      await reconcileDocument(current, canonicalRoot);
+      return current;
+    });
+    await chmod3(registryPath, 384);
+    return new _LocalWorkspaceRegistry(registryPath, canonicalRoot, document);
+  }
+  async resolve(spaceId, agentId) {
+    validateImmutableId("spaceId", spaceId);
+    validateImmutableId("agentId", agentId);
+    return withExclusiveFileLock(this.registryPath, async () => {
+      const document = await readRegistryDocument(this.registryPath);
+      if (document.storageRoot !== this.storageRoot) {
+        throw corrupt2("Registry storage root does not match the selected storage root");
+      }
+      await reconcileDocument(document, this.storageRoot);
+      const expected = deriveWorkspace(this.storageRoot, spaceId, agentId);
+      const existing = document.workspaces[expected.workspaceKey];
+      if (existing) {
+        assertWorkspaceMatches(existing, expected);
+        await reconcileWorkspace(existing, this.storageRoot);
+        this.document = document;
+        return toDescriptor(existing);
+      }
+      assertNoCollision(document.workspaces, expected);
+      await Promise.all([
+        ensurePrivateDirectory2(expected.privateVolume),
+        ensurePrivateDirectory2(expected.sharedVolume),
+        ensurePrivateDirectory2(expected.stateVolume),
+        ensurePrivateDirectory2(expected.temporaryVolume)
+      ]);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const workspace = { ...expected, createdAt: now, verifiedAt: now };
+      document.workspaces[workspace.workspaceKey] = workspace;
+      await writeRegistryAtomically(this.registryPath, document);
+      this.document = document;
+      return toDescriptor(workspace);
+    });
+  }
+  sanitizedMetadata() {
+    return Object.values(this.document.workspaces).map((workspace) => ({
+      workspaceKey: workspace.workspaceKey,
+      spaceId: workspace.spaceId,
+      agentId: workspace.agentId,
+      isolationMode: "limited",
+      verifiedAt: workspace.verifiedAt
+    }));
+  }
+};
+var readRegistryDocument = async (registryPath) => {
+  try {
+    return parseRegistry(await readFile6(registryPath, "utf8"));
   } catch (error) {
-    await stopEmbeddedBunnyDaemon(bunnyDaemon);
+    if (error instanceof WorkspaceRegistryError) throw error;
+    throw corrupt2(`Cannot read local workspace registry: ${errorMessage2(error)}`);
+  }
+};
+var deriveWorkspace = (storageRoot, spaceId, agentId) => {
+  const spaceRoot = path8.join(storageRoot, REGISTRY_DIRECTORY, "spaces", spaceId);
+  const agentRoot = path8.join(spaceRoot, "agents", agentId);
+  return {
+    workspaceKey: `${spaceId}:${agentId}`,
+    spaceId,
+    agentId,
+    privateVolume: path8.join(agentRoot, "workspace"),
+    sharedVolume: path8.join(spaceRoot, "shared"),
+    stateVolume: path8.join(agentRoot, "state"),
+    temporaryVolume: path8.join(agentRoot, "tmp")
+  };
+};
+var parseRegistry = (raw) => {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw corrupt2("Local workspace registry contains invalid JSON");
+  }
+  if (!isRecord(value) || value.version !== REGISTRY_VERSION) {
+    throw corrupt2("Local workspace registry has an unsupported version");
+  }
+  if (typeof value.storageRoot !== "string" || !isRecord(value.workspaces)) {
+    throw corrupt2("Local workspace registry is missing required fields");
+  }
+  for (const workspace of Object.values(value.workspaces)) {
+    if (!isRegistryWorkspace(workspace)) {
+      throw corrupt2("Local workspace registry contains a malformed workspace entry");
+    }
+  }
+  return value;
+};
+var reconcileDocument = async (document, storageRoot) => {
+  const seenPrivateVolumes = /* @__PURE__ */ new Set();
+  for (const [key, workspace] of Object.entries(document.workspaces)) {
+    validateStoredId("spaceId", workspace.spaceId);
+    validateStoredId("agentId", workspace.agentId);
+    const expected = deriveWorkspace(storageRoot, workspace.spaceId, workspace.agentId);
+    if (key !== workspace.workspaceKey) throw corrupt2("Workspace registry key is inconsistent");
+    if (seenPrivateVolumes.has(workspace.privateVolume)) {
+      throw collision("Two Agents map to the same private workspace");
+    }
+    seenPrivateVolumes.add(workspace.privateVolume);
+    assertWorkspaceMatches(workspace, expected);
+    await reconcileWorkspace(workspace, storageRoot);
+  }
+};
+var reconcileWorkspace = async (workspace, storageRoot) => {
+  const volumes = [
+    workspace.privateVolume,
+    workspace.sharedVolume,
+    workspace.stateVolume,
+    workspace.temporaryVolume
+  ];
+  for (const volume of volumes) {
+    assertContained(storageRoot, volume);
+    await ensurePrivateDirectory2(volume);
+    const canonical = await realpath3(volume);
+    if (canonical !== volume) throw corrupt2("Workspace path resolves through a symbolic link");
+  }
+};
+var assertWorkspaceMatches = (actual, expected) => {
+  for (const field of [
+    "workspaceKey",
+    "spaceId",
+    "agentId",
+    "privateVolume",
+    "sharedVolume",
+    "stateVolume",
+    "temporaryVolume"
+  ]) {
+    if (actual[field] !== expected[field]) {
+      throw corrupt2(`Workspace registry ${field} does not match its canonical value`);
+    }
+  }
+};
+var assertNoCollision = (workspaces, candidate) => {
+  for (const existing of Object.values(workspaces)) {
+    if (existing.privateVolume === candidate.privateVolume) {
+      throw collision("Two Agents map to the same private workspace");
+    }
+    for (const left of [existing.privateVolume, existing.sharedVolume]) {
+      for (const right of [candidate.privateVolume, candidate.sharedVolume]) {
+        if (left !== right && (isPathInside2(left, right) || isPathInside2(right, left))) {
+          throw collision("Workspace mappings overlap");
+        }
+      }
+    }
+  }
+};
+var ensurePrivateDirectory2 = async (directory) => {
+  await mkdir8(directory, { recursive: true, mode: 448 });
+  const info = await lstat4(directory);
+  if (info.isSymbolicLink() || !info.isDirectory()) {
+    throw corrupt2("Workspace registry path is not a real directory");
+  }
+  await chmod3(directory, 448);
+};
+var canonicalDirectory = async (directory, label) => {
+  const info = await lstat4(directory);
+  if (info.isSymbolicLink() || !info.isDirectory()) {
+    throw new WorkspaceRegistryError("STORAGE_UNSAFE", `${label} must be a real directory`);
+  }
+  return realpath3(directory);
+};
+var rejectUnsafeFilesystem = async (storageRoot) => {
+  const stats = await statfs(storageRoot, { bigint: true });
+  const type = Number(stats.type);
+  if (UNSAFE_FILESYSTEM_TYPES.has(type)) {
+    throw new WorkspaceRegistryError(
+      "STORAGE_UNSAFE",
+      "Storage root uses a network filesystem that cannot guarantee workspace isolation"
+    );
+  }
+};
+var writeRegistryAtomically = async (registryPath, document) => {
+  const temporaryPath = `${registryPath}.${process.pid}.${Date.now()}.tmp`;
+  const handle = await open3(
+    temporaryPath,
+    constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY,
+    384
+  );
+  try {
+    await handle.writeFile(`${JSON.stringify(document, null, 2)}
+`, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await rename3(temporaryPath, registryPath);
+    await chmod3(registryPath, 384);
+  } catch (error) {
+    await unlink5(temporaryPath).catch(() => void 0);
     throw error;
   }
-  const relay = startConnectorRelay(config, bunnyDaemon, launchConfig);
+};
+var validateImmutableId = (label, value) => {
+  if (!IMMUTABLE_ID_PATTERN2.test(value)) {
+    throw new WorkspaceRegistryError(
+      "WORKSPACE_INVALID",
+      `${label} must contain only letters, numbers, underscores, or hyphens`
+    );
+  }
+};
+var validateStoredId = (label, value) => {
+  try {
+    validateImmutableId(label, value);
+  } catch (error) {
+    throw corrupt2(errorMessage2(error));
+  }
+};
+var assertContained = (root, candidate) => {
+  if (!isPathInside2(root, candidate)) throw corrupt2("Workspace path escapes the storage root");
+};
+var isPathInside2 = (parent, child) => {
+  const relative = path8.relative(parent, child);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
+};
+var toDescriptor = (workspace) => ({
+  workspaceKey: workspace.workspaceKey,
+  spaceId: workspace.spaceId,
+  agentId: workspace.agentId,
+  privateVolume: workspace.privateVolume,
+  sharedVolume: workspace.sharedVolume,
+  stateVolume: workspace.stateVolume,
+  temporaryVolume: workspace.temporaryVolume,
+  isolationMode: "limited"
+});
+var isRegistryWorkspace = (value) => isRecord(value) && [
+  "workspaceKey",
+  "spaceId",
+  "agentId",
+  "privateVolume",
+  "sharedVolume",
+  "stateVolume",
+  "temporaryVolume",
+  "createdAt",
+  "verifiedAt"
+].every((field) => typeof value[field] === "string");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isMissingFile2 = (error) => isRecord(error) && "code" in error && error.code === "ENOENT";
+var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var corrupt2 = (message) => new WorkspaceRegistryError("REGISTRY_CORRUPT", message);
+var collision = (message) => new WorkspaceRegistryError("WORKSPACE_COLLISION", message);
+
+// src/onboard.ts
+async function runOnboard(launchConfig) {
+  intro("Welcome to Buda Connector");
+  const existing = await readDeviceConfig(launchConfig);
+  let relayProtocol;
+  if (existing) {
+    log.info(`Already registered: ${existing.connectorId}`);
+    log.info(`Server: ${existing.serverUrl}`);
+    log.info(`Workdir: ${existing.workdirRoot}`);
+    log.step("Starting daemon with existing config...");
+  } else {
+    log.step("First-time setup");
+    const serverUrl = launchConfig?.serverUrl || await (async () => {
+      const answer = await text({
+        message: "Server URL",
+        placeholder: DEFAULT_SERVER_URL,
+        defaultValue: DEFAULT_SERVER_URL
+      });
+      if (isCancel(answer)) {
+        cancel("Setup cancelled.");
+        process.exit(0);
+      }
+      return answer;
+    })();
+    const oauthToken = launchConfig?.oauthToken || await (async () => {
+      const answer = await text({
+        message: "Auth token (from buda.im \u2192 Settings \u2192 Connectors)",
+        placeholder: "paste your token here",
+        validate: (value) => {
+          if (!value || !value.trim()) return "Token is required";
+        }
+      });
+      if (isCancel(answer)) {
+        cancel("Setup cancelled.");
+        process.exit(0);
+      }
+      return answer;
+    })();
+    launchConfig = { ...launchConfig, serverUrl, oauthToken };
+    const s2 = spinner();
+    s2.start("Registering connector...");
+    const config2 = await createDeviceConfig(launchConfig);
+    const paths2 = getConnectorPaths(config2.serverUrl);
+    await migrateLegacyWorkspaceRoot(config2.workdirRoot);
+    await provisionWorkdirLayout(config2.workdirRoot);
+    try {
+      const registration = await registerConnector(config2, launchConfig, void 0, {
+        recoverMissingProfile: true
+      });
+      config2.connectorId = registration.connectorId;
+      relayProtocol = registration.relayProtocol;
+      await writeDeviceConfig(config2);
+    } catch (error) {
+      s2.stop("Registration failed");
+      log.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+    s2.stop("Registered successfully");
+    note(
+      [
+        `Connector ID: ${config2.connectorId}`,
+        `Config: ${paths2.configPath}`,
+        `Workdir: ${config2.workdirRoot}`
+      ].join("\n"),
+      "Device info"
+    );
+  }
+  const config = await ensureDeviceConfig(launchConfig);
+  const paths = getConnectorPaths(config.serverUrl);
+  await migrateLegacyWorkspaceRoot(config.workdirRoot);
+  await provisionWorkdirLayout(config.workdirRoot);
+  const workspaceRegistry = await LocalWorkspaceRegistry.open(config.workdirRoot);
+  const s = spinner();
+  s.start("Starting daemon...");
+  const bunnyDaemon = await startEmbeddedBunnyDaemon(config, launchConfig);
+  if (!existing) {
+  } else {
+    try {
+      relayProtocol = (await registerConnector(config, launchConfig, bunnyDaemon)).relayProtocol;
+    } catch (error) {
+      await stopEmbeddedBunnyDaemon(bunnyDaemon);
+      s.stop("Failed to register");
+      log.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  const relay = startConnectorRelay(
+    config,
+    bunnyDaemon,
+    relayProtocol,
+    workspaceRegistry,
+    launchConfig
+  );
+  s.stop("Daemon running");
   await writeLog("info", `server ${config.serverUrl}`);
-  await writeLog("info", `config ${CONFIG_PATH}`);
+  await writeLog("info", `config ${paths.configPath}`);
   await writeLog("info", `workdir root ${config.workdirRoot}`);
-  await writeLog("info", `log file ${LOG_PATH}`);
   await writeLog("info", `bunny daemon ${bunnyDaemon.baseUrl}`);
+  await writeLog("info", `log file ${paths.logPath}`);
+  note(
+    [
+      `Server: ${config.serverUrl}`,
+      `Bunny daemon: ${bunnyDaemon.baseUrl}`,
+      `Relay: connected`,
+      `Logs: ${paths.logPath}`
+    ].join("\n"),
+    "Status"
+  );
+  outro("Buda Connector is running. Press Ctrl+C to stop.");
   const interval = setInterval(() => {
     heartbeatConnector(config, launchConfig, bunnyDaemon).catch((error) => {
       void writeLog(
@@ -454,10 +2958,117 @@ async function runConnectorDaemon(launchConfig) {
   process.on("SIGTERM", shutdown);
 }
 
+// src/runtime.ts
+import { mkdir as mkdir9 } from "fs/promises";
+import path9 from "path";
+async function runNewConnector(launchConfig) {
+  const existing = await readDeviceConfig(launchConfig);
+  const config = await ensureDeviceConfig(launchConfig);
+  const paths = getConnectorPaths(config.serverUrl);
+  await migrateLegacyWorkspaceRoot(config.workdirRoot);
+  await provisionWorkdirLayout(config.workdirRoot);
+  await LocalWorkspaceRegistry.open(config.workdirRoot);
+  const registration = await registerConnector(config, launchConfig, void 0, {
+    recoverMissingProfile: !existing
+  });
+  config.connectorId = registration.connectorId;
+  await writeDeviceConfig(config);
+  await writeLog("info", `wrote ${paths.configPath}`);
+  await writeLog("info", `workdir root ${config.workdirRoot}`);
+  await writeLog("info", `log file ${paths.logPath}`);
+}
+async function runConnectorDaemon(launchConfig) {
+  const existing = await readDeviceConfig(launchConfig);
+  const config = await ensureDeviceConfig(launchConfig);
+  const paths = getConnectorPaths(config.serverUrl);
+  const daemonLockTarget = getConnectorDaemonLockTarget(config.serverUrl, config.connectorId);
+  await mkdir9(path9.dirname(daemonLockTarget), { recursive: true, mode: 448 });
+  let daemonLock = await acquireExclusiveFileLock(daemonLockTarget, { timeoutMs: 0 }).catch(() => {
+    throw new Error(
+      `Another Buda Connector daemon is already running for this profile on ${config.serverUrl}. Stop it before starting another instance.`
+    );
+  });
+  let bunnyDaemon;
+  let relayProtocol;
+  try {
+    await migrateLegacyWorkspaceRoot(config.workdirRoot);
+    await provisionWorkdirLayout(config.workdirRoot);
+    const workspaceRegistry = await LocalWorkspaceRegistry.open(config.workdirRoot);
+    bunnyDaemon = await startEmbeddedBunnyDaemon(config, launchConfig);
+    const activeBunnyDaemon = bunnyDaemon;
+    const registration = await registerConnector(config, launchConfig, activeBunnyDaemon, {
+      recoverMissingProfile: !existing
+    });
+    const connectorIdChanged = config.connectorId !== registration.connectorId;
+    if (connectorIdChanged) {
+      const registeredLockTarget = getConnectorDaemonLockTarget(
+        config.serverUrl,
+        registration.connectorId
+      );
+      await mkdir9(path9.dirname(registeredLockTarget), { recursive: true, mode: 448 });
+      const registeredLock = await acquireExclusiveFileLock(registeredLockTarget, {
+        timeoutMs: 0
+      }).catch(() => {
+        throw new Error(
+          `Another Buda Connector daemon is already running for this profile on ${config.serverUrl}. Stop it before starting another instance.`
+        );
+      });
+      await daemonLock.release();
+      daemonLock = registeredLock;
+    }
+    config.connectorId = registration.connectorId;
+    relayProtocol = registration.relayProtocol;
+    if (!existing || connectorIdChanged) await writeDeviceConfig(config);
+    const relay = startConnectorRelay(
+      config,
+      activeBunnyDaemon,
+      relayProtocol,
+      workspaceRegistry,
+      launchConfig
+    );
+    await writeLog("info", `server ${config.serverUrl}`);
+    await writeLog("info", `config ${paths.configPath}`);
+    await writeLog("info", `workdir root ${config.workdirRoot}`);
+    await writeLog("info", `log file ${paths.logPath}`);
+    await writeLog("info", `bunny daemon ${activeBunnyDaemon.baseUrl}`);
+    const interval = setInterval(() => {
+      heartbeatConnector(config, launchConfig, activeBunnyDaemon).then(({ relayProtocol: nextRelayProtocol }) => {
+        relay.updateRelayProtocol(nextRelayProtocol);
+      }).catch((error) => {
+        void writeLog(
+          "warn",
+          `heartbeat failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }, HEARTBEAT_INTERVAL_MS);
+    let shuttingDown = false;
+    const shutdown = async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      clearInterval(interval);
+      relay.stop();
+      try {
+        await closeAllBrowserSessions();
+        await unregisterConnector(config, launchConfig);
+        await stopEmbeddedBunnyDaemon(activeBunnyDaemon);
+      } finally {
+        await daemonLock.release();
+        process.exit(0);
+      }
+    };
+    process.once("SIGINT", () => void shutdown());
+    process.once("SIGTERM", () => void shutdown());
+  } catch (error) {
+    if (bunnyDaemon) await stopEmbeddedBunnyDaemon(bunnyDaemon);
+    await daemonLock.release();
+    throw error;
+  }
+}
+
 // src/cli.ts
-function printUsage() {
+function printHelp() {
   console.log(
-    "Usage: buda-connector new | dev | daemon [--space-id <space>] [--server-url <url>] [--token <token>] [--workdir <path>] [--launch-config-stdin]\n       pnpm --filter @buda-ai/connector dev\n\nCommands:\n  new     Create/register a new connector identity\n  dev     Run the connector daemon in development\n  daemon  Run the connector daemon for sidecar/service usage"
+    "Help: buda-connector [onboard | new | dev | daemon] [--token <token>] [--server-url <url>] [--workdir <path>] [--launch-config-stdin]\n       pnpm --filter @buda-ai/connector dev\n\nCommands (default: onboard in TTY, daemon otherwise):\n  onboard  Interactive first-time setup + start daemon\n  new      Create/register a new connector identity\n  dev      Run the connector daemon in development\n  daemon   Run the connector daemon for sidecar/service usage"
   );
 }
 function readFlagValue(name) {
@@ -471,8 +3082,8 @@ function readCliLaunchConfig() {
   return {
     serverUrl: readFlagValue("--server-url"),
     workdirRoot: readFlagValue("--workdir"),
-    oauthToken: readFlagValue("--token"),
-    spaceId: readFlagValue("--space-id"),
+    oauthToken: readFlagValue("--oauth-token"),
+    token: readFlagValue("--token"),
     bunnyDaemonHost: readFlagValue("--bunny-daemon-host"),
     bunnyDaemonPort: bunnyDaemonPort && Number.isInteger(Number(bunnyDaemonPort)) ? Number(bunnyDaemonPort) : void 0
   };
@@ -509,21 +3120,34 @@ async function readLaunchConfig() {
   });
 }
 async function main() {
-  const command = process.argv[2];
-  if (!command || process.argv.includes("--help") || process.argv.includes("-h")) {
-    printUsage();
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    printHelp();
     return;
   }
+  const rawCommand = process.argv[2];
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+  const defaultCommand = isTTY ? "onboard" : "daemon";
+  const command = !rawCommand || rawCommand.startsWith("-") ? defaultCommand : rawCommand;
+  process.on("unhandledRejection", (reason) => {
+    console.error("[buda-connector] unhandledRejection:", reason);
+  });
+  process.on("uncaughtException", (error) => {
+    console.error("[buda-connector] uncaughtException:", error);
+  });
   const launchConfig = await readLaunchConfig();
   if (command === "new") {
     await runNewConnector(launchConfig);
     return;
   }
+  if (command === "onboard") {
+    await runOnboard(launchConfig);
+    return;
+  }
   if (command === "dev" || command === "daemon") {
     await runConnectorDaemon(launchConfig);
     return;
   }
-  printUsage();
+  printHelp();
   process.exit(1);
 }
 main().catch((error) => {