@buda-ai/connector 0.1.30 → 0.1.32

package/agent-templates/shared/AGENTS.md

@@ -47,7 +47,7 @@ Capture what matters. Decisions, context, things to remember. Skip the secrets u
 
 - **Memory is limited** — if you want to remember something, you MUST write it to a file using your tools (like `bash` or `write`).
 - "Mental notes" do not survive session restarts or context limits. Only files do.
-- When the user gives you a **new rule, a new preference, changes your identity/role, or tells you to "remember this"** → You **MUST IMMEDIATELY** use your tools to update `SOUL.md`, `AGENTS.md`, `MEMORY.md` or `memory/YYYY-MM-DD.md`.
+- When the user gives you a **new rule, a new preference, changes your identity/role, or tells you to "remember this"** → You **MUST IMMEDIATELY** use your tools to update `SOUL.md`, `AGENTS.md`, `USER.md` or `memory/YYYY-MM-DD.md`.
 - DO NOT just reply "Okay, I will remember this." You must actually execute a file write operation to make it permanent.
 - When you learn a lesson → update `AGENTS.md`, `TOOLS.md`, or the relevant skill.
 - When you make a mistake → document it so future-you doesn't repeat it.

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)) {
-        const recovered = await unlink(lockPath).then(() => true).catch(() => false);
-        if (recovered) continue;
+        await unlink(lockPath).catch(() => void 0);
+        continue;
       }
       if (Date.now() >= deadline) {
         throw new Error(`Timed out waiting for exclusive access to ${targetPath}`);
@@ -35,23 +35,17 @@ async function acquireExclusiveFileLock(targetPath, options = {}) {
       continue;
     }
     const ownerToken = randomUUID();
-    try {
-      await handle.writeFile(
-        `${JSON.stringify({ pid: process.pid, ownerToken, createdAt: Date.now() })}
+    await handle.writeFile(
+      `${JSON.stringify({ pid: process.pid, ownerToken, createdAt: Date.now() })}
 `
-      );
-      await handle.sync();
-    } catch (error) {
-      await handle.close().catch(() => void 0);
-      await unlink(lockPath).catch(() => void 0);
-      throw error;
-    }
-    await handle.close();
+    );
+    await handle.sync();
     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);
       }
@@ -523,7 +517,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.30",
+  version: "0.1.32",
   private: false,
   type: "module",
   publishConfig: {
@@ -541,7 +535,6 @@ 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",
@@ -550,7 +543,7 @@ var package_default = {
     "lint:err": "biome format . --write && biome check . --write --diagnostic-level=error"
   },
   dependencies: {
-    "@bunny-agent/daemon": "0.9.57",
+    "@bunny-agent/daemon": "0.9.51",
     "@clack/prompts": "^1.0.0",
     "playwright-core": "^1.52.0",
     ws: "^8.21.0"
@@ -2215,13 +2208,6 @@ 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" };
@@ -2308,15 +2294,14 @@ 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, options = {}) {
+async function postJson(serverUrl, pathname, body, config, launchConfig) {
   const response = await fetch(`${serverUrl}${pathname}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       ...buildAuthHeaders(config, launchConfig)
     },
-    body: JSON.stringify(body),
-    ...options.timeoutMs ? { signal: AbortSignal.timeout(options.timeoutMs) } : {}
+    body: JSON.stringify(body)
   });
   if (!response.ok) {
     const text2 = await response.text().catch(() => "");
@@ -2336,9 +2321,6 @@ async function postJson(serverUrl, pathname, body, config, launchConfig, options
     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();
@@ -2414,8 +2396,7 @@ async function unregisterConnector(config, launchConfig) {
       connectorId: config.connectorId
     },
     config,
-    launchConfig,
-    { timeoutMs: UNREGISTER_TIMEOUT_MS }
+    launchConfig
   ).catch((error) => {
     void writeLog("warn", `unregister failed: ${error instanceof Error ? error.message : error}`);
   });
@@ -2424,58 +2405,73 @@ async function unregisterConnector(config, launchConfig) {
 // src/runtime-install.ts
 import { execFile } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
-import { access, cp, mkdir as mkdir5, readFile as readFile5, rename as rename4, rm, writeFile as writeFile3 } from "fs/promises";
+import {
+  access,
+  cp,
+  mkdir as mkdir5,
+  readdir as readdir4,
+  readFile as readFile5,
+  realpath,
+  rename as rename4,
+  rm,
+  writeFile as writeFile3
+} from "fs/promises";
 import { homedir as homedir3 } from "os";
 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 resolveBundledNodePlacement = (sourceRoot, sourceNode, pathApi = path6) => {
-  const relativeNode = pathApi.relative(sourceRoot, sourceNode);
-  return {
-    copyNode: relativeNode.startsWith("..") || pathApi.isAbsolute(relativeNode),
-    relativeNode
-  };
-};
-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")
+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 copyNodeRuntime = async (sourceNode, destinationNode, options = {}) => {
+  const resolvedSourceNode = await realpath(sourceNode);
+  const sourceDirectory = path6.dirname(resolvedSourceNode);
+  const destinationDirectory = path6.dirname(destinationNode);
+  await mkdir5(destinationDirectory, { recursive: true });
+  await cp(resolvedSourceNode, destinationNode, { dereference: true, force: true });
+  if ((options.platform ?? process.platform) !== "darwin") return;
+  const launcherDirectory = path6.resolve(path6.dirname(sourceNode));
+  const companionDirectories = [
+    .../* @__PURE__ */ new Set([
+      launcherDirectory,
+      path6.resolve(launcherDirectory, "..", "lib"),
+      sourceDirectory,
+      path6.resolve(sourceDirectory, "..", "lib")
+    ])
   ];
-  for (const candidate of candidates) {
-    if (!candidate || pathApi.basename(candidate).toLowerCase() !== "npm-cli.js") continue;
-    if (await pathExists(candidate)) {
-      return { argsPrefix: [candidate], executable: nodeExecutable };
+  const companions = (await Promise.all(
+    companionDirectories.map(async (directory) => ({
+      directory,
+      entries: await readdir4(directory, { withFileTypes: true }).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") return [];
+        throw error;
+      })
+    }))
+  )).flatMap(({ directory, entries }) => entries.map((entry) => ({ directory, entry })));
+  const companionFiles = /* @__PURE__ */ new Map();
+  const loadedLibraries = options.loadedLibraries ?? getLoadedSharedObjects();
+  for (const library of loadedLibraries) {
+    const name = path6.basename(library);
+    if (MACOS_NODE_LIBRARY_PATTERN.test(name)) companionFiles.set(name, library);
+  }
+  for (const { directory, entry } of companions) {
+    if ((entry.isFile() || entry.isSymbolicLink()) && MACOS_NODE_LIBRARY_PATTERN.test(entry.name) && !companionFiles.has(entry.name)) {
+      companionFiles.set(entry.name, path6.join(directory, entry.name));
     }
   }
-  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 ?? "")})`
+  await Promise.all(
+    [...companionFiles].map(
+      ([name, source]) => cp(source, path6.join(destinationDirectory, name), {
+        dereference: true,
+        force: true
+      })
+    )
   );
 };
+var exists = async (filePath) => access(filePath).then(() => true).catch(() => false);
 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);
@@ -2509,11 +2505,9 @@ var validateRuntime = async (runtime) => {
 };
 var installFromNpm = async (directory) => {
   await mkdir5(directory, { recursive: true, mode: 448 });
-  const npm = await resolveNpmInvocation();
   await execFileAsync(
-    npm.executable,
+    process.platform === "win32" ? "npm.cmd" : "npm",
     [
-      ...npm.argsPrefix,
       "install",
       "--ignore-scripts=false",
       "--no-audit",
@@ -2534,8 +2528,7 @@ var installFromNpm = async (directory) => {
     "cli.js"
   );
   const nodeExecutable = path6.join(directory, "node", path6.basename(process.execPath));
-  await mkdir5(path6.dirname(nodeExecutable), { recursive: true });
-  await cp(process.execPath, nodeExecutable, { force: true });
+  await copyNodeRuntime(process.execPath, nodeExecutable);
   if (!await exists(entrypoint)) throw new Error("Installed Connector runtime is incomplete");
   return { entrypoint, nodeExecutable, version: CONNECTOR_RUNTIME_VERSION };
 };
@@ -2548,12 +2541,11 @@ var installFromBundledRuntime = async (directory, sourceRoot) => {
   if (relativeEntrypoint.startsWith("..") || path6.isAbsolute(relativeEntrypoint)) {
     throw new Error("Bundled Connector entrypoint must be inside its runtime root");
   }
-  const { copyNode, relativeNode } = resolveBundledNodePlacement(sourceRoot, sourceNode);
+  const relativeNode = path6.relative(sourceRoot, sourceNode);
   const entrypoint = path6.join(directory, relativeEntrypoint);
-  const nodeExecutable = copyNode ? path6.join(directory, "node", path6.basename(sourceNode)) : path6.join(directory, relativeNode);
-  if (copyNode) {
-    await mkdir5(path6.dirname(nodeExecutable), { recursive: true });
-    await cp(sourceNode, nodeExecutable, { force: true });
+  const nodeExecutable = relativeNode.startsWith("..") ? path6.join(directory, "node", path6.basename(sourceNode)) : path6.join(directory, relativeNode);
+  if (relativeNode.startsWith("..")) {
+    await copyNodeRuntime(sourceNode, nodeExecutable);
   }
   if (!await exists(entrypoint))
     throw new Error("Copied Connector runtime entrypoint is missing");
@@ -2599,7 +2591,7 @@ async function ensureStableConnectorRuntime() {
         };
         await writeManifest(temporary, rebased);
         await rm(finalDirectory, { recursive: true, force: true });
-        await renameStagedRuntime(temporary, finalDirectory);
+        await rename4(temporary, finalDirectory);
         return rebased;
       } catch (error) {
         await rm(temporary, { recursive: true, force: true });
@@ -2613,8 +2605,6 @@ 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;
@@ -2647,78 +2637,14 @@ 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(
@@ -2727,126 +2653,17 @@ var waitForDaemon = async (launchConfig, deadline) => {
 };
 var spawnInternalDaemon = async (launchConfig, mode, preparedRuntime, options = {}) => {
   const runtime = preparedRuntime ?? await ensureStableConnectorRuntime();
-  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;
-  }
+  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();
 };
-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;
@@ -2873,19 +2690,14 @@ 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 };
         }
-        return await startInternalDaemonWithRecovery(launchConfig, mode, preparedRuntime, options);
+        await spawnInternalDaemon(launchConfig, mode, preparedRuntime, options);
+        return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
       }
       const persistedStatus = await readPersistedDaemonStatus(
         existingConfig,
@@ -2896,12 +2708,9 @@ 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);
-      }
     }
-    return await startInternalDaemonWithRecovery(launchConfig, mode, void 0, options);
+    await spawnInternalDaemon(launchConfig, mode, void 0, options);
+    return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
   } finally {
     await bootstrapLock.release();
   }
@@ -2921,7 +2730,6 @@ 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}`;
@@ -2997,7 +2805,9 @@ 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`);
-  await stopDaemonForIdentity(config, configRoot);
+  const status = await readLiveStatus(config, configRoot);
+  if (!status) return;
+  await requestDaemonControl(config, "stop", configRoot);
 }
 async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
   const configs = await listDeviceConfigs(configRoot);
@@ -3008,7 +2818,10 @@ async function stopAllLocalConnectorDaemons(configRoot = getConfigRoot()) {
 ${config.connectorId}`, config);
   }
   const results = await Promise.allSettled(
-    [...identities.values()].map((config) => stopDaemonForIdentity(config, configRoot))
+    [...identities.values()].map(async (config) => {
+      const status = await readLiveStatus(config, configRoot);
+      if (status) await requestDaemonControl(config, "stop", configRoot);
+    })
   );
   const failures = results.filter((result) => result.status === "rejected");
   if (failures.length) {
@@ -3027,7 +2840,6 @@ 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;
@@ -3048,8 +2860,7 @@ async function runConnectorDashboard(launchConfig, options = {}) {
       connectorId: config.connectorId,
       dashboardActive: false,
       plain: Boolean(options.plain),
-      serverUrl: config.serverUrl,
-      startedAt
+      serverUrl: config.serverUrl
     });
     if (!process.stdin.isTTY) {
       stopLogs2();
@@ -3076,8 +2887,7 @@ async function runConnectorDashboard(launchConfig, options = {}) {
   const stopLogs = streamDaemonLogs({
     dashboardActive: true,
     plain: false,
-    serverUrl: getServerUrl(launchConfig),
-    startedAt
+    serverUrl: getServerUrl(launchConfig)
   });
   let refreshing = false;
   const refresh = async () => {
@@ -3622,10 +3432,10 @@ import {
   lstat,
   mkdir as mkdir8,
   open as open2,
-  readdir as readdir4,
+  readdir as readdir5,
   readFile as readFile7,
   readlink,
-  realpath,
+  realpath as realpath2,
   rename as rename5,
   rm as rm2,
   symlink,
@@ -3677,7 +3487,7 @@ var migrateLegacyWorkspaceRoot = async (storageRoot, options = {}) => {
       "Legacy migration storage root must be a real directory"
     );
   }
-  const canonicalRoot = await realpath(storageRoot);
+  const canonicalRoot = await realpath2(storageRoot);
   const migrationDirectory = path9.join(canonicalRoot, MIGRATION_DIRECTORY);
   await ensurePrivateDirectoryWithin(canonicalRoot, migrationDirectory);
   const journalPath = path9.join(migrationDirectory, JOURNAL_FILENAME);
@@ -3807,7 +3617,7 @@ var createJournal = async (storageRoot, migrationDirectory, owner) => {
   };
 };
 var inventoryLegacySources = async (storageRoot) => {
-  const rootEntries = await readdir4(storageRoot, { withFileTypes: true });
+  const rootEntries = await readdir5(storageRoot, { withFileTypes: true });
   const templateNames = new Set(LEGACY_TEMPLATE_FILES);
   for (const entry of rootEntries) {
     if (entry.name.endsWith(".md")) templateNames.add(entry.name);
@@ -3837,7 +3647,7 @@ var inventoryLegacySources = async (storageRoot) => {
         `Legacy migration source ${candidate.id} must not be a symbolic link`
       );
     }
-    if (info.isDirectory() && (await readdir4(candidate.source)).length === 0) continue;
+    if (info.isDirectory() && (await readdir5(candidate.source)).length === 0) continue;
     found.push(candidate);
   }
   return found;
@@ -3857,7 +3667,7 @@ var copyTree = async (source, destination, onEntryCopied) => {
   const info = await lstat(source);
   if (info.isDirectory()) {
     await mkdir8(destination, { mode: info.mode & 4095 });
-    const entries = (await readdir4(source)).sort();
+    const entries = (await readdir5(source)).sort();
     for (const entry of entries) {
       await copyTree(path9.join(source, entry), path9.join(destination, entry), onEntryCopied);
     }
@@ -3894,8 +3704,8 @@ var verifyTree = async (source, destination) => {
   }
   if (sourceInfo.isDirectory()) {
     const [sourceEntries, destinationEntries] = await Promise.all([
-      readdir4(source),
-      readdir4(destination)
+      readdir5(source),
+      readdir5(destination)
     ]);
     sourceEntries.sort();
     destinationEntries.sort();
@@ -3973,7 +3783,6 @@ 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();
@@ -4321,7 +4130,7 @@ function isNonEmptyString(value) {
 }
 
 // src/html-preview.ts
-import { readFile as readFile8, realpath as realpath2, stat as stat4 } from "fs/promises";
+import { readFile as readFile8, realpath as realpath3, stat as stat4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
 import path10 from "path";
 var PREVIEW_HOST = "127.0.0.1";
@@ -4411,7 +4220,7 @@ var resolveWorkspaceFile = async (input) => {
   const virtualPath = input.filePath.replaceAll("\\", "/");
   if (virtualPath.includes("\0")) throw new Error("HTML preview path contains invalid data.");
   const mountPath = path10.resolve(input.mounts[input.rootVolume]);
-  const root = await realpath2(mountPath);
+  const root = await realpath3(mountPath);
   let relativePath = virtualPath;
   let explicitVolume;
   for (const volume of ["agent", "space"]) {
@@ -4441,7 +4250,7 @@ var resolveWorkspaceFile = async (input) => {
   }
   const candidate = path10.resolve(root, ...segments);
   assertContained(root, candidate);
-  const canonicalFile = await realpath2(candidate);
+  const canonicalFile = await realpath3(candidate);
   assertContained(root, canonicalFile);
   const fileStat = await stat4(canonicalFile);
   if (!fileStat.isFile()) throw new Error("HTML preview path must identify a file.");
@@ -4503,10 +4312,10 @@ var serveStaticFile = async (folder, method, requestUrl) => {
   try {
     const candidate = path10.resolve(folder, ...segments);
     assertContained(folder, candidate);
-    let canonicalFile = await realpath2(candidate);
+    let canonicalFile = await realpath3(candidate);
     assertContained(folder, canonicalFile);
     if ((await stat4(canonicalFile)).isDirectory()) {
-      canonicalFile = await realpath2(path10.join(canonicalFile, "index.html"));
+      canonicalFile = await realpath3(path10.join(canonicalFile, "index.html"));
       assertContained(folder, canonicalFile);
     }
     if (!(await stat4(canonicalFile)).isFile()) throw new Error("Not a file");
@@ -4539,19 +4348,14 @@ import {
   copyFile as copyFile2,
   lstat as lstat2,
   mkdir as mkdir9,
-  readdir as readdir5,
+  readdir as readdir6,
   readFile as readFile9,
-  realpath as realpath3,
+  realpath as realpath4,
   rm as rm3,
   symlink as symlink2,
   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 = [
@@ -4649,7 +4453,7 @@ var WorkspaceVolumeLifecycle = class {
     const bootstrapped = [];
     const skipped = [];
     const entries = new Set(
-      (await readdir5(templateDirectory, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile()).map((entry) => entry.name)
+      (await readdir6(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;
@@ -4684,7 +4488,7 @@ var WorkspaceVolumeLifecycle = class {
     ]) {
       await mkdir9(volume, { recursive: true, mode: 448 });
       const info = await lstat2(volume);
-      if (info.isSymbolicLink() || !info.isDirectory() || await realpath3(volume) !== volume) {
+      if (info.isSymbolicLink() || !info.isDirectory() || await realpath4(volume) !== volume) {
         throw new Error("Workspace volume must be a canonical real directory");
       }
     }
@@ -4697,17 +4501,17 @@ var isMissingFile = (error) => error instanceof Error && "code" in error && erro
 var ensureVolumeLink = async (target, linkPath) => {
   try {
     const info = await lstat2(linkPath);
-    if (!info.isSymbolicLink() || await realpath3(linkPath) !== target) {
+    if (!info.isSymbolicLink() || await realpath4(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, directoryLinkType());
+      await symlink2(target, linkPath, "dir");
     } catch (createError) {
       if (!isAlreadyExists3(createError)) throw createError;
       const info = await lstat2(linkPath);
-      if (!info.isSymbolicLink() || await realpath3(linkPath) !== target) {
+      if (!info.isSymbolicLink() || await realpath4(linkPath) !== target) {
         throw new Error("Workspace mount link raced with an invalid target");
       }
     }
@@ -4718,7 +4522,6 @@ 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;
@@ -4824,7 +4627,6 @@ 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;
@@ -4837,7 +4639,6 @@ 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 {
@@ -4849,33 +4650,18 @@ 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,
@@ -5051,7 +4837,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
       });
       executionIdentity = message.executionIdentity;
     } catch (error) {
-      await sendRelayError(socket, message.requestId, error).catch(() => void 0);
+      sendRelayError(socket, message.requestId, error);
       return;
     }
   }
@@ -5137,7 +4923,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         durationMs: Date.now() - codingRunStartedAt
       });
     }
-    await sendRelayMessage(socket, {
+    sendRelayMessage(socket, {
       type: "start",
       requestId: message.requestId,
       status: response.status,
@@ -5157,7 +4943,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         while (true) {
           const { value, done } = await reader.read();
           if (done) break;
-          await sendRelayMessage(socket, {
+          sendRelayMessage(socket, {
             type: "chunk",
             requestId: message.requestId,
             data: binaryResponse ? Buffer.from(value).toString("base64") : decoder?.decode(value, { stream: true }) ?? "",
@@ -5166,7 +4952,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         }
         const tail = decoder?.decode() ?? "";
         if (tail) {
-          await sendRelayMessage(socket, {
+          sendRelayMessage(socket, {
             type: "chunk",
             requestId: message.requestId,
             data: tail
@@ -5177,7 +4963,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         reader.releaseLock();
       }
     }
-    await sendRelayMessage(socket, {
+    sendRelayMessage(socket, {
       type: "end",
       requestId: message.requestId
     });
@@ -5189,16 +4975,14 @@ 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,
-        error: formatConnectorRelayError(error)
+        durationMs: Date.now() - codingRunStartedAt
       });
     }
-    await sendRelayError(socket, message.requestId, error).catch(() => void 0);
+    sendRelayError(socket, message.requestId, error);
   } finally {
     inflight.delete(message.requestId);
   }
@@ -5252,20 +5036,17 @@ var normalizeWorkspaceRequest = (request, mounts) => {
   if (!mount || relative === void 0) {
     throw new ConnectorRelayProtocolError("WORKSPACE_MISMATCH");
   }
-  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
-  };
+  const env = body.env && typeof body.env === "object" && !Array.isArray(body.env) ? body.env : {};
   return {
     ...request,
     body: {
       ...body,
       cwd: path12.join(mount, relative),
-      systemEnv: {
-        ...systemEnv,
-        ...workspaceEnv
+      env: {
+        ...env,
+        BUDA_AGENT_ROOT: mounts.agent,
+        BUDA_SPACE_ROOT: mounts.space,
+        BUDA_SYSTEM_ROOT: mounts.system
       }
     }
   };
@@ -5297,24 +5078,17 @@ var normalizeConnectorFilesystemRequest = (request, mounts) => {
   }
   return request;
 };
-async function sendRelayError(socket, requestId, error) {
-  await sendRelayMessage(socket, {
+function sendRelayError(socket, requestId, error) {
+  sendRelayMessage(socket, {
     type: "error",
     requestId,
     error: error instanceof Error ? error.message : String(error),
     ...error instanceof ConnectorRelayProtocolError ? { code: error.code } : {}
   });
 }
-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 sendRelayMessage(socket, message) {
+  if (socket.readyState !== WebSocket2.OPEN) return;
+  socket.send(JSON.stringify(message));
 }
 function headersToRecord(headers) {
   const result = {};
@@ -5373,7 +5147,7 @@ async function ensureSymlink(target, linkPath) {
   } catch {
   }
   await mkdir10(path13.dirname(linkPath), { recursive: true });
-  await symlink3(target, linkPath, directoryLinkType());
+  await symlink3(target, linkPath, "dir");
 }
 
 // src/workspace-registry.ts
@@ -5384,7 +5158,7 @@ import {
   mkdir as mkdir11,
   open as open3,
   readFile as readFile10,
-  realpath as realpath4,
+  realpath as realpath5,
   rename as rename6,
   statfs,
   unlink as unlink7
@@ -5548,7 +5322,7 @@ var reconcileWorkspace = async (workspace, storageRoot) => {
   for (const volume of volumes) {
     assertContained2(storageRoot, volume);
     await ensurePrivateDirectory2(volume);
-    const canonical = await realpath4(volume);
+    const canonical = await realpath5(volume);
     if (canonical !== volume) throw corrupt2("Workspace path resolves through a symbolic link");
   }
 };
@@ -5594,7 +5368,7 @@ var canonicalDirectory = async (directory, label) => {
   if (info.isSymbolicLink() || !info.isDirectory()) {
     throw new WorkspaceRegistryError("STORAGE_UNSAFE", `${label} must be a real directory`);
   }
-  return realpath4(directory);
+  return realpath5(directory);
 };
 var rejectUnsafeFilesystem = async (storageRoot) => {
   const stats = await statfs(storageRoot, { bigint: true });
@@ -5830,30 +5604,7 @@ 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
@@ -5973,30 +5724,18 @@ 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 Promise.all([
-          runShutdownStep("browser session cleanup", closeAllBrowserSessions),
-          ...shutdownOptions.unregister === false ? [] : [
-            runShutdownStep(
-              "connector unregister",
-              () => unregisterConnector(config, launchConfig)
-            )
-          ],
-          runShutdownStep(
-            "embedded Bunny daemon shutdown",
-            () => stopEmbeddedBunnyDaemon(activeBunnyDaemon)
-          )
-        ]);
+        await closeAllBrowserSessions();
+        if (shutdownOptions.unregister !== false) {
+          await unregisterConnector(config, launchConfig);
+        }
+        await stopEmbeddedBunnyDaemon(activeBunnyDaemon);
       } finally {
-        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);
+        await control?.close();
+        await daemonLock.release();
+        await restoreConsole?.();
         if (options.exitOnShutdown !== false) process.exit(0);
       }
     };
@@ -6011,11 +5750,8 @@ async function runConnectorDaemon(launchConfig, options = {}) {
         });
       }).catch((error) => {
         heartbeatHealthy = false;
-        if (error instanceof ConnectorDeletedError || error instanceof ConnectorUnauthorizedError) {
-          void writeLog(
-            "warn",
-            error instanceof ConnectorDeletedError ? "connector deleted remotely; stopping daemon" : "connector authentication rejected remotely; stopping daemon"
-          );
+        if (error instanceof ConnectorDeletedError) {
+          void writeLog("warn", "connector deleted remotely; stopping daemon");
           void shutdown({ unregister: false });
           return;
         }
@@ -6039,10 +5775,6 @@ 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?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buda-ai/connector",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "private": false,
   "type": "module",
   "publishConfig": {
@@ -18,7 +18,6 @@
     "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",
@@ -27,7 +26,7 @@
     "lint:err": "biome format . --write && biome check . --write --diagnostic-level=error"
   },
   "dependencies": {
-    "@bunny-agent/daemon": "0.9.57",
+    "@bunny-agent/daemon": "0.9.51",
     "@clack/prompts": "^1.0.0",
     "playwright-core": "^1.52.0",
     "ws": "^8.21.0"