@buda-ai/connector 0.1.32 → 0.1.34

package/dist/cli.js

@@ -25,8 +25,8 @@ async function acquireExclusiveFileLock(targetPath, options = {}) {
     } catch (error) {
       if (!isAlreadyExists(error)) throw error;
       if (await shouldRecoverLock(lockPath, staleMs)) {
-        await unlink(lockPath).catch(() => void 0);
-        continue;
+        const recovered = await unlink(lockPath).then(() => true).catch(() => false);
+        if (recovered) continue;
       }
       if (Date.now() >= deadline) {
         throw new Error(`Timed out waiting for exclusive access to ${targetPath}`);
@@ -35,17 +35,23 @@ async function acquireExclusiveFileLock(targetPath, options = {}) {
       continue;
     }
     const ownerToken = randomUUID();
-    await handle.writeFile(
-      `${JSON.stringify({ pid: process.pid, ownerToken, createdAt: Date.now() })}
+    try {
+      await handle.writeFile(
+        `${JSON.stringify({ pid: process.pid, ownerToken, createdAt: Date.now() })}
 `
-    );
-    await handle.sync();
+      );
+      await handle.sync();
+    } catch (error) {
+      await handle.close().catch(() => void 0);
+      await unlink(lockPath).catch(() => void 0);
+      throw error;
+    }
+    await handle.close();
     let released = false;
     return {
       release: async () => {
         if (released) return;
         released = true;
-        await handle.close();
         const currentOwner = await readFile(lockPath, "utf8").then((raw) => JSON.parse(raw).ownerToken).catch(() => void 0);
         if (currentOwner === ownerToken) await unlink(lockPath).catch(() => void 0);
       }
@@ -98,8 +104,8 @@ var defaultDependencies = {
 };
 var readRawSystemId = (dependencies) => {
   if (dependencies.platform === "darwin") {
-    const output = dependencies.execFile("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
-    return output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)?.[1];
+    const output2 = dependencies.execFile("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"]);
+    return output2.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)?.[1];
   }
   if (dependencies.platform === "linux") {
     for (const filePath of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
@@ -112,13 +118,13 @@ var readRawSystemId = (dependencies) => {
     return void 0;
   }
   if (dependencies.platform === "win32") {
-    const output = dependencies.execFile("reg", [
+    const output2 = 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 output2.match(/MachineGuid\s+REG_SZ\s+([^\r\n]+)/i)?.[1];
   }
   return void 0;
 };
@@ -517,7 +523,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.32",
+  version: "0.1.34",
   private: false,
   type: "module",
   publishConfig: {
@@ -535,6 +541,7 @@ var package_default = {
     dev: "tsx src/cli.ts dev",
     daemon: "tsx src/cli.ts daemon",
     new: "tsx src/cli.ts new",
+    prepack: "tsup --silent",
     start: "node dist/cli.js daemon",
     build: "tsup",
     test: "vitest run",
@@ -543,7 +550,7 @@ var package_default = {
     "lint:err": "biome format . --write && biome check . --write --diagnostic-level=error"
   },
   dependencies: {
-    "@bunny-agent/daemon": "0.9.51",
+    "@bunny-agent/daemon": "0.9.60-beta.1",
     "@clack/prompts": "^1.0.0",
     "playwright-core": "^1.52.0",
     ws: "^8.21.0"
@@ -847,14 +854,14 @@ var openControllingTerminal = () => {
   try {
     inputFd = openSync(inputPath, "r");
     outputFd = openSync(outputPath, "w");
-    const input = new ReadStream(inputFd);
-    const output = new WriteStream(outputFd);
+    const input2 = new ReadStream(inputFd);
+    const output2 = new WriteStream(outputFd);
     return {
-      input,
-      output,
+      input: input2,
+      output: output2,
       close: () => {
-        input.destroy();
-        output.destroy();
+        input2.destroy();
+        output2.destroy();
       }
     };
   } catch {
@@ -1005,8 +1012,8 @@ var getConnectorSectionHeight = (state, height) => state.connectors.length ? Mat
   Math.max(4, state.connectors.length + 2),
   Math.max(4, Math.min(Math.floor(height / 3), height - 13))
 ) : 0;
-var parseDashboardMouseWheel = (input, state, size) => {
-  const event = input.split("\x1B[<").at(-1);
+var parseDashboardMouseWheel = (input2, state, size) => {
+  const event = input2.split("\x1B[<").at(-1);
   const match = event?.match(/^(64|65);\d+;(\d+)[Mm]/);
   if (!match) return void 0;
   const row = Number(match[2]);
@@ -1117,13 +1124,13 @@ var renderConnectors = (state, height, width) => {
   const range = state.connectors.length ? `${start + 1}-${start + visible.length}/${state.connectors.length}` : "0/0";
   const title = ` Connectors ${state.activeSection === "connectors" ? "[active]" : ""}`;
   const headerFill = Math.max(1, innerWidth - title.length - range.length);
-  const output = [
+  const output2 = [
     `${state.activeSection === "connectors" ? colors.reverse : ""}+${title}${"-".repeat(headerFill)}${range}+${colors.reset}`
   ];
   for (let index = 0; index < contentHeight; index += 1) {
     const connector = visible[index];
     if (!connector) {
-      output.push(`|${" ".repeat(innerWidth)}|`);
+      output2.push(`|${" ".repeat(innerWidth)}|`);
       continue;
     }
     const marker = connector.connectorId === state.selectedConnectorId ? ">" : " ";
@@ -1134,10 +1141,10 @@ var renderConnectors = (state, height, width) => {
     const serverWidth = Math.max(8, availableFieldWidth - connectorWidth - spaceWidth);
     const content = `${marker} ${statusText} ${truncate(connector.label ?? connector.connectorId, connectorWidth)} | ${truncate(connector.spaceId, spaceWidth)} | ${truncate(connector.serverUrl, serverWidth)}`;
     const color = connector.status === "Stopped" ? colors.dim : connector.status === "Online" ? colors.cyan : connector.status === "Connecting" || connector.status === "Stopping" ? colors.yellow : connector.status === "Error" || connector.status === "Unresponsive" ? colors.red : "";
-    output.push(`|${color}${truncate(content, innerWidth)}${colors.reset}|`);
+    output2.push(`|${color}${truncate(content, innerWidth)}${colors.reset}|`);
   }
-  output.push(`+${"-".repeat(innerWidth)}+`);
-  return output;
+  output2.push(`+${"-".repeat(innerWidth)}+`);
+  return output2;
 };
 var renderPane = (title, lines, height, width, active, scroll) => {
   const innerWidth = width - 2;
@@ -1147,22 +1154,22 @@ var renderPane = (title, lines, height, width, active, scroll) => {
   const headerSuffix = scroll === 0 ? "following" : `${scroll} lines behind`;
   const titleText = ` ${title} ${active ? "[active]" : ""}`;
   const headerFill = Math.max(1, innerWidth - titleText.length - headerSuffix.length);
-  const output = [
+  const output2 = [
     `${active ? colors.reverse : ""}+${titleText}${"-".repeat(headerFill)}${headerSuffix}+${colors.reset}`
   ];
   for (let index = 0; index < contentHeight; index += 1) {
     const line = visible[index];
     if (!line) {
-      output.push(`|${" ".repeat(innerWidth)}|`);
+      output2.push(`|${" ".repeat(innerWidth)}|`);
       continue;
     }
     const levelColor = line.level === "error" ? colors.red : line.level === "warn" ? colors.yellow : colors.dim;
     const count = line.count > 1 ? ` x${line.count}` : "";
     const content = `${line.time} ${line.level.toUpperCase().padEnd(5)} ${line.message}${count}`;
-    output.push(`|${levelColor}${truncate(content, innerWidth)}${colors.reset}|`);
+    output2.push(`|${levelColor}${truncate(content, innerWidth)}${colors.reset}|`);
   }
-  output.push(`+${"-".repeat(innerWidth)}+`);
-  return output;
+  output2.push(`+${"-".repeat(innerWidth)}+`);
+  return output2;
 };
 var renderFooter = (state, width) => {
   const managerKeys = state.connectors.length ? "Up/Down select | S stop | Esc exit | " : "";
@@ -1524,7 +1531,7 @@ var installConnectorConsoleCapture = () => {
     log: console.log,
     warn: console.warn
   };
-  const capture = (level, output) => (...args) => {
+  const capture = (level, output2) => (...args) => {
     const message = format2(...args);
     if (!message.startsWith("[buda-connector]")) {
       writes.push(
@@ -1539,7 +1546,7 @@ var installConnectorConsoleCapture = () => {
         })
       );
     }
-    output(...args);
+    output2(...args);
   };
   console.log = capture("info", original.log);
   console.warn = capture("warn", original.warn);
@@ -1817,7 +1824,7 @@ async function handleBrowserInput(sessionIdValue, body) {
   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(() => {
+  const input2 = s.inputQueue.catch(() => {
   }).then(async () => {
     switch (ev.type) {
       case "mouseMove":
@@ -1871,8 +1878,8 @@ async function handleBrowserInput(sessionIdValue, body) {
         throw new Error(`Unknown browser input event: ${String(ev.type)}`);
     }
   });
-  s.inputQueue = input;
-  await input;
+  s.inputQueue = input2;
+  await input2;
 }
 var getPageResult = async (s) => ({
   url: s.page.url(),
@@ -1902,16 +1909,16 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
   if (!sessionId)
     return jsonResponse(400, { ok: false, error: "valid browser session id required" });
   if (route === "start" && method === "POST") {
-    const input = body ?? {};
+    const input2 = body ?? {};
     const viewport = {
-      width: normalizeViewportDimension(input.width, 320, 2560, DEFAULT_VIEWPORT.width),
-      height: normalizeViewportDimension(input.height, 240, 2560, DEFAULT_VIEWPORT.height)
+      width: normalizeViewportDimension(input2.width, 320, 2560, DEFAULT_VIEWPORT.width),
+      height: normalizeViewportDimension(input2.height, 240, 2560, DEFAULT_VIEWPORT.height)
     };
     const s = await ensureSession(sessionId, viewport);
-    const clientId = normalizeSessionId(input.clientId);
+    const clientId = normalizeSessionId(input2.clientId);
     if (clientId) s.clientIds.add(clientId);
     await resizeBrowser(s, viewport);
-    const url = input.url?.trim() || "about:blank";
+    const url = input2.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()}`);
@@ -1922,8 +1929,8 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     return jsonResponse(200, { ok: true });
   }
   if (route === "release" && method === "POST") {
-    const input = body ?? {};
-    const clientId = normalizeSessionId(input.clientId);
+    const input2 = body ?? {};
+    const clientId = normalizeSessionId(input2.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 });
@@ -1933,13 +1940,13 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     return jsonResponse(200, { ok: true, closed: true });
   }
   if (route === "navigate" && method === "POST") {
-    const input = body ?? {};
-    const url = input.url?.trim();
+    const input2 = body ?? {};
+    const url = input2.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)
+      waitUntil: input2.waitUntil ?? "domcontentloaded",
+      timeout: normalizeTimeout(input2.timeoutMs, 3e4, 6e4)
     });
     return jsonResponse(200, {
       ok: true,
@@ -1949,14 +1956,14 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     });
   }
   if (route === "click" && method === "POST") {
-    const input = body ?? {};
-    const selector = input.selector?.trim();
+    const input2 = body ?? {};
+    const selector = input2.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";
+    const button = input2.button === "right" || input2.button === "middle" ? input2.button : "left";
     await s.page.locator(selector).click({
       button,
-      timeout: normalizeTimeout(input.timeoutMs, 1e4, 3e4)
+      timeout: normalizeTimeout(input2.timeoutMs, 1e4, 3e4)
     });
     await s.page.waitForLoadState("domcontentloaded", { timeout: 5e3 }).catch(() => {
     });
@@ -1968,14 +1975,14 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     });
   }
   if (route === "type" && method === "POST") {
-    const input = body ?? {};
-    const selector = input.selector?.trim();
+    const input2 = body ?? {};
+    const selector = input2.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) {
+    const text2 = typeof input2.text === "string" ? input2.text : String(input2.text ?? "");
+    const timeout = normalizeTimeout(input2.timeoutMs, 1e4, 3e4);
+    if (input2.clear !== false) {
       await locator.fill("", { timeout });
       await locator.fill(text2, { timeout });
     } else {
@@ -1989,12 +1996,12 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     });
   }
   if (route === "extract" && method === "POST") {
-    const input = body ?? {};
-    const selector = input.selector?.trim() || "body";
+    const input2 = body ?? {};
+    const selector = input2.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;
+    const maxChars = typeof input2.maxChars === "number" && Number.isFinite(input2.maxChars) ? Math.min(2e4, Math.max(500, Math.round(input2.maxChars))) : 8e3;
     return jsonResponse(200, {
       ok: true,
       action: "extract",
@@ -2003,13 +2010,13 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     });
   }
   if (route === "screenshot" && method === "POST") {
-    const input = body ?? {};
+    const input2 = body ?? {};
     const s = await ensureSession(sessionId);
-    const screenshotPath = resolveScreenshotPath(context.workdirRoot, input.file_path);
+    const screenshotPath = resolveScreenshotPath(context.workdirRoot, input2.file_path);
     await mkdir4(path4.dirname(screenshotPath.absolutePath), { recursive: true });
     await s.page.screenshot({
       path: screenshotPath.absolutePath,
-      fullPage: input.fullPage !== false
+      fullPage: input2.fullPage !== false
     });
     return jsonResponse(200, {
       ok: true,
@@ -2020,10 +2027,10 @@ async function handleBrowserRequest(requestPath, method, body, context = {}) {
     });
   }
   if (route === "resize" && method === "POST") {
-    const input = body ?? {};
+    const input2 = body ?? {};
     const viewport = {
-      width: normalizeViewportDimension(input.width, 320, 2560, DEFAULT_VIEWPORT.width),
-      height: normalizeViewportDimension(input.height, 240, 2560, DEFAULT_VIEWPORT.height)
+      width: normalizeViewportDimension(input2.width, 320, 2560, DEFAULT_VIEWPORT.width),
+      height: normalizeViewportDimension(input2.height, 240, 2560, DEFAULT_VIEWPORT.height)
     };
     const s = await ensureSession(sessionId);
     await resizeBrowser(s, viewport);
@@ -2208,6 +2215,13 @@ var ConnectorDeletedError = class extends Error {
     this.name = "ConnectorDeletedError";
   }
 };
+var ConnectorUnauthorizedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectorUnauthorizedError";
+  }
+};
+var UNREGISTER_TIMEOUT_MS = 3e3;
 async function resolveConnectorScope(deviceId, launchConfig) {
   const serverUrl = normalizeServerOrigin(getServerUrl(launchConfig));
   const headers = { "Content-Type": "application/json" };
@@ -2294,14 +2308,15 @@ function buildAuthHeaders(config, launchConfig) {
   if (config.deviceToken) headers["X-Buda-Connector-Device-Token"] = config.deviceToken;
   return headers;
 }
-async function postJson(serverUrl, pathname, body, config, launchConfig) {
+async function postJson(serverUrl, pathname, body, config, launchConfig, options = {}) {
   const response = await fetch(`${serverUrl}${pathname}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       ...buildAuthHeaders(config, launchConfig)
     },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    ...options.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}
   });
   if (!response.ok) {
     const text2 = await response.text().catch(() => "");
@@ -2321,6 +2336,9 @@ async function postJson(serverUrl, pathname, body, config, launchConfig) {
     if (errorCode === "connector_deleted") {
       throw new ConnectorDeletedError(errorMessage3 || "Connector no longer exists");
     }
+    if (response.status === 401) {
+      throw new ConnectorUnauthorizedError(errorMessage3 || "Connector authentication failed");
+    }
     throw new Error(`${pathname} failed: ${response.status} ${errorMessage3}`);
   }
   return await response.json();
@@ -2396,7 +2414,8 @@ async function unregisterConnector(config, launchConfig) {
       connectorId: config.connectorId
     },
     config,
-    launchConfig
+    launchConfig,
+    { timeoutMs: UNREGISTER_TIMEOUT_MS }
   ).catch((error) => {
     void writeLog("warn", `unregister failed: ${error instanceof Error ? error.message : error}`);
   });
@@ -2421,11 +2440,19 @@ import path6 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var RUNTIME_INSTALL_TIMEOUT_MS = 5 * 6e4;
+var WINDOWS_RENAME_RETRY_DELAYS_MS = [50, 100, 200, 400, 500, 500, 500, 500, 500];
 var MACOS_NODE_LIBRARY_PATTERN = /^libnode(?:\.\d+)*\.dylib$/;
 var getLoadedSharedObjects = () => {
   const report = process.report?.getReport();
   return Array.isArray(report?.sharedObjects) ? report.sharedObjects.filter((value) => typeof value === "string") : [];
 };
+var resolveBundledNodePlacement = (sourceRoot, sourceNode, pathApi = path6) => {
+  const relativeNode = pathApi.relative(sourceRoot, sourceNode);
+  return {
+    copyNode: relativeNode.startsWith("..") || pathApi.isAbsolute(relativeNode),
+    relativeNode
+  };
+};
 var copyNodeRuntime = async (sourceNode, destinationNode, options = {}) => {
   const resolvedSourceNode = await realpath(sourceNode);
   const sourceDirectory = path6.dirname(resolvedSourceNode);
@@ -2452,8 +2479,7 @@ var copyNodeRuntime = async (sourceNode, destinationNode, options = {}) => {
     }))
   )).flatMap(({ directory, entries }) => entries.map((entry) => ({ directory, entry })));
   const companionFiles = /* @__PURE__ */ new Map();
-  const loadedLibraries = options.loadedLibraries ?? getLoadedSharedObjects();
-  for (const library of loadedLibraries) {
+  for (const library of options.loadedLibraries ?? getLoadedSharedObjects()) {
     const name = path6.basename(library);
     if (MACOS_NODE_LIBRARY_PATTERN.test(name)) companionFiles.set(name, library);
   }
@@ -2471,7 +2497,44 @@ var copyNodeRuntime = async (sourceNode, destinationNode, options = {}) => {
     )
   );
 };
+var isWindowsRenameContention = (error) => error instanceof Error && "code" in error && ["EACCES", "EBUSY", "EPERM"].includes(String(error.code));
+var renameStagedRuntime = async (source, destination, options = {}) => {
+  const platform4 = options.platform ?? process.platform;
+  const renamePath = options.renamePath ?? rename4;
+  const wait4 = options.wait ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  const delays = platform4 === "win32" ? WINDOWS_RENAME_RETRY_DELAYS_MS : [];
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await renamePath(source, destination);
+      return;
+    } catch (error) {
+      const delay = delays[attempt];
+      if (delay === void 0 || !isWindowsRenameContention(error)) throw error;
+      await wait4(delay);
+    }
+  }
+};
 var exists = async (filePath) => access(filePath).then(() => true).catch(() => false);
+var resolveNpmInvocation = async (options = {}) => {
+  const platform4 = options.platform ?? process.platform;
+  if (platform4 !== "win32") return { argsPrefix: [], executable: "npm" };
+  const nodeExecutable = options.nodeExecutable ?? process.execPath;
+  const pathApi = options.pathApi ?? path6;
+  const pathExists = options.pathExists ?? exists;
+  const candidates = [
+    options.npmExecPath ?? process.env.npm_execpath,
+    pathApi.join(pathApi.dirname(nodeExecutable), "node_modules", "npm", "bin", "npm-cli.js")
+  ];
+  for (const candidate of candidates) {
+    if (!candidate || pathApi.basename(candidate).toLowerCase() !== "npm-cli.js") continue;
+    if (await pathExists(candidate)) {
+      return { argsPrefix: [candidate], executable: nodeExecutable };
+    }
+  }
+  throw new Error(
+    `Unable to locate npm-cli.js for the stable Connector runtime installation (node=${JSON.stringify(nodeExecutable)}, npm_execpath=${JSON.stringify(options.npmExecPath ?? process.env.npm_execpath ?? "")})`
+  );
+};
 var runtimeRoot = () => process.env.BUDA_CONNECTOR_RUNTIME_ROOT || path6.join(homedir3(), ".buda", "runtime");
 var runtimePlatformKey = `${process.platform}-${process.arch}-node${process.versions.modules}`;
 var versionDirectory = () => path6.join(runtimeRoot(), runtimePlatformKey, CONNECTOR_RUNTIME_VERSION);
@@ -2505,9 +2568,11 @@ var validateRuntime = async (runtime) => {
 };
 var installFromNpm = async (directory) => {
   await mkdir5(directory, { recursive: true, mode: 448 });
+  const npm = await resolveNpmInvocation();
   await execFileAsync(
-    process.platform === "win32" ? "npm.cmd" : "npm",
+    npm.executable,
     [
+      ...npm.argsPrefix,
       "install",
       "--ignore-scripts=false",
       "--no-audit",
@@ -2541,10 +2606,10 @@ var installFromBundledRuntime = async (directory, sourceRoot) => {
   if (relativeEntrypoint.startsWith("..") || path6.isAbsolute(relativeEntrypoint)) {
     throw new Error("Bundled Connector entrypoint must be inside its runtime root");
   }
-  const relativeNode = path6.relative(sourceRoot, sourceNode);
+  const { copyNode, relativeNode } = resolveBundledNodePlacement(sourceRoot, sourceNode);
   const entrypoint = path6.join(directory, relativeEntrypoint);
-  const nodeExecutable = relativeNode.startsWith("..") ? path6.join(directory, "node", path6.basename(sourceNode)) : path6.join(directory, relativeNode);
-  if (relativeNode.startsWith("..")) {
+  const nodeExecutable = copyNode ? path6.join(directory, "node", path6.basename(sourceNode)) : path6.join(directory, relativeNode);
+  if (copyNode) {
     await copyNodeRuntime(sourceNode, nodeExecutable);
   }
   if (!await exists(entrypoint))
@@ -2591,7 +2656,7 @@ async function ensureStableConnectorRuntime() {
         };
         await writeManifest(temporary, rebased);
         await rm(finalDirectory, { recursive: true, force: true });
-        await rename4(temporary, finalDirectory);
+        await renameStagedRuntime(temporary, finalDirectory);
         return rebased;
       } catch (error) {
         await rm(temporary, { recursive: true, force: true });
@@ -2605,6 +2670,8 @@ async function ensureStableConnectorRuntime() {
 // src/daemon-client.ts
 var START_TIMEOUT_MS = 45e3;
 var BOOTSTRAP_TIMEOUT_MS = 5 * 6e4;
+var GRACEFUL_STOP_TIMEOUT_MS = 3e3;
+var LOCK_ONLY_RECOVERY_MAX_AGE_MS = 5 * 6e4;
 var POLL_INTERVAL_MS = 250;
 var wait2 = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 var getConfigRoot = () => process.env.BUDA_CONNECTOR_CONFIG_ROOT;
@@ -2637,14 +2704,78 @@ var compareVersions = (left, right) => {
   return 0;
 };
 var shouldReplaceDaemonVersion = (runningVersion, candidateVersion) => compareVersions(candidateVersion, runningVersion) > 0;
+var shouldDisplayConnectorLogEntry = (createdAt, startedAt) => {
+  const timestamp = Date.parse(createdAt);
+  return Number.isNaN(timestamp) || timestamp >= startedAt;
+};
+var getErrorCode = (error) => typeof error === "object" && error !== null && "code" in error ? String(error.code) : "UNKNOWN";
+var waitForChildSpawn = (child) => new Promise((resolve, reject) => {
+  const onError = (error) => {
+    child.off("spawn", onSpawn);
+    reject(error);
+  };
+  const onSpawn = () => {
+    child.off("error", onError);
+    resolve();
+  };
+  child.once("error", onError);
+  child.once("spawn", onSpawn);
+});
+async function spawnDetachedDaemonProcess(command, args, options, dependencies = {}) {
+  const platform4 = dependencies.platform ?? process.platform;
+  const spawnProcess = dependencies.spawnProcess ?? ((file, fileArgs, spawnOptions) => spawn(file, fileArgs, spawnOptions));
+  const strategies = platform4 === "win32" ? [
+    { name: "detached-hidden", windowsHide: true },
+    { name: "detached-unhidden", windowsHide: false }
+  ] : [{ name: "detached-hidden", windowsHide: true }];
+  const attempted = [];
+  for (const [index, strategy] of strategies.entries()) {
+    attempted.push(strategy.name);
+    const child = spawnProcess(command, args, {
+      detached: true,
+      env: options.env,
+      stdio: options.stdio,
+      windowsHide: strategy.windowsHide
+    });
+    try {
+      await waitForChildSpawn(child);
+      if (!child.pid) {
+        throw Object.assign(new Error("spawned Connector daemon did not expose a PID"), {
+          code: "NO_PID"
+        });
+      }
+      child.unref();
+      return { pid: child.pid, strategy: strategy.name };
+    } catch (error) {
+      const code = getErrorCode(error);
+      const shouldRetry = platform4 === "win32" && index === 0 && code === "EINVAL";
+      if (shouldRetry) continue;
+      const diagnostics = [
+        `code=${code}`,
+        `strategies=${attempted.join(",")}`,
+        `platform=${platform4}`,
+        `node=${dependencies.nodeVersion ?? process.version}`,
+        `executable=${JSON.stringify(command)}`,
+        `entrypoint=${JSON.stringify(args[0] ?? "")}`,
+        `cwd=${JSON.stringify(dependencies.cwd ?? process.cwd())}`
+      ].join(" ");
+      throw new Error(`Connector daemon process creation failed: ${diagnostics}`, { cause: error });
+    }
+  }
+  throw new Error("Connector daemon process creation failed without a spawn attempt");
+}
+var readReadyDaemon = async (launchConfig) => {
+  const config = await readDeviceConfig(launchConfig, getConfigRoot());
+  if (!config) return null;
+  const status = await readLiveStatus(config);
+  return status ? { config, status } : null;
+};
 var waitForDaemon = async (launchConfig, deadline) => {
   let lastConfig = null;
   while (Date.now() < deadline) {
+    const ready = await readReadyDaemon(launchConfig);
+    if (ready) return ready;
     lastConfig = await readDeviceConfig(launchConfig, getConfigRoot());
-    if (lastConfig) {
-      const status = await readLiveStatus(lastConfig);
-      if (status) return { config: lastConfig, status };
-    }
     await wait2(POLL_INTERVAL_MS);
   }
   throw new Error(
@@ -2653,17 +2784,126 @@ var waitForDaemon = async (launchConfig, deadline) => {
 };
 var spawnInternalDaemon = async (launchConfig, mode, preparedRuntime, options = {}) => {
   const runtime = preparedRuntime ?? await ensureStableConnectorRuntime();
-  const child = spawn(runtime.nodeExecutable, getRuntimeCommandArgs(runtime, mode, options), {
-    detached: true,
-    env: {
-      ...process.env,
-      BUDA_CONNECTOR_INTERNAL_LAUNCH_CONFIG: JSON.stringify(launchConfig ?? {})
-    },
-    stdio: "ignore",
-    windowsHide: true
-  });
-  child.unref();
+  const debugDaemonStdio = process.env.BUDA_CONNECTOR_DEBUG_DAEMON_STDIO === "1";
+  return spawnDetachedDaemonProcess(
+    runtime.nodeExecutable,
+    getRuntimeCommandArgs(runtime, mode, options),
+    {
+      env: {
+        ...process.env,
+        BUDA_CONNECTOR_INTERNAL_LAUNCH_CONFIG: JSON.stringify(launchConfig ?? {})
+      },
+      stdio: debugDaemonStdio ? ["ignore", "inherit", "inherit"] : "ignore"
+    }
+  );
+};
+var waitForProcessExit = async (pid, timeoutMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive2(pid)) return true;
+    await wait2(50);
+  }
+  return !isProcessAlive2(pid);
+};
+var signalProcess = (pid, signal) => {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH") {
+      return false;
+    }
+    throw error;
+  }
+};
+var stopUnresponsiveDaemonProcess = async (pid) => {
+  if (!isProcessAlive2(pid)) return;
+  if (!signalProcess(pid, "SIGTERM")) return;
+  if (await waitForProcessExit(pid, 2e3)) return;
+  if (!signalProcess(pid, "SIGKILL")) return;
+  if (await waitForProcessExit(pid, 3e3)) return;
+  throw new Error(`Timed-out Connector daemon PID ${pid} could not be stopped safely`);
+};
+var waitForDaemonRelease = async (config, status, configRoot = getConfigRoot()) => {
+  const deadline = Date.now() + GRACEFUL_STOP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive2(status.pid)) return true;
+    const current = await readPersistedDaemonStatus(config, configRoot).catch(() => null);
+    if (!current || current.pid !== status.pid || current.instanceId !== status.instanceId) {
+      return true;
+    }
+    await wait2(50);
+  }
+  return !isProcessAlive2(status.pid);
 };
+var stopLiveDaemon = async (config, status, configRoot = getConfigRoot(), command = "stop") => {
+  const stopStatus = await requestDaemonControl(config, command, configRoot);
+  if (command === "stop-if-idle" && !stopStatus.idle) return false;
+  if (await waitForDaemonRelease(config, status, configRoot)) return true;
+  const current = await readPersistedDaemonStatus(config, configRoot).catch(() => null);
+  if (!current || current.pid !== status.pid || current.instanceId !== status.instanceId) {
+    return true;
+  }
+  await stopUnresponsiveDaemonProcess(status.pid);
+  return true;
+};
+var matchesDaemonIdentity = (config, status) => status.connectorId === config.connectorId && normalizeServerOrigin(status.serverUrl) === normalizeServerOrigin(config.serverUrl) && Number.isSafeInteger(status.pid) && status.pid > 0 && typeof status.instanceId === "string" && status.instanceId.length > 0;
+var readMatchingPersistedDaemonStatus = async (config, configRoot = getConfigRoot()) => {
+  const status = await readPersistedDaemonStatus(config, configRoot).catch(() => null);
+  return status && matchesDaemonIdentity(config, status) ? status : null;
+};
+var stopDaemonForIdentity = async (config, configRoot = getConfigRoot()) => {
+  const liveStatus = await readLiveStatus(config, configRoot);
+  if (liveStatus) {
+    await stopLiveDaemon(config, liveStatus, configRoot);
+    return;
+  }
+  const persistedStatus = await readMatchingPersistedDaemonStatus(config, configRoot);
+  if (!persistedStatus || !isProcessAlive2(persistedStatus.pid)) return;
+  const currentStatus = await readMatchingPersistedDaemonStatus(config, configRoot);
+  if (!currentStatus || currentStatus.pid !== persistedStatus.pid || currentStatus.instanceId !== persistedStatus.instanceId || !isProcessAlive2(currentStatus.pid)) {
+    return;
+  }
+  await stopUnresponsiveDaemonProcess(currentStatus.pid);
+};
+var shouldRestartUnhealthyDaemonForEnrollment = (status, explicitEnrollment) => explicitEnrollment && status.idle && status.heartbeatHealthy === false;
+var readDaemonLockOwnerPid = async (config) => {
+  const lockPath = `${getConnectorDaemonLockTarget(
+    config.serverUrl,
+    config.connectorId,
+    getConfigRoot()
+  )}.lock`;
+  const raw = await readFile6(lockPath, "utf8").catch(() => "");
+  try {
+    const metadata = JSON.parse(raw);
+    const age = typeof metadata.createdAt === "number" && Number.isFinite(metadata.createdAt) ? Date.now() - metadata.createdAt : Number.POSITIVE_INFINITY;
+    return typeof metadata.pid === "number" && Number.isSafeInteger(metadata.pid) && metadata.pid > 0 && age >= 0 && age <= LOCK_ONLY_RECOVERY_MAX_AGE_MS ? metadata.pid : null;
+  } catch {
+    return null;
+  }
+};
+async function startDaemonWithRecovery(dependencies, maxAttempts = 2) {
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const spawned = await dependencies.spawnDaemon();
+    try {
+      return await dependencies.waitForReady();
+    } catch (error) {
+      lastError = error;
+      const lateReady = await dependencies.readReady().catch(() => null);
+      if (lateReady) return lateReady;
+      await dependencies.stopDaemon(spawned.pid);
+      if (attempt === maxAttempts) throw error;
+    }
+  }
+  throw lastError;
+}
+var startInternalDaemonWithRecovery = (launchConfig, mode, preparedRuntime, options = {}) => startDaemonWithRecovery({
+  readReady: () => readReadyDaemon(launchConfig),
+  spawnDaemon: () => spawnInternalDaemon(launchConfig, mode, preparedRuntime, options),
+  stopDaemon: stopUnresponsiveDaemonProcess,
+  waitForReady: () => waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS)
+});
 var stopOlderIdleDaemon = async (config, status) => {
   if (!shouldReplaceDaemonVersion(status.version, CONNECTOR_RUNTIME_VERSION)) return false;
   if (!status.idle) return false;
@@ -2690,14 +2930,19 @@ async function ensureConnectorDaemon(launchConfig, mode, options = {}) {
     if (existingConfig) {
       const existingStatus = await readLiveStatus(existingConfig);
       if (existingStatus) {
+        if (shouldRestartUnhealthyDaemonForEnrollment(
+          existingStatus,
+          Boolean(options.explicitEnrollment)
+        ) && await stopLiveDaemon(existingConfig, existingStatus, getConfigRoot(), "stop-if-idle")) {
+          return await startInternalDaemonWithRecovery(launchConfig, mode, void 0, options);
+        }
         const preparedRuntime = !shouldReplaceDaemonVersion(existingStatus.version, CONNECTOR_RUNTIME_VERSION) || !existingStatus.idle ? void 0 : await ensureStableConnectorRuntime();
         const replaced = await stopOlderIdleDaemon(existingConfig, existingStatus);
         if (!replaced) {
           const status = mode === "persistent" ? await requestDaemonControl(existingConfig, "persist", getConfigRoot()) : existingStatus;
           return { config: existingConfig, status };
         }
-        await spawnInternalDaemon(launchConfig, mode, preparedRuntime, options);
-        return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
+        return await startInternalDaemonWithRecovery(launchConfig, mode, preparedRuntime, options);
       }
       const persistedStatus = await readPersistedDaemonStatus(
         existingConfig,
@@ -2708,9 +2953,12 @@ async function ensureConnectorDaemon(launchConfig, mode, options = {}) {
           `Connector daemon PID ${persistedStatus.pid} is running but its local control channel is not responding. Stop that process and retry.`
         );
       }
+      const lockOwnerPid = await readDaemonLockOwnerPid(existingConfig);
+      if (lockOwnerPid && isProcessAlive2(lockOwnerPid)) {
+        await stopUnresponsiveDaemonProcess(lockOwnerPid);
+      }
     }
-    await spawnInternalDaemon(launchConfig, mode, void 0, options);
-    return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
+    return await startInternalDaemonWithRecovery(launchConfig, mode, void 0, options);
   } finally {
     await bootstrapLock.release();
   }
@@ -2730,17 +2978,18 @@ var streamDaemonLogs = (options) => {
     for (const line of lines.slice(seenLines)) {
       try {
         const entry = JSON.parse(line);
+        if (!shouldDisplayConnectorLogEntry(entry.createdAt, options.startedAt)) continue;
         const connectorId = entry.metadata?.connectorId;
         if (options.dashboardActive && typeof connectorId === "string") {
-          const output2 = entry.metadata?.source === "daemon-console" ? entry.message : `[buda-connector] ${entry.message}`;
-          appendConnectorDashboardLog(connectorId, entry.level, output2);
+          const output3 = entry.metadata?.source === "daemon-console" ? entry.message : `[buda-connector] ${entry.message}`;
+          appendConnectorDashboardLog(connectorId, entry.level, output3);
           continue;
         }
         if (connectorId !== options.connectorId) continue;
-        const output = entry.metadata?.source === "daemon-console" ? entry.message : `[buda-connector] ${entry.message}`;
-        if (entry.level === "error") console.error(output);
-        else if (entry.level === "warn") console.warn(output);
-        else console.log(output);
+        const output2 = entry.metadata?.source === "daemon-console" ? entry.message : `[buda-connector] ${entry.message}`;
+        if (entry.level === "error") console.error(output2);
+        else if (entry.level === "warn") console.warn(output2);
+        else console.log(output2);
       } catch {
         if (options.plain) console.log(line);
       }
@@ -2805,9 +3054,7 @@ async function stopLocalConnectorDaemon(connectorId, serverUrl, configRoot = get
     (candidate) => candidate.connectorId === connectorId && normalizeServerOrigin(candidate.serverUrl) === serverOrigin
   );
   if (!config) throw new Error(`Local Connector ${connectorId} was not found`);
-  const status = await readLiveStatus(config, configRoot);
-  if (!status) return;
-  await requestDaemonControl(config, "stop", configRoot);
+  await stopDaemonForIdentity(config, configRoot);
 }
 async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
   const configs = await listDeviceConfigs(configRoot);
@@ -2818,10 +3065,7 @@ async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
 ${config.connectorId}`, config);
   }
   const results = await Promise.allSettled(
-    [...identities.values()].map(async (config) => {
-      const status = await readLiveStatus(config, configRoot);
-      if (status) await requestDaemonControl(config, "stop", configRoot);
-    })
+    [...identities.values()].map((config) => stopDaemonForIdentity(config, configRoot))
   );
   const failures = results.filter((result) => result.status === "rejected");
   if (failures.length) {
@@ -2840,6 +3084,7 @@ var waitForConnectorViewerExit = async (dashboardClosed) => {
   process.off("SIGTERM", finishSignal);
 };
 async function runConnectorDashboard(launchConfig, options = {}) {
+  const startedAt = Date.now();
   let finishDashboard = () => void 0;
   const dashboardClosed = new Promise((resolve) => {
     finishDashboard = resolve;
@@ -2860,7 +3105,8 @@ async function runConnectorDashboard(launchConfig, options = {}) {
       connectorId: config.connectorId,
       dashboardActive: false,
       plain: Boolean(options.plain),
-      serverUrl: config.serverUrl
+      serverUrl: config.serverUrl,
+      startedAt
     });
     if (!process.stdin.isTTY) {
       stopLogs2();
@@ -2887,7 +3133,8 @@ async function runConnectorDashboard(launchConfig, options = {}) {
   const stopLogs = streamDaemonLogs({
     dashboardActive: true,
     plain: false,
-    serverUrl: getServerUrl(launchConfig)
+    serverUrl: getServerUrl(launchConfig),
+    startedAt
   });
   let refreshing = false;
   const refresh = async () => {
@@ -2983,9 +3230,6 @@ var getDaemonModeFlag = () => {
   return process.argv[index + 1] === "transient" ? "transient" : "persistent";
 };
 
-// src/onboard.ts
-import { cancel, intro, isCancel, log, note, outro, spinner, text } from "@clack/prompts";
-
 // src/bunny-daemon.ts
 import { mkdir as mkdir7 } from "fs/promises";
 import { createDaemon } from "@bunny-agent/daemon";
@@ -3224,17 +3468,17 @@ var installConnectorTerminalEndpoint = (server, options = {}) => {
     sessions2.clear();
   });
 };
-var registerLocalTerminal = (input) => {
-  if (!isSafeId(input.workspaceKey) || !isSafeId(input.tabId)) {
+var registerLocalTerminal = (input2) => {
+  if (!isSafeId(input2.workspaceKey) || !isSafeId(input2.tabId)) {
     throw new Error("Invalid local terminal workspace session.");
   }
   const token = randomBytes3(32).toString("base64url");
   localGrants.set(token, {
-    sessionKey: `${input.workspaceKey}:${input.tabId}`,
-    workspaceKey: input.workspaceKey,
-    cwd: input.cwd,
-    cols: input.cols,
-    rows: input.rows,
+    sessionKey: `${input2.workspaceKey}:${input2.tabId}`,
+    workspaceKey: input2.workspaceKey,
+    cwd: input2.cwd,
+    cols: input2.cols,
+    rows: input2.rows,
     expiresAt: Date.now() + LOCAL_TERMINAL_GRANT_TTL_MS
   });
   const cleanupTimer = setTimeout(() => localGrants.delete(token), LOCAL_TERMINAL_GRANT_TTL_MS);
@@ -3258,16 +3502,16 @@ var connectSocket = async (socket) => new Promise((resolve, reject) => {
   socket.once("open", onOpen);
   socket.once("error", onError);
 });
-var proxyConnectorTerminalTunnel = async (input) => {
+var proxyConnectorTerminalTunnel = async (input2) => {
   const cloud = new WebSocket(
-    getConnectorTerminalUrl(input.serverUrl, input.connectorId, input.sessionId),
+    getConnectorTerminalUrl(input2.serverUrl, input2.connectorId, input2.sessionId),
     {
-      headers: { "X-Buda-Terminal-Token": input.cloudToken },
+      headers: { "X-Buda-Terminal-Token": input2.cloudToken },
       handshakeTimeout: TERMINAL_HANDSHAKE_TIMEOUT_MS
     }
   );
-  const local = new WebSocket(toLocalTerminalUrl(input.localBaseUrl), {
-    headers: { "X-Buda-Local-Terminal-Token": input.localToken },
+  const local = new WebSocket(toLocalTerminalUrl(input2.localBaseUrl), {
+    headers: { "X-Buda-Local-Terminal-Token": input2.localToken },
     handshakeTimeout: TERMINAL_HANDSHAKE_TIMEOUT_MS
   });
   let bridgeAccepted = false;
@@ -3278,7 +3522,7 @@ var proxyConnectorTerminalTunnel = async (input) => {
   const endActivity = () => {
     if (!activityStarted || activityEnded) return;
     activityEnded = true;
-    input.onActivityEnd?.();
+    input2.onActivityEnd?.();
   };
   let pendingBytes = 0;
   const pendingCloudFrames = [];
@@ -3334,7 +3578,7 @@ var proxyConnectorTerminalTunnel = async (input) => {
     if (!bridgeAccepted) {
       void writeLog(
         "warn",
-        `terminal cloud tunnel closed before readiness session=${input.sessionId} code=${code} reason=${normalizedReason}`
+        `terminal cloud tunnel closed before readiness session=${input2.sessionId} code=${code} reason=${normalizedReason}`
       );
     }
     if (local.readyState === WebSocket.OPEN) {
@@ -3372,12 +3616,12 @@ var proxyConnectorTerminalTunnel = async (input) => {
   if (cloud.readyState !== WebSocket.OPEN) return;
   if (local.readyState === WebSocket.OPEN) {
     activityStarted = true;
-    input.onActivityStart?.();
+    input2.onActivityStart?.();
   }
   cloud.send(JSON.stringify({ type: "bridge-ready" }));
   await writeLog(
     "info",
-    `terminal proxy connected session=${input.sessionId} workspace=${input.workspaceKey}`
+    `terminal proxy connected session=${input2.sessionId} workspace=${input2.workspaceKey}`
   );
 };
 
@@ -3783,6 +4027,7 @@ var writeJournal = async (journalPath, journal) => {
   }
 };
 var syncDirectory2 = async (directory) => {
+  if (process.platform === "win32") return;
   const handle = await open2(directory, constants2.O_RDONLY);
   try {
     await handle.sync();
@@ -3960,6 +4205,86 @@ var verifyFailure = (detail) => new LegacyWorkspaceMigrationError(
 var corrupt = (message) => new LegacyWorkspaceMigrationError("MIGRATION_CORRUPT", message);
 var errorMessage = (error) => error instanceof Error ? error.message : String(error);
 
+// src/prompts.ts
+import { stdin as input, stdout as output } from "process";
+import { createInterface } from "readline/promises";
+var CANCELLED = /* @__PURE__ */ Symbol("prompt-cancelled");
+function printLine(prefix, message) {
+  output.write(`${prefix}${message}
+`);
+}
+function intro(message) {
+  printLine("\n", message);
+}
+function outro(message) {
+  printLine("", message);
+}
+function cancel(message) {
+  printLine("", message);
+}
+function note(message, title) {
+  if (title) {
+    printLine("", `${title}
+${message}`);
+    return;
+  }
+  printLine("", message);
+}
+var log = {
+  info(message) {
+    printLine("", message);
+  },
+  error(message) {
+    printLine("", message);
+  },
+  step(message) {
+    printLine("", message);
+  }
+};
+function isCancel(value) {
+  return value === CANCELLED;
+}
+function spinner() {
+  let activeMessage = null;
+  return {
+    start(message) {
+      activeMessage = message;
+      printLine("", message);
+    },
+    stop(message) {
+      if (message) {
+        printLine("", message);
+      } else if (activeMessage) {
+        printLine("", activeMessage);
+      }
+      activeMessage = null;
+    }
+  };
+}
+async function text(options) {
+  if (!input.isTTY || !output.isTTY) {
+    const fallback = options.defaultValue ?? "";
+    const validationError = options.validate?.(fallback);
+    return validationError ? CANCELLED : fallback;
+  }
+  const rl = createInterface({ input, output });
+  const hint = options.defaultValue ?? options.placeholder;
+  const suffix = hint ? ` (${hint})` : "";
+  try {
+    while (true) {
+      const answer = await rl.question(`${options.message}${suffix}: `);
+      const value = answer.trim() || options.defaultValue || "";
+      const validationError = options.validate?.(value);
+      if (!validationError) return value;
+      printLine("", validationError);
+    }
+  } catch {
+    return CANCELLED;
+  } finally {
+    rl.close();
+  }
+}
+
 // src/relay.ts
 import { realpathSync } from "fs";
 import path12 from "path";
@@ -4050,7 +4375,10 @@ function verifyConnectorExecutionIdentity(options) {
   const signature = decodeSignature(identity.signature);
   let verified = false;
   try {
-    const publicKey = createPublicKey({ key: protocol.publicKeyJwk, format: "jwk" });
+    const publicKey = createPublicKey({
+      key: protocol.publicKeyJwk,
+      format: "jwk"
+    });
     if (publicKey.asymmetricKeyType !== "ed25519") {
       throw new ConnectorRelayProtocolError("PROTOCOL_UNSUPPORTED");
     }
@@ -4157,8 +4485,8 @@ var MIME_TYPES = {
 };
 var HtmlPreviewServerRegistry = class {
   servers = /* @__PURE__ */ new Map();
-  async open(input) {
-    const htmlFile = await resolveWorkspaceFile(input);
+  async open(input2) {
+    const htmlFile = await resolveWorkspaceFile(input2);
     const folder = path10.dirname(htmlFile);
     let pending = this.servers.get(folder);
     if (!pending) {
@@ -4216,10 +4544,10 @@ var handleHtmlPreviewRequest = async (request, mounts, registry) => {
     );
   }
 };
-var resolveWorkspaceFile = async (input) => {
-  const virtualPath = input.filePath.replaceAll("\\", "/");
+var resolveWorkspaceFile = async (input2) => {
+  const virtualPath = input2.filePath.replaceAll("\\", "/");
   if (virtualPath.includes("\0")) throw new Error("HTML preview path contains invalid data.");
-  const mountPath = path10.resolve(input.mounts[input.rootVolume]);
+  const mountPath = path10.resolve(input2.mounts[input2.rootVolume]);
   const root = await realpath3(mountPath);
   let relativePath = virtualPath;
   let explicitVolume;
@@ -4231,7 +4559,7 @@ var resolveWorkspaceFile = async (input) => {
       break;
     }
   }
-  if (explicitVolume && explicitVolume !== input.rootVolume) {
+  if (explicitVolume && explicitVolume !== input2.rootVolume) {
     throw new Error("HTML preview path does not match the requested root volume.");
   }
   if (!explicitVolume && (path10.isAbsolute(virtualPath) || /^[A-Za-z]:\//.test(virtualPath))) {
@@ -4356,6 +4684,11 @@ import {
   writeFile as writeFile4
 } from "fs/promises";
 import path11 from "path";
+
+// src/directory-link.ts
+var directoryLinkType = (platform4 = process.platform) => platform4 === "win32" ? "junction" : "dir";
+
+// src/workspace-volume-lifecycle.ts
 var MOUNT_DIRECTORY = "mount";
 var ARCHIVE_MARKER = "archived.json";
 var AGENT_CONTEXT_TEMPLATE_FILES = [
@@ -4507,7 +4840,7 @@ var ensureVolumeLink = async (target, linkPath) => {
   } catch (error) {
     if (!isMissingFile(error)) throw error;
     try {
-      await symlink2(target, linkPath, "dir");
+      await symlink2(target, linkPath, directoryLinkType());
     } catch (createError) {
       if (!isAlreadyExists3(createError)) throw createError;
       const info = await lstat2(linkPath);
@@ -4522,6 +4855,7 @@ var isAlreadyExists3 = (error) => error instanceof Error && "code" in error && e
 // src/relay.ts
 var RELAY_PING_INTERVAL_MS = 2e4;
 var RELAY_PONG_TIMEOUT_MS = 1e4;
+var RELAY_ACTIVE_REQUEST_PONG_TIMEOUT_LIMIT = 2;
 var RELAY_HANDSHAKE_TIMEOUT_MS = 1e4;
 var RELAY_RECONNECT_MAX_MS = 3e4;
 var RELAY_RECONNECT_JITTER = 0.2;
@@ -4627,6 +4961,7 @@ function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegist
     socket = ws;
     const inflight = /* @__PURE__ */ new Map();
     currentInflight = inflight;
+    let consecutivePongTimeouts = 0;
     let detached = false;
     const detach = () => {
       if (detached) return;
@@ -4639,6 +4974,7 @@ function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegist
       void writeLog("info", `relay connected ${relayUrl}`);
       hadOpenConnection = true;
       reconnectDelayMs = RELAY_RECONNECT_INTERVAL_MS;
+      consecutivePongTimeouts = 0;
       pingTimer = setInterval(() => {
         if (ws.readyState !== WebSocket2.OPEN) return;
         try {
@@ -4650,18 +4986,33 @@ function startConnectorRelay(config, bunnyDaemon, relayProtocol, workspaceRegist
         }
         if (pongTimer) clearTimeout(pongTimer);
         pongTimer = setTimeout(() => {
+          pongTimer = null;
+          consecutivePongTimeouts += 1;
+          if (inflight.size > 0 && consecutivePongTimeouts < RELAY_ACTIVE_REQUEST_PONG_TIMEOUT_LIMIT) {
+            void writeLog(
+              "warn",
+              `relay pong timeout deferred while ${inflight.size} request(s) are active`
+            );
+            return;
+          }
           void writeLog("warn", "relay pong timeout, terminating");
           ws.terminate();
         }, RELAY_PONG_TIMEOUT_MS);
       }, RELAY_PING_INTERVAL_MS);
     });
     ws.on("pong", () => {
+      consecutivePongTimeouts = 0;
       if (pongTimer) {
         clearTimeout(pongTimer);
         pongTimer = null;
       }
     });
     ws.on("message", (raw) => {
+      consecutivePongTimeouts = 0;
+      if (pongTimer) {
+        clearTimeout(pongTimer);
+        pongTimer = null;
+      }
       void handleRelayMessage(
         ws,
         bunnyDaemon,
@@ -4837,7 +5188,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
       });
       executionIdentity = message.executionIdentity;
     } catch (error) {
-      sendRelayError(socket, message.requestId, error);
+      await sendRelayError(socket, message.requestId, error).catch(() => void 0);
       return;
     }
   }
@@ -4923,7 +5274,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         durationMs: Date.now() - codingRunStartedAt
       });
     }
-    sendRelayMessage(socket, {
+    await sendRelayMessage(socket, {
       type: "start",
       requestId: message.requestId,
       status: response.status,
@@ -4943,7 +5294,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         while (true) {
           const { value, done } = await reader.read();
           if (done) break;
-          sendRelayMessage(socket, {
+          await sendRelayMessage(socket, {
             type: "chunk",
             requestId: message.requestId,
             data: binaryResponse ? Buffer.from(value).toString("base64") : decoder?.decode(value, { stream: true }) ?? "",
@@ -4952,7 +5303,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         }
         const tail = decoder?.decode() ?? "";
         if (tail) {
-          sendRelayMessage(socket, {
+          await sendRelayMessage(socket, {
             type: "chunk",
             requestId: message.requestId,
             data: tail
@@ -4963,7 +5314,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         reader.releaseLock();
       }
     }
-    sendRelayMessage(socket, {
+    await sendRelayMessage(socket, {
       type: "end",
       requestId: message.requestId
     });
@@ -4975,14 +5326,16 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
       });
     }
   } catch (error) {
+    controller.abort();
     if (codingRunTrace && codingRunStartedAt !== void 0) {
       await writeLog("error", "relay request coding run error", {
         ...codingRunTrace,
         status: codingRunStatus,
-        durationMs: Date.now() - codingRunStartedAt
+        durationMs: Date.now() - codingRunStartedAt,
+        error: formatConnectorRelayError(error)
       });
     }
-    sendRelayError(socket, message.requestId, error);
+    await sendRelayError(socket, message.requestId, error).catch(() => void 0);
   } finally {
     inflight.delete(message.requestId);
   }
@@ -5036,17 +5389,20 @@ var normalizeWorkspaceRequest = (request, mounts) => {
   if (!mount || relative === void 0) {
     throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
   }
-  const env = body.env && typeof body.env === "object" && !Array.isArray(body.env) ? body.env : {};
+  const systemEnv = body.systemEnv && typeof body.systemEnv === "object" && !Array.isArray(body.systemEnv) ? body.systemEnv : {};
+  const workspaceEnv = {
+    BUDA_AGENT_ROOT: mounts.agent,
+    BUDA_SPACE_ROOT: mounts.space,
+    BUDA_SYSTEM_ROOT: mounts.system
+  };
   return {
     ...request,
     body: {
       ...body,
       cwd: path12.join(mount, relative),
-      env: {
-        ...env,
-        BUDA_AGENT_ROOT: mounts.agent,
-        BUDA_SPACE_ROOT: mounts.space,
-        BUDA_SYSTEM_ROOT: mounts.system
+      systemEnv: {
+        ...systemEnv,
+        ...workspaceEnv
       }
     }
   };
@@ -5078,17 +5434,24 @@ var normalizeConnectorFilesystemRequest = (request, mounts) => {
   }
   return request;
 };
-function sendRelayError(socket, requestId, error) {
-  sendRelayMessage(socket, {
+async function sendRelayError(socket, requestId, error) {
+  await 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 !== WebSocket2.OPEN) return;
-  socket.send(JSON.stringify(message));
+async function sendRelayMessage(socket, message) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    throw new Error(`Connector relay socket closed before ${message.type} could be sent.`);
+  }
+  await new Promise((resolve, reject) => {
+    socket.send(JSON.stringify(message), (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
 }
 function headersToRecord(headers) {
   const result = {};
@@ -5147,7 +5510,7 @@ async function ensureSymlink(target, linkPath) {
   } catch {
   }
   await mkdir10(path13.dirname(linkPath), { recursive: true });
-  await symlink3(target, linkPath, "dir");
+  await symlink3(target, linkPath, directoryLinkType());
 }
 
 // src/workspace-registry.ts
@@ -5604,7 +5967,30 @@ import { mkdir as mkdir12 } from "fs/promises";
 import path15 from "path";
 var RECOVERED_DAEMON_STOP_TIMEOUT_MS = 1e4;
 var RECOVERED_DAEMON_STOP_POLL_MS = 100;
+var SHUTDOWN_FORCE_EXIT_MS = 1e4;
+var SHUTDOWN_STEP_TIMEOUT_MS = 2e3;
 var wait3 = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+var runShutdownStep = async (label, operation) => {
+  let timeout;
+  try {
+    await Promise.race([
+      Promise.resolve().then(operation),
+      new Promise((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`${label} timed out after ${SHUTDOWN_STEP_TIMEOUT_MS}ms`)),
+          SHUTDOWN_STEP_TIMEOUT_MS
+        );
+      })
+    ]);
+  } catch (error) {
+    await writeLog(
+      "warn",
+      `${label} failed during shutdown: ${error instanceof Error ? error.message : String(error)}`
+    ).catch(() => void 0);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+};
 async function stopRecoveredIdleDaemon(config, configRoot) {
   const stopStatus = await requestDaemonControl(config, "stop-if-idle", configRoot).catch(
     () => null
@@ -5724,18 +6110,30 @@ async function runConnectorDaemon(launchConfig, options = {}) {
     const shutdown = async (shutdownOptions = {}) => {
       if (shuttingDown) return;
       shuttingDown = true;
+      const forceExit = options.exitOnShutdown === false ? void 0 : setTimeout(() => process.exit(0), SHUTDOWN_FORCE_EXIT_MS);
       if (interval) clearInterval(interval);
       relay.stop();
       try {
-        await closeAllBrowserSessions();
-        if (shutdownOptions.unregister !== false) {
-          await unregisterConnector(config, launchConfig);
-        }
-        await stopEmbeddedBunnyDaemon(activeBunnyDaemon);
+        await Promise.all([
+          runShutdownStep("browser session cleanup", closeAllBrowserSessions),
+          ...shutdownOptions.unregister === false ? [] : [
+            runShutdownStep(
+              "connector unregister",
+              () => unregisterConnector(config, launchConfig)
+            )
+          ],
+          runShutdownStep(
+            "embedded Bunny daemon shutdown",
+            () => stopEmbeddedBunnyDaemon(activeBunnyDaemon)
+          )
+        ]);
       } finally {
-        await control?.close();
-        await daemonLock.release();
-        await restoreConsole?.();
+        await Promise.all([
+          runShutdownStep("control channel shutdown", async () => control?.close()),
+          runShutdownStep("daemon lock release", () => daemonLock.release()),
+          runShutdownStep("console capture restore", async () => restoreConsole?.())
+        ]);
+        if (forceExit) clearTimeout(forceExit);
         if (options.exitOnShutdown !== false) process.exit(0);
       }
     };
@@ -5750,8 +6148,11 @@ async function runConnectorDaemon(launchConfig, options = {}) {
         });
       }).catch((error) => {
         heartbeatHealthy = false;
-        if (error instanceof ConnectorDeletedError) {
-          void writeLog("warn", "connector deleted remotely; stopping daemon");
+        if (error instanceof ConnectorDeletedError || error instanceof ConnectorUnauthorizedError) {
+          void writeLog(
+            "warn",
+            error instanceof ConnectorDeletedError ? "connector deleted remotely; stopping daemon" : "connector authentication rejected remotely; stopping daemon"
+          );
           void shutdown({ unregister: false });
           return;
         }
@@ -5775,6 +6176,10 @@ async function runConnectorDaemon(launchConfig, options = {}) {
     process.once("SIGINT", () => void shutdown());
     process.once("SIGTERM", () => void shutdown());
   } catch (error) {
+    await writeLog(
+      "error",
+      `daemon startup failed: ${error instanceof Error ? error.stack || error.message : String(error)}`
+    ).catch(() => void 0);
     if (bunnyDaemon) await stopEmbeddedBunnyDaemon(bunnyDaemon);
     await daemonLock.release();
     await restoreConsole?.();