@skaile/workspaces 1.16.0 → 2.1.0

package/dist/{chunk-6POODADP.js → chunk-HOL5KD7U.js}

@@ -1,17 +1,19 @@
-import { resolveAuthRef } from './chunk-2TSSCHCQ.js';
+import { resolveAuthRef } from './chunk-BHLNQ4L5.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeFlowStateFromSnapshots } from './chunk-HPGV54O4.js';
 import { renderStimulusPrompt } from './chunk-Y662DNQQ.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
-import { portableSpawn } from './chunk-5NZ56R63.js';
-import { createLogger } from './chunk-JB35MVBN.js';
-import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, cpSync, statSync, createReadStream, readdirSync, openSync, writeSync, closeSync, chmodSync } from 'fs';
+import { portableSpawn } from './chunk-RTLQAZAE.js';
+import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-DYMWJAL4.js';
+import { createLogger } from './chunk-7GOCNYUV.js';
+import { mkdir, rename, writeFile, readFile, stat, cp, readdir, chmod, realpath } from 'fs/promises';
 import { join, dirname, resolve, sep, relative } from 'path';
 import * as zNS from 'zod';
-import { execSync } from 'child_process';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { createReadStream, readFileSync, existsSync, mkdirSync, openSync, writeSync, closeSync, chmodSync, renameSync } from 'fs';
 import { createServer } from 'http';
 import mime from 'mime';
-import { stat, readdir, mkdir, chmod, readFile, realpath } from 'fs/promises';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import { createConnection } from 'net';
@@ -51,6 +53,8 @@ var AbstractConnector = class {
     };
   }
 };
