@buda-ai/connector 0.1.32 → 0.1.33

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`, `USER.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`, `MEMORY.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)) {
-        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);
       }
@@ -517,7 +523,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.32",
+  version: "0.1.33",
   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.58",
     "@clack/prompts": "^1.0.0",
     "playwright-core": "^1.52.0",
     ws: "^8.21.0"
@@ -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,6 +2978,7 @@ 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}`;
@@ -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 () => {
@@ -3783,6 +4030,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();
@@ -4356,6 +4604,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 +4760,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 +4775,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 +4881,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 +4894,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 +4906,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 +5108,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 +5194,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 +5214,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 +5223,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 +5234,7 @@ async function handleRelayMessage(socket, bunnyDaemon, raw, inflight, expectedCo
         reader.releaseLock();
       }
     }
-    sendRelayMessage(socket, {
+    await sendRelayMessage(socket, {
       type: "end",
       requestId: message.requestId
     });
@@ -4975,14 +5246,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 +5309,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 +5354,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 +5430,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 +5887,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 +6030,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 +6068,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 +6096,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?.();

package/package.json

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