+var execFileAsync = promisify(execFile);
+var GIT_REV_PARSE_TIMEOUT_MS = 15e3;
 var DeployConnector = class extends AbstractConnector {
   name = "deploy";
   tools;
@@ -69,12 +73,16 @@ var DeployConnector = class extends AbstractConnector {
     for (const [k, v] of Object.entries(declaration.options ?? {})) {
       if (k !== "provider" && typeof v === "string") defaults[k] = v;
     }
+    const repoDir = String(declaration.options?.repo_root ?? process.cwd());
     let repoRoot = null;
     try {
-      repoRoot = execSync("git rev-parse --show-toplevel", {
+      const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: repoDir,
         encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
+        timeout: GIT_REV_PARSE_TIMEOUT_MS,
+        killSignal: "SIGKILL"
+      });
+      repoRoot = stdout.trim();
     } catch {
     }
     return this.makeHandle(declaration, {
@@ -82,7 +90,7 @@ var DeployConnector = class extends AbstractConnector {
       defaults,
       deployments: /* @__PURE__ */ new Map(),
       repoRoot,
-      worktreeDir: process.cwd()
+      worktreeDir: repoDir
     });
   }
   async disconnect(handle) {
@@ -317,7 +325,7 @@ var DevServerConnector = class extends AbstractConnector {
     const portRange = opts.port_range ?? [3e3, 3099];
     let repoRoot = null;
     try {
-      repoRoot = findGitRoot(process.cwd());
+      repoRoot = await findGitRoot(process.cwd());
     } catch {
     }
     const state = {
@@ -546,8 +554,8 @@ var DevServerConnector = class extends AbstractConnector {
       detached: true
     });
     const logBuffer = new LogBuffer(state.logBufferSize);
-    pipeToBuffer(proc.stdout, logBuffer);
-    pipeToBuffer(proc.stderr, logBuffer);
+    void pipeToBuffer(proc.stdout, logBuffer);
+    void pipeToBuffer(proc.stderr, logBuffer);
     const instance = {
       id: label,
       pid: proc.pid,
@@ -838,24 +846,29 @@ function resolveGitConfig(args) {
   };
 }
 var modeLog = createLogger({ kind: "connector", subkind: "git" });
-function shellQuote(value) {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function gitCommand(cwd) {
-  return `git -c safe.directory=${shellQuote(cwd)}`;
+var execFileAsync2 = promisify(execFile);
+function gitPrefix(cwd) {
+  return ["-c", `safe.directory=${cwd}`];
 }
-function git(cmd, cwd, timeout = 3e4) {
-  return execSync(`${gitCommand(cwd)} ${cmd}`, {
-    cwd,
+async function runGit(args, options) {
+  const { stdout } = await execFileAsync2("git", args, {
     encoding: "utf-8",
-    timeout,
-    stdio: "pipe"
-  }).trim();
+    timeout: options.timeout,
+    killSignal: "SIGKILL",
+    ...options.cwd === void 0 ? {} : { cwd: options.cwd }
+  });
+  return stdout.trim();
 }
-function syncSubmodules(cwd) {
-  if (!existsSync(join(cwd, ".gitmodules"))) return;
+function git(args, cwd, timeout = 3e4) {
+  return runGit([...gitPrefix(cwd), ...args], { cwd, timeout });
+}
+function pathExists(path) {
+  return tryWithFsDeadline(`stat ${path}`, () => stat(path).then(() => true), false);
+}
+async function syncSubmodules(cwd) {
+  if (!await pathExists(join(cwd, ".gitmodules"))) return;
   try {
-    git("submodule update --init --recursive", cwd, 12e4);
+    await git(["submodule", "update", "--init", "--recursive"], cwd, 12e4);
   } catch {
   }
 }
@@ -867,19 +880,19 @@ function isValidGitRefOrSha(ref) {
   if (ref.includes("..") || ref.includes("@{")) return false;
   return true;
 }
-function hasChanges(cwd) {
-  const status = git("status --porcelain", cwd);
+async function hasChanges(cwd) {
+  const status = await git(["status", "--porcelain"], cwd);
   return status.length > 0;
 }
-function gitOrNull(cmd, cwd) {
+async function gitOrNull(args, cwd) {
   try {
-    return git(cmd, cwd);
+    return await git(args, cwd);
   } catch {
     return null;
   }
 }
-function countAheadBehind(cwd, remoteRef) {
-  const out = gitOrNull(`rev-list --left-right --count ${remoteRef}...HEAD`, cwd);
+async function countAheadBehind(cwd, remoteRef) {
+  const out = await gitOrNull(["rev-list", "--left-right", "--count", `${remoteRef}...HEAD`], cwd);
   if (!out) {
     return { ahead: 0, behind: 0 };
   }
@@ -891,15 +904,15 @@ function countAheadBehind(cwd, remoteRef) {
     behind: Number.isFinite(behind) ? behind : 0
   };
 }
-function readGitSyncStatus(cwd, baseBranch) {
-  const branchRaw = gitOrNull("rev-parse --abbrev-ref HEAD", cwd);
+async function readGitSyncStatus(cwd, baseBranch) {
+  const branchRaw = await gitOrNull(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
   const branch = branchRaw && branchRaw !== "HEAD" ? branchRaw : null;
-  const dirty = (gitOrNull("status --porcelain", cwd) ?? "") !== "";
-  const hasUpstream = branch !== null && gitOrNull("rev-parse --abbrev-ref @{upstream}", cwd) !== null;
-  const upstream = countAheadBehind(cwd, "@{upstream}");
+  const dirty = (await gitOrNull(["status", "--porcelain"], cwd) ?? "") !== "";
+  const hasUpstream = branch !== null && await gitOrNull(["rev-parse", "--abbrev-ref", "@{upstream}"], cwd) !== null;
+  const upstream = await countAheadBehind(cwd, "@{upstream}");
   const baseRef = isValidGitRefOrSha(baseBranch) ? `origin/${baseBranch}` : "origin/main";
-  const base = countAheadBehind(cwd, baseRef);
-  const commitSha = gitOrNull("rev-parse HEAD", cwd);
+  const base = await countAheadBehind(cwd, baseRef);
+  const commitSha = await gitOrNull(["rev-parse", "HEAD"], cwd);
   return {
     branch,
     dirty,
@@ -911,25 +924,22 @@ function readGitSyncStatus(cwd, baseBranch) {
     commitSha
   };
 }
-function localBranchExists(branch, cwd) {
+async function localBranchExists(branch, cwd) {
   try {
-    git(`rev-parse --verify --quiet refs/heads/${branch}`, cwd);
+    await git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], cwd);
     return true;
   } catch {
     return false;
   }
 }
-function isDirEmpty(dir) {
-  try {
-    return readdirSync(dir).length === 0;
-  } catch {
-    return true;
-  }
+async function isDirEmpty(dir) {
+  const entries = await tryWithFsDeadline(`readdir ${dir}`, () => readdir(dir), []);
+  return entries.length === 0;
 }
-function commitAll(cwd, message) {
-  if (!hasChanges(cwd)) return null;
-  git("add -A", cwd);
-  return git(`commit -m ${JSON.stringify(message)}`, cwd);
+async function commitAll(cwd, message) {
+  if (!await hasChanges(cwd)) return null;
+  await git(["add", "-A"], cwd);
+  return git(["commit", "-m", message], cwd);
 }
 var TokenMediatorError = class extends Error {
   code;
@@ -969,7 +979,7 @@ var GitConnector = class extends AbstractConnector {
           throw new Error("git sync_status: mount path unavailable");
         }
         const state = handle.state;
-        return JSON.stringify(readGitSyncStatus(cwd, state.branch));
+        return JSON.stringify(await readGitSyncStatus(cwd, state.branch));
       }
       default:
         throw new Error(`GitConnector has no operation: ${operation}`);
@@ -1014,9 +1024,9 @@ var GitConnector = class extends AbstractConnector {
       tokenMediator: initial.authRef?.kind === "backend" ? tokenMediator : void 0
     };
     const authUrl = this.authUrl(state);
-    this.prepareCheckout(targetDir, url, branch, authUrl, started);
+    await this.prepareCheckout(targetDir, url, branch, authUrl, started);
     if (session.enabled && !session.isMain && session.slug) {
-      this.checkoutSessionBranch(state, session, targetDir);
+      await this.checkoutSessionBranch(state, session, targetDir);
     }
     if (sync.fetchIntervalSec > 0) {
       this.startPeriodicFetch(state, targetDir);
@@ -1030,9 +1040,9 @@ var GitConnector = class extends AbstractConnector {
       }
     }
     if (state.managedGitconfig) {
-      this.stripRemoteInlineToken(targetDir);
+      await this.stripRemoteInlineToken(targetDir);
     } else {
-      this.rebakeRemoteAuth(targetDir, state);
+      await this.rebakeRemoteAuth(targetDir, state);
       if (initial.authRef?.kind === "backend" && initial.expiresAt && state.tokenMediator) {
         this.scheduleRefresh(declaration.id, state, initial.expiresAt);
       }
@@ -1061,31 +1071,37 @@ var GitConnector = class extends AbstractConnector {
    *     reset, no clean. Existing files become uncommitted-on-init; the
    *     agent or `pushAfterCommit` reconciles with remote later.
    */
-  prepareCheckout(targetDir, url, branch, authUrl, started) {
+  async prepareCheckout(targetDir, url, branch, authUrl, started) {
     try {
-      if (existsSync(join(targetDir, ".git"))) {
-        if (this.isInitialisedCheckout(targetDir)) {
+      if (await pathExists(join(targetDir, ".git"))) {
+        if (await this.isInitialisedCheckout(targetDir)) {
           this.log.info("found existing checkout \u2014 using as-is", { branch, targetDir });
         } else {
           this.log.info("found empty .git \u2014 bootstrapping from origin", { branch });
-          this.bootstrapFromOrigin(targetDir, branch, authUrl);
+          await this.bootstrapFromOrigin(targetDir, branch, authUrl);
           this.log.info("bootstrap ok", { branch, durationMs: Date.now() - started });
         }
       } else {
-        mkdirSync(targetDir, { recursive: true });
-        if (isDirEmpty(targetDir)) {
+        await withFsDeadline(`mkdir ${targetDir}`, () => mkdir(targetDir, { recursive: true }));
+        if (await isDirEmpty(targetDir)) {
           this.log.info("clone start", { url, branch });
-          execSync(
-            `${gitCommand(targetDir)} clone --branch ${branch} --single-branch --recurse-submodules ${authUrl} ${targetDir}`,
-            {
-              timeout: 12e4,
-              stdio: "pipe"
-            }
+          await runGit(
+            [
+              ...gitPrefix(targetDir),
+              "clone",
+              "--branch",
+              branch,
+              "--single-branch",
+              "--recurse-submodules",
+              authUrl,
+              targetDir
+            ],
+            { timeout: 12e4 }
           );
           this.log.info("clone ok", { branch, durationMs: Date.now() - started });
         } else {
           this.log.warn("target non-empty without .git \u2014 initialising in place", { targetDir });
-          this.initInPlace(targetDir, authUrl);
+          await this.initInPlace(targetDir, authUrl);
           this.log.info("init in place ok", { durationMs: Date.now() - started });
         }
       }
@@ -1101,37 +1117,37 @@ var GitConnector = class extends AbstractConnector {
    * fork flow) when supplied and valid, else off the currently-checked-out
    * HEAD (== base branch).
    */
-  checkoutSessionBranch(state, session, targetDir) {
+  async checkoutSessionBranch(state, session, targetDir) {
     const sessionBranch = `${session.branchPrefix}${session.slug}`;
     if (!isValidGitRefOrSha(sessionBranch)) {
       throw new Error(`Git connector: invalid session branch name "${sessionBranch}"`);
     }
     let created = false;
-    if (localBranchExists(sessionBranch, targetDir)) {
-      git(`checkout ${sessionBranch}`, targetDir);
+    if (await localBranchExists(sessionBranch, targetDir)) {
+      await git(["checkout", sessionBranch], targetDir);
       this.log.info("reusing existing local session branch", { sessionBranch });
     } else {
       let originHasBranch = false;
       try {
-        git(`rev-parse --verify origin/${sessionBranch}`, targetDir);
+        await git(["rev-parse", "--verify", `origin/${sessionBranch}`], targetDir);
         originHasBranch = true;
       } catch {
       }
       if (originHasBranch) {
-        git(`checkout -B ${sessionBranch} origin/${sessionBranch}`, targetDir);
-      } else if (!this.branchFromRef(session, sessionBranch, targetDir)) {
-        git(`checkout -b ${sessionBranch}`, targetDir);
+        await git(["checkout", "-B", sessionBranch, `origin/${sessionBranch}`], targetDir);
+      } else if (!await this.branchFromRef(session, sessionBranch, targetDir)) {
+        await git(["checkout", "-b", sessionBranch], targetDir);
         created = true;
       } else {
         created = true;
       }
     }
-    syncSubmodules(targetDir);
+    await syncSubmodules(targetDir);
     state.activeBranch = sessionBranch;
     this.log.info("session branch checked out", { sessionBranch });
     if (created && state.lifecycle.publishOnCreate) {
       try {
-        git(`push -u origin ${sessionBranch}`, targetDir, 6e4);
+        await git(["push", "-u", "origin", sessionBranch], targetDir, 6e4);
         this.log.info("published new session branch", { sessionBranch });
       } catch (err) {
         this.log.warn("publish-on-create push failed; deferring to lifecycle push", {
@@ -1146,7 +1162,7 @@ var GitConnector = class extends AbstractConnector {
    * true when the branch was created from the anchor; false when no valid
    * `fromRef` was supplied or the fetch failed (caller falls back to base).
    */
-  branchFromRef(session, sessionBranch, targetDir) {
+  async branchFromRef(session, sessionBranch, targetDir) {
     if (!session.fromRef) return false;
     if (!isValidGitRefOrSha(session.fromRef)) {
       this.log.warn("fromRef rejected by refname validation, falling back to base branch", {
@@ -1156,8 +1172,8 @@ var GitConnector = class extends AbstractConnector {
       return false;
     }
     try {
-      git(`fetch origin ${session.fromRef}`, targetDir);
-      git(`checkout -b ${sessionBranch} FETCH_HEAD`, targetDir);
+      await git(["fetch", "origin", session.fromRef], targetDir);
+      await git(["checkout", "-b", sessionBranch, "FETCH_HEAD"], targetDir);
       this.log.info("session branch created from fromRef", {
         sessionBranch,
         fromRef: session.fromRef
@@ -1189,7 +1205,7 @@ var GitConnector = class extends AbstractConnector {
     await ensureFleetMounted(targetDir, this.log);
     let activeBranch = "unknown";
     try {
-      activeBranch = git("rev-parse --abbrev-ref HEAD", targetDir, 5e3);
+      activeBranch = await git(["rev-parse", "--abbrev-ref", "HEAD"], targetDir, 5e3);
     } catch {
     }
     const fleetConfig = resolveGitConfig({
@@ -1265,6 +1281,7 @@ var GitConnector = class extends AbstractConnector {
   async disconnect(handle) {
     this.log.info("unmount");
     const s = handle.state;
+    s.disposed = true;
     if (s.fleetManaged) {
       await s.fleetWatcher?.close();
       s.fleetWatcher = void 0;
@@ -1289,8 +1306,8 @@ var GitConnector = class extends AbstractConnector {
     }
     this.log.debug("sync (pull) start", { branch: s.activeBranch });
     try {
-      git(`pull origin ${s.activeBranch}`, handle.mountPath, 6e4);
-      syncSubmodules(handle.mountPath);
+      await git(["pull", "origin", s.activeBranch], handle.mountPath, 6e4);
+      await syncSubmodules(handle.mountPath);
       this.log.debug("sync ok");
     } catch (err) {
       this.log.error("sync failed", err, { branch: s.activeBranch });
@@ -1341,12 +1358,12 @@ var GitConnector = class extends AbstractConnector {
     }
     const lc = s.lifecycle;
     if (!lc.commitOnHibernate) return;
-    const result = commitAll(handle.mountPath, `skaile: hibernate snapshot`);
+    const result = await commitAll(handle.mountPath, `skaile: hibernate snapshot`);
     if (!result) return "Nothing to commit.";
-    const sha = git("rev-parse --short HEAD", handle.mountPath);
+    const sha = await git(["rev-parse", "--short", "HEAD"], handle.mountPath);
     if (lc.pushOnHibernate) {
       try {
-        git(`push origin ${s.activeBranch}`, handle.mountPath, 6e4);
+        await git(["push", "origin", s.activeBranch], handle.mountPath, 6e4);
         this.log.info("push ok", { branch: s.activeBranch });
       } catch (err) {
         this.log.error("push failed", err, { branch: s.activeBranch });
@@ -1363,29 +1380,29 @@ var GitConnector = class extends AbstractConnector {
     }
     const lc = s.lifecycle;
     const details = [];
-    const commitResult = commitAll(handle.mountPath, `skaile: session close`);
+    const commitResult = await commitAll(handle.mountPath, `skaile: session close`);
     if (commitResult) {
-      const sha = git("rev-parse --short HEAD", handle.mountPath);
+      const sha = await git(["rev-parse", "--short", "HEAD"], handle.mountPath);
       details.push(`Committed ${sha}`);
     }
     if (lc.pushOnClose || lc.mergeOnClose) {
-      git(`push origin ${s.activeBranch}`, handle.mountPath, 6e4);
+      await git(["push", "origin", s.activeBranch], handle.mountPath, 6e4);
       details.push(`Pushed ${s.activeBranch}`);
     }
     if (lc.mergeOnClose && s.activeBranch !== s.branch) {
-      git(`checkout ${s.branch}`, handle.mountPath);
-      git(`pull origin ${s.branch}`, handle.mountPath, 6e4);
-      syncSubmodules(handle.mountPath);
+      await git(["checkout", s.branch], handle.mountPath);
+      await git(["pull", "origin", s.branch], handle.mountPath, 6e4);
+      await syncSubmodules(handle.mountPath);
       try {
-        git(`merge ${s.activeBranch}`, handle.mountPath);
+        await git(["merge", s.activeBranch], handle.mountPath);
       } catch {
-        const resolved = this.resolveConflictsOrAbort(s, handle.mountPath, "merge");
+        const resolved = await this.resolveConflictsOrAbort(s, handle.mountPath, "merge");
         if (resolved) {
           details.push("Resolved merge conflicts (created .conflict files)");
         }
       }
       if (lc.pushOnClose) {
-        git(`push origin ${s.branch}`, handle.mountPath, 6e4);
+        await git(["push", "origin", s.branch], handle.mountPath, 6e4);
       }
       details.push(`Merged ${s.activeBranch} into ${s.branch}`);
     }
@@ -1592,7 +1609,7 @@ var GitConnector = class extends AbstractConnector {
         credentialsPath: state.managedGitconfig.credentialsPath
       });
     } else if (state.targetDir) {
-      this.rebakeRemoteAuth(state.targetDir, state);
+      await this.rebakeRemoteAuth(state.targetDir, state);
     }
     this.log.info("refresh", {
       event: "refresh",
@@ -1662,18 +1679,13 @@ var GitConnector = class extends AbstractConnector {
    * handling is external to this method (managed-gitconfig credential
    * helper refresh in Tier-2 connectors).
    */
-  initInPlace(targetDir, authUrl) {
-    git("init", targetDir, 1e4);
+  async initInPlace(targetDir, authUrl) {
+    await git(["init"], targetDir, 1e4);
     try {
-      git("remote remove origin", targetDir, 5e3);
+      await git(["remote", "remove", "origin"], targetDir, 5e3);
     } catch {
     }
-    execSync(`${gitCommand(targetDir)} remote add origin ${authUrl}`, {
-      cwd: targetDir,
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: "pipe"
-    });
+    await git(["remote", "add", "origin", authUrl], targetDir, 5e3);
   }
   /**
    * True when `<targetDir>/.git` contains at least one resolvable commit
@@ -1684,9 +1696,9 @@ var GitConnector = class extends AbstractConnector {
    * checkout (preserve, don't touch) and a half-initialised one
    * (bootstrap by fetching from origin).
    */
-  isInitialisedCheckout(targetDir) {
+  async isInitialisedCheckout(targetDir) {
     try {
-      git("rev-parse HEAD", targetDir, 5e3);
+      await git(["rev-parse", "HEAD"], targetDir, 5e3);
       return true;
     } catch {
       return false;
@@ -1712,23 +1724,18 @@ var GitConnector = class extends AbstractConnector {
    * the same way `git clone <authUrl>` does — token-rotation handling
    * is external to this connector method.
    */
-  bootstrapFromOrigin(targetDir, branch, authUrl) {
+  async bootstrapFromOrigin(targetDir, branch, authUrl) {
     try {
-      git("remote remove origin", targetDir, 5e3);
+      await git(["remote", "remove", "origin"], targetDir, 5e3);
     } catch {
     }
-    execSync(`${gitCommand(targetDir)} remote add origin ${authUrl}`, {
-      cwd: targetDir,
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: "pipe"
-    });
-    git(`fetch --depth=1 origin ${branch}`, targetDir, 12e4);
-    this.preserveConflictingUntracked(targetDir, branch);
-    git(`checkout -B ${branch} origin/${branch}`, targetDir, 3e4);
-    syncSubmodules(targetDir);
+    await git(["remote", "add", "origin", authUrl], targetDir, 5e3);
+    await git(["fetch", "--depth=1", "origin", branch], targetDir, 12e4);
+    await this.preserveConflictingUntracked(targetDir, branch);
+    await git(["checkout", "-B", branch, `origin/${branch}`], targetDir, 3e4);
+    await syncSubmodules(targetDir);
     try {
-      git(`branch --set-upstream-to=origin/${branch} ${branch}`, targetDir, 5e3);
+      await git(["branch", `--set-upstream-to=origin/${branch}`, branch], targetDir, 5e3);
     } catch {
     }
   }
@@ -1747,10 +1754,10 @@ var GitConnector = class extends AbstractConnector {
    * left untouched — they are pure local additions and survive the
    * bootstrap.
    */
-  preserveConflictingUntracked(targetDir, branch) {
+  async preserveConflictingUntracked(targetDir, branch) {
     let remoteFiles = [];
     try {
-      remoteFiles = git(`ls-tree -r origin/${branch} --name-only`, targetDir, 3e4).split("\n").filter(Boolean);
+      remoteFiles = (await git(["ls-tree", "-r", `origin/${branch}`, "--name-only"], targetDir, 3e4)).split("\n").filter(Boolean);
     } catch (err) {
       this.log.warn("ls-tree failed \u2014 skipping untracked preservation", {
         branch,
@@ -1760,13 +1767,13 @@ var GitConnector = class extends AbstractConnector {
     }
     for (const relPath of remoteFiles) {
       const fullPath = join(targetDir, relPath);
-      if (!existsSync(fullPath)) continue;
+      if (!await pathExists(fullPath)) continue;
       let dest = `${fullPath}.local`;
-      if (existsSync(dest)) {
+      if (await pathExists(dest)) {
         dest = `${fullPath}.local.${Date.now()}`;
       }
       try {
-        renameSync(fullPath, dest);
+        await withFsDeadline(`rename ${fullPath}`, () => rename(fullPath, dest));
         this.log.info("preserved local file as .local", { path: relPath, dest });
       } catch (err) {
         this.log.warn("failed to preserve local file \u2014 checkout may fail", {
@@ -1793,15 +1800,15 @@ var GitConnector = class extends AbstractConnector {
    * carries creds — so the baked-in token must go. Best-effort: a missing
    * origin or a non-http(s) remote (e.g. file:// in tests) is left untouched.
    */
-  stripRemoteInlineToken(targetDir) {
+  async stripRemoteInlineToken(targetDir) {
     try {
-      const current = git("remote get-url origin", targetDir, 5e3);
+      const current = await git(["remote", "get-url", "origin"], targetDir, 5e3);
       if (!current.startsWith("https://") && !current.startsWith("http://")) return;
       const u = new URL(current);
       if (!u.username && !u.password) return;
       u.username = "";
       u.password = "";
-      git(`remote set-url origin ${u.toString()}`, targetDir, 5e3);
+      await git(["remote", "set-url", "origin", u.toString()], targetDir, 5e3);
     } catch (err) {
       this.log.warn("managed-gitconfig: failed to strip inline token from origin", {
         error: err instanceof Error ? err.message : String(err)
@@ -1815,10 +1822,10 @@ var GitConnector = class extends AbstractConnector {
    * a Tier-2 helper this URL token is the sole credential, so it must be
    * refreshed here. No-op for anonymous (no token) or non-https remotes.
    */
-  rebakeRemoteAuth(targetDir, state) {
+  async rebakeRemoteAuth(targetDir, state) {
     if (!state.token || !state.url.startsWith("https://")) return;
     try {
-      git(`remote set-url origin ${this.authUrl(state)}`, targetDir, 5e3);
+      await git(["remote", "set-url", "origin", this.authUrl(state)], targetDir, 5e3);
     } catch (err) {
       this.log.warn("failed to refresh inline token on origin", {
         error: err instanceof Error ? err.message : String(err)
@@ -1830,22 +1837,41 @@ var GitConnector = class extends AbstractConnector {
     if (s.fetchTimer) clearInterval(s.fetchTimer);
     const intervalMs = s.sync.fetchIntervalSec * 1e3;
     s.fetchTimer = setInterval(() => {
+      if (s.fetchInFlight) {
+        this.log.warn("periodic fetch skipped \u2014 previous tick still running", {
+          branch: s.activeBranch,
+          intervalMs
+        });
+        return;
+      }
+      if (s.disposed) return;
+      s.fetchInFlight = true;
+      void this.runPeriodicFetch(s, mountPath).catch((err) => {
+        this.log.debug("periodic fetch failed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }).finally(() => {
+        s.fetchInFlight = false;
+      });
+    }, intervalMs);
+  }
+  /** One periodic-fetch tick. Bails out at each resumption point once disconnected. */
+  async runPeriodicFetch(s, mountPath) {
+    await git(["fetch", "origin"], mountPath, 6e4);
+    if (s.disposed) return;
+    if (s.sync.autoRebase && s.activeBranch !== s.branch) {
       try {
-        git("fetch origin", mountPath, 6e4);
-        if (s.sync.autoRebase && s.activeBranch !== s.branch) {
-          try {
-            git(`rebase origin/${s.branch}`, mountPath, 6e4);
-          } catch {
-            this.resolveConflictsOrAbort(s, mountPath, "rebase");
-          }
-          syncSubmodules(mountPath);
-        } else if (s.sync.autoPull) {
-          git(`pull origin ${s.activeBranch}`, mountPath, 6e4);
-          syncSubmodules(mountPath);
-        }
+        await git(["rebase", `origin/${s.branch}`], mountPath, 6e4);
       } catch {
+        await this.resolveConflictsOrAbort(s, mountPath, "rebase");
       }
-    }, intervalMs);
+      if (s.disposed) return;
+      await syncSubmodules(mountPath);
+    } else if (s.sync.autoPull) {
+      await git(["pull", "origin", s.activeBranch], mountPath, 6e4);
+      if (s.disposed) return;
+      await syncSubmodules(mountPath);
+    }
   }
   // ── Conflict resolution ──────────────────────────────────────────────────
   /**
@@ -1853,17 +1879,17 @@ var GitConnector = class extends AbstractConnector {
    * "theirs" to a .conflict file. If resolution fails entirely, abort.
    * Returns true if conflicts were resolved, false if aborted.
    */
-  resolveConflictsOrAbort(s, mountPath, mode) {
+  async resolveConflictsOrAbort(s, mountPath, mode) {
     try {
-      const conflicted = git("diff --name-only --diff-filter=U", mountPath).split("\n").filter(Boolean);
+      const conflicted = (await git(["diff", "--name-only", "--diff-filter=U"], mountPath)).split("\n").filter(Boolean);
       if (conflicted.length === 0) return false;
       for (const file of conflicted) {
-        this.resolveFileConflict(mountPath, file);
+        await this.resolveFileConflict(mountPath, file);
       }
       if (mode === "rebase") {
-        git("-c core.editor=true rebase --continue", mountPath, 3e4);
+        await git(["-c", "core.editor=true", "rebase", "--continue"], mountPath, 3e4);
       } else {
-        git(`commit --no-edit`, mountPath);
+        await git(["commit", "--no-edit"], mountPath);
       }
       for (const file of conflicted) {
         const ext = file.includes(".") ? file.slice(file.lastIndexOf(".")) : "";
@@ -1878,9 +1904,9 @@ var GitConnector = class extends AbstractConnector {
     } catch {
       try {
         if (mode === "rebase") {
-          git("rebase --abort", mountPath);
+          await git(["rebase", "--abort"], mountPath);
         } else {
-          git("merge --abort", mountPath);
+          await git(["merge", "--abort"], mountPath);
         }
       } catch {
       }
@@ -1890,31 +1916,48 @@ var GitConnector = class extends AbstractConnector {
   /**
    * For a single conflicted file: keep "ours", save "theirs" as .conflict file.
    */
-  resolveFileConflict(root, file) {
+  async resolveFileConflict(root, file) {
     const ext = file.includes(".") ? file.slice(file.lastIndexOf(".")) : "";
     const base = file.includes(".") ? file.slice(0, file.lastIndexOf(".")) : file;
     const conflictPath = `${base}.conflict${ext}`;
     try {
-      const theirs = git(`show :3:${file}`, root);
-      writeFileSync(join(root, conflictPath), theirs);
+      const theirs = await git(["show", `:3:${file}`], root);
+      await withFsDeadline(
+        `write ${conflictPath}`,
+        () => writeFile(join(root, conflictPath), theirs)
+      );
     } catch {
       const fullPath = join(root, file);
-      if (existsSync(fullPath)) {
-        const content = readFileSync(fullPath, "utf-8");
-        writeFileSync(join(root, conflictPath), content);
+      const content = await tryWithFsDeadline(
+        `read ${file}`,
+        () => readFile(fullPath, "utf-8"),
+        null
+      );
+      if (content !== null) {
+        await withFsDeadline(
+          `write ${conflictPath}`,
+          () => writeFile(join(root, conflictPath), content)
+        );
       }
     }
     try {
-      const ours = git(`show :2:${file}`, root);
-      writeFileSync(join(root, file), ours);
+      const ours = await git(["show", `:2:${file}`], root);
+      await withFsDeadline(`write ${file}`, () => writeFile(join(root, file), ours));
     } catch {
       const fullPath = join(root, file);
-      if (existsSync(fullPath)) {
-        const content = readFileSync(fullPath, "utf-8");
-        writeFileSync(fullPath, this.stripConflictKeepOurs(content));
+      const content = await tryWithFsDeadline(
+        `read ${file}`,
+        () => readFile(fullPath, "utf-8"),
+        null
+      );
+      if (content !== null) {
+        await withFsDeadline(
+          `write ${file}`,
+          () => writeFile(fullPath, this.stripConflictKeepOurs(content))
+        );
       }
     }
-    git(`add ${file} ${conflictPath}`, root);
+    await git(["add", file, conflictPath], root);
   }
   stripConflictKeepOurs(content) {
     return content.replace(/<<<<<<< .*\n/g, "").replace(/=======\n[\s\S]*?>>>>>>> .*\n/g, "");
@@ -1922,30 +1965,48 @@ var GitConnector = class extends AbstractConnector {
   // ── Auto-commit on idle ────────────────────────────────────────────────────
   resetAutoCommitTimer(s, mountPath) {
     if (s.lifecycle.autoCommitIdleMs <= 0) return;
+    if (s.disposed) return;
     if (s.autoCommitTimer) clearTimeout(s.autoCommitTimer);
     s.autoCommitTimer = setTimeout(() => {
-      this.performAutoCommit(s, mountPath);
+      s.autoCommitTimer = void 0;
+      if (s.disposed) return;
+      if (s.autoCommitInFlight) {
+        this.log.warn("auto-commit skipped \u2014 previous run still in flight", {
+          branch: s.activeBranch
+        });
+        this.resetAutoCommitTimer(s, mountPath);
+        return;
+      }
+      s.autoCommitInFlight = true;
+      void this.performAutoCommit(s, mountPath).catch((err) => {
+        this.log.debug("auto-commit failed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }).finally(() => {
+        s.autoCommitInFlight = false;
+      });
     }, s.lifecycle.autoCommitIdleMs);
   }
-  performAutoCommit(s, mountPath) {
+  async performAutoCommit(s, mountPath) {
     try {
-      const message = this.generateCommitMessage(mountPath);
-      const result = commitAll(mountPath, message);
-      if (!result) return;
+      const message = await this.generateCommitMessage(mountPath);
+      if (s.disposed) return;
+      const result = await commitAll(mountPath, message);
+      if (!result || s.disposed) return;
       if (s.lifecycle.pushAfterCommit) {
         try {
-          git(`push origin ${s.activeBranch}`, mountPath, 6e4);
+          await git(["push", "origin", s.activeBranch], mountPath, 6e4);
         } catch {
         }
       }
     } catch {
     }
   }
-  generateCommitMessage(mountPath) {
+  async generateCommitMessage(mountPath) {
     try {
-      git("add -A", mountPath);
-      const stat2 = git("diff --cached --stat", mountPath);
-      const lines = stat2.split("\n").filter((l) => l.includes("|"));
+      await git(["add", "-A"], mountPath);
+      const stat5 = await git(["diff", "--cached", "--stat"], mountPath);
+      const lines = stat5.split("\n").filter((l) => l.includes("|"));
       if (lines.length === 0) return "skaile: auto-save";
       const files = lines.map((l) => l.split("|")[0].trim());
       if (files.length === 1) return `Update ${files[0]}`;
@@ -2217,6 +2278,7 @@ function syncFleetManaged2(options) {
   });
   return Promise.resolve({ filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 });
 }
+var COPY_DEADLINE_FACTOR = 20;
 var LocalConnector = class extends AbstractConnector {
   name = "local";
   filesystem = {
@@ -2231,20 +2293,24 @@ var LocalConnector = class extends AbstractConnector {
     }
     const started = Date.now();
     const source = declaration.mount?.source ?? "";
-    this.log.info("mount start", { source, targetDir });
     const sourceDir = resolve(String(source));
-    if (!existsSync(sourceDir)) {
-      this.log.error("connect failed: source path does not exist", void 0, {
-        sourceDir
+    if (isFleetManaged(declaration.id)) {
+      this.log.info("mount handled by host fleet \u2014 skipping local copy", {
+        connectorId: declaration.id,
+        targetDir
       });
-      throw new Error(`Local source path does not exist: ${sourceDir}`);
-    }
-    mkdirSync(targetDir, { recursive: true });
-    const src = resolve(sourceDir);
-    const tgt = resolve(targetDir);
-    if (src !== tgt && !tgt.startsWith(`${src}/`)) {
-      cpSync(src, tgt, { recursive: true });
+      await ensureFleetMounted(targetDir, this.log);
+      this.log.info("mount ok", { targetDir, durationMs: Date.now() - started });
+      return this.makeHandle(
+        declaration,
+        { sourceDir, fleetManaged: true },
+        targetDir
+      );
     }
+    this.log.info("mount start", { source, targetDir });
+    await this.assertSourceExists(sourceDir);
+    await withFsDeadline(`mkdir ${targetDir}`, () => mkdir(targetDir, { recursive: true }));
+    await this.copyTree(sourceDir, targetDir);
     this.log.info("mount ok", { targetDir, durationMs: Date.now() - started });
     return this.makeHandle(declaration, { sourceDir }, targetDir);
   }
@@ -2253,18 +2319,58 @@ var LocalConnector = class extends AbstractConnector {
   }
   async _sync(handle, _options) {
     this.log.debug("sync start");
-    const { sourceDir } = handle.state;
-    const src = resolve(sourceDir);
+    const state = handle.state;
+    if (state.fleetManaged) {
+      this.log.debug("sync skipped \u2014 fleet-managed");
+      return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
+    }
+    const src = resolve(state.sourceDir);
     const tgt = resolve(handle.mountPath);
     if (src === tgt || tgt.startsWith(`${src}/`)) {
       this.log.debug("sync ok (no-op: source equals target)");
       return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
     }
-    mkdirSync(handle.mountPath, { recursive: true });
-    cpSync(src, handle.mountPath, { recursive: true });
+    await withFsDeadline(`mkdir ${tgt}`, () => mkdir(tgt, { recursive: true }));
+    await this.copyTree(src, tgt);
     this.log.debug("sync ok");
     return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
   }
+  /**
+   * Fail with the historical message when the source directory is missing,
+   * while letting a wedged-mount deadline surface as itself.
+   *
+   * The old `existsSync` probe could not tell those apart — and on a hung
+   * mount it never returned at all.
+   */
+  async assertSourceExists(sourceDir) {
+    try {
+      await withFsDeadline(`stat ${sourceDir}`, () => stat(sourceDir));
+    } catch (err) {
+      if (err instanceof FsDeadlineError) {
+        this.log.error("connect failed: source path unreadable (deadline)", err, { sourceDir });
+        throw err;
+      }
+      this.log.error("connect failed: source path does not exist", void 0, { sourceDir });
+      throw new Error(`Local source path does not exist: ${sourceDir}`);
+    }
+  }
+  /**
+   * Recursively copy `src` into `tgt`, skipping the copy when the two overlap.
+   *
+   * The string-overlap guard is a second line of defence behind the
+   * fleet-managed refusal in `connect`: it is a *textual* comparison, so a
+   * source that differs textually while overlapping physically (symlink, bind
+   * mount, `..` segments already normalised away) still slips past it. It stays
+   * because it is free and catches the common container layout.
+   */
+  async copyTree(src, tgt) {
+    if (src === tgt || tgt.startsWith(`${src}/`)) return;
+    await withFsDeadline(
+      `cp -r ${src} -> ${tgt}`,
+      () => cp(src, tgt, { recursive: true }),
+      fsDeadlineMs() * COPY_DEADLINE_FACTOR
+    );
+  }
   watch(handle, callback, options) {
     let fsWatcher = null;
     let closed = false;
@@ -3373,6 +3479,7 @@ function createConnector12() {
   return new PostgresConnector();
 }
 var s3Pkg = "@aws-sdk/client-s3";
+var DOWNLOAD_DEADLINE_FACTOR = 20;
 var S3Connector = class extends AbstractConnector {
   name = "s3";
   /** Optional SDK module override — used in tests to avoid importing the real AWS SDK. */
@@ -3420,7 +3527,7 @@ var S3Connector = class extends AbstractConnector {
     }
     const client = new S3Client(clientConfig);
     const state = { client, bucket, prefix, region };
-    mkdirSync(targetDir, { recursive: true });
+    await withFsDeadline(`mkdir ${targetDir}`, () => mkdir(targetDir, { recursive: true }));
     try {
       const result = await this.downloadAll(state, targetDir);
       this.log.info("mount ok", {
@@ -3451,6 +3558,28 @@ var S3Connector = class extends AbstractConnector {
       throw err;
     }
   }
+  /**
+   * Fetch one object's bytes, or `null` when it yields none.
+   *
+   * S3-side failures are contained here — a single `GetObject` miss is
+   * survivable and must not abort the whole sync. Local filesystem failures are
+   * deliberately *not* in scope: see the write path in {@link downloadAll}.
+   */
+  async fetchObject(s3Mod, state, key) {
+    try {
+      const resp = await state.client.send(
+        new s3Mod.GetObjectCommand({ Bucket: state.bucket, Key: key })
+      );
+      const bytes = await resp.Body?.transformToByteArray();
+      return bytes == null ? null : Buffer.from(bytes);
+    } catch (err) {
+      this.log.warn("object download failed", {
+        key,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
   async downloadAll(state, targetDir) {
     const s3Mod = await this._loadSdk();
     const { client, bucket, prefix } = state;
@@ -3474,23 +3603,32 @@ var S3Connector = class extends AbstractConnector {
     } while (continuationToken);
     let filesWritten = 0;
     let bytesTransferred = 0;
+    const budgetMs = fsDeadlineMs() * DOWNLOAD_DEADLINE_FACTOR;
+    const deadlineAt = Date.now() + budgetMs;
+    const created = /* @__PURE__ */ new Set();
     for (const { key, relPath } of entries) {
-      try {
-        const resp = await client.send(new s3Mod.GetObjectCommand({ Bucket: bucket, Key: key }));
-        const bytes = await resp.Body?.transformToByteArray();
-        if (bytes == null) continue;
-        const body = Buffer.from(bytes);
-        const localPath = join(targetDir, relPath);
-        mkdirSync(dirname(localPath), { recursive: true });
-        writeFileSync(localPath, body);
-        filesWritten++;
-        bytesTransferred += body.byteLength;
-      } catch (err) {
-        this.log.warn("object download failed", {
-          key,
-          error: err instanceof Error ? err.message : String(err)
-        });
+      if (deadlineAt - Date.now() <= 0) {
+        throw new FsDeadlineError(`downloadAll ${targetDir}`, budgetMs);
+      }
+      const body = await this.fetchObject(s3Mod, state, key);
+      if (body == null) continue;
+      const localPath = join(targetDir, relPath);
+      const parent = dirname(localPath);
+      if (!created.has(parent)) {
+        await withFsDeadline(
+          `mkdir ${parent}`,
+          () => mkdir(parent, { recursive: true }),
+          deadlineAt - Date.now()
+        );
+        created.add(parent);
       }
+      await withFsDeadline(
+        `writeFile ${localPath}`,
+        () => writeFile(localPath, body),
+        deadlineAt - Date.now()
+      );
+      filesWritten++;
+      bytesTransferred += body.byteLength;
     }
     return { filesWritten, filesDeleted: 0, bytesTransferred };
   }
@@ -3583,14 +3721,21 @@ var SQLiteConnector = class extends AbstractConnector {
     let db;
     if (dbPath === ":memory:") {
       db = new SQL.Database();
-    } else if (existsSync(dbPath)) {
-      const buffer = readFileSync(dbPath);
-      db = new SQL.Database(buffer);
-    } else if (!isReadonly) {
-      db = new SQL.Database();
     } else {
-      this.log.error("connect failed: db file not found", void 0, { dbPath });
-      throw new Error(`SQLite database not found: ${dbPath}`);
+      let buffer;
+      try {
+        buffer = await withFsDeadline(`readFile ${dbPath}`, () => readFile(dbPath));
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          this.log.error("connect failed: db path unreadable", err, { dbPath });
+          throw err;
+        }
+        if (isReadonly) {
+          this.log.error("connect failed: db file not found", void 0, { dbPath });
+          throw new Error(`SQLite database not found: ${dbPath}`);
+        }
+      }
+      db = buffer ? new SQL.Database(buffer) : new SQL.Database();
     }
     this.log.info("connect ok", { dbPath, durationMs: Date.now() - started });
     if (!isReadonly && dbPath !== ":memory:") {
@@ -3605,7 +3750,7 @@ var SQLiteConnector = class extends AbstractConnector {
     this.log.info("disconnect");
     const { db, dbPath, readonly: isReadonly } = handle.state;
     if (!isReadonly && dbPath !== ":memory:") {
-      this.saveToDisk(db, dbPath);
+      await this.saveToDisk(db, dbPath);
     }
     db.close();
     handle.status = "disconnected";
@@ -3613,13 +3758,18 @@ var SQLiteConnector = class extends AbstractConnector {
   db(handle) {
     return handle.state.db;
   }
-  /** sql.js operates in-memory — flush to disk explicitly. */
-  saveToDisk(db, dbPath) {
+  /** sql.js operates in-memory — flush to disk explicitly. Best-effort, but no
+   *  longer silent: a dropped flush on a wedged mount is lost data, so it warns. */
+  async saveToDisk(db, dbPath) {
     try {
       const data = db.export();
       const buffer = Buffer.from(data);
-      writeFileSync(dbPath, buffer);
-    } catch {
+      await withFsDeadline(`writeFile ${dbPath}`, () => writeFile(dbPath, buffer));
+    } catch (err) {
+      this.log.warn("db flush failed \u2014 changes not persisted", {
+        dbPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   }
   /** Run a query that returns rows. sql.js uses stmt.getAsObject() pattern. */
@@ -3790,7 +3940,7 @@ var SQLiteConnector = class extends AbstractConnector {
         if (!sql) return "Error: sql argument is required";
         const changes = this.runStmt(db, sql);
         if (!state.readonly && state.dbPath !== ":memory:") {
-          this.saveToDisk(db, state.dbPath);
+          await this.saveToDisk(db, state.dbPath);
         }
         return JSON.stringify({ changes });
       }
@@ -3821,7 +3971,7 @@ var StaticServerConnector = class extends AbstractConnector {
     const worktreeDir = String(declaration.options?.worktree_dir ?? DEFAULT_WORKTREE_DIR);
     let repoRoot = null;
     try {
-      repoRoot = findGitRoot(process.cwd());
+      repoRoot = await findGitRoot(process.cwd());
     } catch {
     }
     return this.makeHandle(declaration, {
@@ -3945,7 +4095,10 @@ var StaticServerConnector = class extends AbstractConnector {
     }
     const serveDir = dir;
     const server = createServer((req, res) => {
-      serveStaticFile(serveDir, req.url ?? "/", res);
+      void serveStaticFile(serveDir, req.url ?? "/", res).catch(() => {
+        if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain" });
+        res.end();
+      });
     });
     server.listen(port);
     state.instances.set(label, {
@@ -4014,7 +4167,14 @@ var StaticServerConnector = class extends AbstractConnector {
     };
   }
 };
-function serveStaticFile(rootDir, reqUrl, res) {
+async function statOrNull(filePath) {
+  try {
+    return await withFsDeadline(`stat ${filePath}`, () => stat(filePath));
+  } catch {
+    return void 0;
+  }
+}
+async function serveStaticFile(rootDir, reqUrl, res) {
   const root = resolve(rootDir);
   const pathname = decodeURIComponent(new URL(reqUrl, "http://localhost").pathname);
   let filePath = resolve(root, `.${pathname}`);
@@ -4023,10 +4183,18 @@ function serveStaticFile(rootDir, reqUrl, res) {
     res.end("Forbidden");
     return;
   }
-  if (pathname.endsWith("/") || existsSync(filePath) && statSync(filePath).isDirectory()) {
+  let stats;
+  if (pathname.endsWith("/")) {
     filePath = join(filePath, "index.html");
+    stats = await statOrNull(filePath);
+  } else {
+    stats = await statOrNull(filePath);
+    if (stats?.isDirectory()) {
+      filePath = join(filePath, "index.html");
+      stats = await statOrNull(filePath);
+    }
   }
-  if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+  if (!stats?.isFile()) {
     res.writeHead(404, { "content-type": "text/plain" });
     res.end("Not Found");
     return;
@@ -4361,8 +4529,13 @@ var XStateConnector = class extends AbstractConnector {
     let definition = declaration.options?.machine;
     if (!definition && declaration.options?.definitionPath) {
       const defPath = String(declaration.options.definitionPath);
-      if (!existsSync(defPath)) throw new Error(`Machine definition not found: ${defPath}`);
-      const raw = readFileSync(defPath, "utf-8");
+      let raw;
+      try {
+        raw = await withFsDeadline(`readFile ${defPath}`, () => readFile(defPath, "utf-8"));
+      } catch (err) {
+        if (err instanceof FsDeadlineError) throw err;
+        throw new Error(`Machine definition not found: ${defPath}`);
+      }
       if (defPath.endsWith(".json")) {
         definition = JSON.parse(raw);
       } else {
@@ -5317,7 +5490,7 @@ var ConnectorManager = class {
     if (connector.filesystem != null) {
       const absPath = this.resolveMountTarget(declaration);
       this.reserveMountTarget(declaration.id, absPath);
-      if (!existsSync(absPath)) mkdirSync(absPath, { recursive: true });
+      await withFsDeadline(`mkdir ${absPath}`, () => mkdir(absPath, { recursive: true }));
       ctx.mountTarget = absPath;
     }
     return ctx;
@@ -5370,8 +5543,18 @@ var ConnectorManager = class {
    */
   async connectAll(declarations, options) {
     this.mgrLog.info("connectAll start", { count: declarations.length });
-    for (const decl of declarations) {
-      if (decl.mount != null) this.reserveMountTarget(decl.id, this.resolveMountTarget(decl));
+    const claimed = [];
+    try {
+      for (const decl of declarations) {
+        if (decl.mount == null) continue;
+        const absPath = this.resolveMountTarget(decl);
+        const isNew = !this.mountTargets.has(absPath);
+        this.reserveMountTarget(decl.id, absPath);
+        if (isNew) claimed.push(absPath);
+      }
+    } catch (err) {
+      for (const path of claimed) this.mountTargets.delete(path);
+      throw err;
     }
     const results = [];
     for (const decl of declarations) {
@@ -5447,6 +5630,7 @@ var ConnectorManager = class {
         access: decl.access
       };
     } catch (err) {
+      if (!this.active.has(decl.id)) this.releaseMountTarget(decl.id);
       const msg = err instanceof Error ? err.message : String(err);
       this.mgrLog.error("connect failed", err, { id: decl.id, driver: decl.driver });
       this.opts.onStatusChange?.({
@@ -5514,8 +5698,8 @@ var ConnectorManager = class {
       instance: declaration.id
     });
     connector.setLogger?.(connectorLog);
-    const ctx = await this.buildConnectContext(declaration, connector);
     try {
+      const ctx = await this.buildConnectContext(declaration, connector);
       const handle = await this.withSpan(
         "connector.connect",
         {
@@ -6796,11 +6980,15 @@ var DEFAULT_IGNORED = [
   (p) => p.endsWith("~")
 ];
 var DEFAULT_DEBOUNCE_MS = 150;
-function parseGitignore(rootDir) {
+async function parseGitignore(rootDir) {
   const gitignorePath = join(rootDir, ".gitignore");
-  if (!existsSync(gitignorePath)) return [];
+  const content = await tryWithFsDeadline(
+    `read ${gitignorePath}`,
+    () => readFile(gitignorePath, "utf-8"),
+    null
+  );
+  if (content === null) return [];
   try {
-    const content = readFileSync(gitignorePath, "utf-8");
     const matchers = [];
     for (const raw of content.split("\n")) {
       const line = raw.trim();
@@ -6834,7 +7022,7 @@ var CHOKIDAR_EVENT_MAP = {
 };
 async function createFsWatcher(rootDir, callback, options) {
   const log = createLogger({ kind: "connector", subkind: "watcher", instance: rootDir });
-  const gitignorePatterns = parseGitignore(rootDir);
+  const gitignorePatterns = await parseGitignore(rootDir);
   const optionsIgnored = (options?.ignored ?? []).map(
     (entry) => typeof entry === "string" ? globToMatcher(entry) : entry
   );
@@ -6865,6 +7053,7 @@ async function createFsWatcher(rootDir, callback, options) {
     close: () => watcher.close()
   };
 }
+var execFileAsync3 = promisify(execFile);
 var WorktreeRegistryImpl = class {
   entries = /* @__PURE__ */ new Map();
   register(path, owner) {
@@ -6889,27 +7078,37 @@ var WorktreeRegistryImpl = class {
   }
 };
 var worktreeRegistry = new WorktreeRegistryImpl();
-function git2(args, cwd) {
-  return execSync(`git ${args}`, { cwd, encoding: "utf-8" }).trim();
+var GIT_QUERY_TIMEOUT_MS = 15e3;
+var GIT_WORKTREE_TIMEOUT_MS = 12e4;
+async function git2(args, cwd, timeoutMs) {
+  const { stdout } = await execFileAsync3("git", args, {
+    cwd,
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    killSignal: "SIGKILL"
+  });
+  return stdout.trim();
 }
-function resolveRef(repoRoot, ref) {
-  return git2(`rev-parse --verify ${ref}`, repoRoot);
+async function resolveRef(repoRoot, ref) {
+  return git2(["rev-parse", "--verify", ref], repoRoot, GIT_QUERY_TIMEOUT_MS);
 }
-function findGitRoot(fromDir) {
-  return git2("rev-parse --show-toplevel", fromDir);
+async function findGitRoot(fromDir) {
+  return git2(["rev-parse", "--show-toplevel"], fromDir, GIT_QUERY_TIMEOUT_MS);
 }
 async function createWorktree(opts) {
-  const sha = resolveRef(opts.repoRoot, opts.ref);
+  const sha = await resolveRef(opts.repoRoot, opts.ref);
   const label = opts.label ?? sha.slice(0, 8);
   const wtPath = resolve(opts.baseDir, label);
-  if (!existsSync(opts.baseDir)) {
-    mkdirSync(opts.baseDir, { recursive: true });
-  }
-  git2(`worktree add "${wtPath}" ${sha} --detach`, opts.repoRoot);
+  await withFsDeadline(`mkdir ${opts.baseDir}`, () => mkdir(opts.baseDir, { recursive: true }));
+  await git2(["worktree", "add", wtPath, sha, "--detach"], opts.repoRoot, GIT_WORKTREE_TIMEOUT_MS);
   worktreeRegistry.register(wtPath, opts.owner);
   let branch;
   try {
-    const refName = git2(`rev-parse --abbrev-ref ${opts.ref}`, opts.repoRoot);
+    const refName = await git2(
+      ["rev-parse", "--abbrev-ref", opts.ref],
+      opts.repoRoot,
+      GIT_QUERY_TIMEOUT_MS
+    );
     if (refName !== "HEAD" && refName !== sha) branch = refName;
   } catch {
   }
@@ -6924,15 +7123,19 @@ async function createWorktree(opts) {
         throw new Error(`worktree in use by: ${remaining.join(", ")}`);
       }
       try {
-        git2(`worktree remove "${wtPath}" --force`, opts.repoRoot);
+        await git2(
+          ["worktree", "remove", wtPath, "--force"],
+          opts.repoRoot,
+          GIT_WORKTREE_TIMEOUT_MS
+        );
       } catch {
       }
-      git2("worktree prune", opts.repoRoot);
+      await git2(["worktree", "prune"], opts.repoRoot, GIT_WORKTREE_TIMEOUT_MS);
     }
   };
 }
 async function listWorktrees(repoRoot) {
-  const raw = git2("worktree list --porcelain", repoRoot);
+  const raw = await git2(["worktree", "list", "--porcelain"], repoRoot, GIT_QUERY_TIMEOUT_MS);
   const trees = [];
   let current = {};
   for (const line of raw.split("\n")) {
@@ -7907,5 +8110,5 @@ function createConnector() {
 }
 
 export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, ConnectorFieldMissingError, ConnectorManager, ConnectorStartupError, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, PortPool, PostgresConnector, S3Connector, SQLiteConnector, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, buildConnectorPromptSection, buildSdkConnectorTools, buildSdkFlowTools, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector20, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, ensureDirMode, ensureFleetMounted, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock };
-//# sourceMappingURL=chunk-6POODADP.js.map
-//# sourceMappingURL=chunk-6POODADP.js.map
+//# sourceMappingURL=chunk-HOL5KD7U.js.map
+//# sourceMappingURL=chunk-HOL5KD7U.js.map