@skaile/workspaces 6.8.0 → 6.8.1

package/dist/{chunk-LJ6PLEDU.js → chunk-NAEXYRHR.js}

@@ -1,5 +1,5 @@
 import { declaredConnectErrorKind, ClassifiedConnectError, withConnectErrorKind } from './chunk-BRPEW3UL.js';
-import { readUnavailableMarker, OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, ConnectorStartupError, resolveAuthRef } from './chunk-ZBA4P5TD.js';
+import { readUnavailableMarker, OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, ConnectorStartupError, resolveAuthRef } from './chunk-SAL72A7T.js';
 import { EventNormalizer } from './chunk-XIIIGLSL.js';
 import { resolveModelTier } from './chunk-SBNUXJ6E.js';
 import { createHarness } from './chunk-SILFO5RY.js';
@@ -8282,33 +8282,100 @@ async function isMountpoint(dir, mountinfoPath) {
 async function probeFleetMount(dir, mountinfoPath, { list }) {
   const st = await stat(dir);
   if (!st.isDirectory()) {
-    throw new Error(`fleet mountpoint ${dir} is not a directory`);
+    throw new FleetMountDeadError(`fleet mountpoint ${dir} is not a directory`);
   }
   if (list) await readdir(dir);
   if (await isMountpoint(dir, mountinfoPath) === false) {
-    throw new Error(
+    throw new FleetMountDeadError(
       `fleet mountpoint ${dir} is a plain directory, not a mount \u2014 the host bind is absent or landed on a different path`
     );
   }
 }
+var FleetMountDeadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FleetMountDeadError";
+  }
+};
+var DEAD_ERRNO_CODES = /* @__PURE__ */ new Set([
+  "ENOENT",
+  "ENOTCONN",
+  "ENOTDIR",
+  "EACCES",
+  "EPERM",
+  "ELOOP"
+]);
+function classifyProbeFailure(err) {
+  if (err instanceof FleetMountDeadError) return "dead";
+  const code = err?.code;
+  if (typeof code === "string" && DEAD_ERRNO_CODES.has(code)) return "dead";
+  return "pending";
+}
+var FLEET_MOUNT_CONNECTING_CODE = "FLEET_MOUNT_CONNECTING";
+var FleetMountConnectingError = class extends Error {
+  code = FLEET_MOUNT_CONNECTING_CODE;
+  dir;
+  constructor(dir, message, options) {
+    super(message, options);
+    this.name = "FleetMountConnectingError";
+    this.dir = dir;
+  }
+};
+function isFleetMountConnectingError(err) {
+  return err instanceof Error && err.code === FLEET_MOUNT_CONNECTING_CODE;
+}
+var inflightProbes = /* @__PURE__ */ new Map();
+function sharedListingProbe(dir, mountinfoPath) {
+  const key = `${dir}\0${mountinfoPath}`;
+  const running = inflightProbes.get(key);
+  if (running) return running;
+  const probe = probeFleetMount(dir, mountinfoPath, { list: true }).finally(() => {
+    if (inflightProbes.get(key) === probe) inflightProbes.delete(key);
+  });
+  probe.catch(() => {
+  });
+  inflightProbes.set(key, probe);
+  return probe;
+}
 async function ensureFleetMounted(dir, log, options) {
   const timeoutMs = options?.timeoutMs ?? 3e3;
   const pollIntervalMs = options?.pollIntervalMs ?? 100;
   const mountinfoPath = options?.mountinfoPath ?? testMountinfoOverride() ?? MOUNTINFO_PATH;
+  const raceDeadline = options?.deadline ?? withFsDeadline;
   const deadline = Date.now() + timeoutMs;
-  let lastErr = null;
+  let lastAnswer = null;
+  let lastMiss = null;
+  let lastWasMiss = false;
   while (Date.now() < deadline) {
+    const budget = Math.max(1, deadline - Date.now());
     try {
-      await probeFleetMount(dir, mountinfoPath, { list: true });
+      await raceDeadline(
+        `fleet readiness ${dir}`,
+        () => sharedListingProbe(dir, mountinfoPath),
+        budget
+      );
       log.info("fleet bind mount verified", { dir });
       return;
     } catch (err) {
-      lastErr = err;
+      lastWasMiss = err instanceof FsDeadlineError;
+      if (lastWasMiss) lastMiss = { err, fair: budget * 2 >= timeoutMs };
+      else lastAnswer = err;
+      if (deadline - Date.now() < 2 * pollIntervalMs) break;
       await new Promise((resolve9) => setTimeout(resolve9, pollIntervalMs));
+      if (deadline - Date.now() < pollIntervalMs) break;
     }
   }
-  throw new Error(
-    `fleet mount ${dir} not ready after ${timeoutMs}ms \u2014 check SKAILE_FLEET_MANAGED_MOUNTS env var and host bind: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+  const deciding = lastWasMiss && lastMiss !== null && (lastMiss.fair || lastAnswer === null) ? lastMiss.err : lastAnswer ?? lastMiss?.err ?? null;
+  const detail = deciding instanceof Error ? deciding.message : String(deciding);
+  if (deciding !== null && classifyProbeFailure(deciding) === "dead") {
+    throw new Error(
+      `fleet mount ${dir} not ready after ${timeoutMs}ms \u2014 check SKAILE_FLEET_MANAGED_MOUNTS env var and host bind: ${detail}`
+    );
+  }
+  throw new FleetMountConnectingError(
+    dir,
+    `fleet mount ${dir} is still connecting: its readiness check did not pass within ${timeoutMs}ms (${detail})`,
+    { cause: deciding }
   );
 }
 var LIVENESS_TIMEOUT_MS = 2e3;
@@ -8460,6 +8527,19 @@ var MountLedger = class {
 };
 
 // connectors/src/connector-manager.ts
+var FLEET_RETRY_INITIAL_DELAY_MS = 1e3;
+var FLEET_RETRY_MAX_DELAY_MS = 3e4;
+function fleetMountConnectingMessage(id) {
+  return `Mount "${id}" is still connecting: its first readiness check has not passed yet, so nothing is read from or written to it. Retry shortly.`;
+}
+var ConnectorConnectingError = class extends Error {
+  connectorId;
+  constructor(id) {
+    super(fleetMountConnectingMessage(id));
+    this.name = "ConnectorConnectingError";
+    this.connectorId = id;
+  }
+};
 var KNOWN_PREFIXES = ["env:", "forge:", "op:", "kp:", "oauth:"];
 function missingTokenMediatorMessage(connectorId) {
   return `Connector '${connectorId}' uses 'auth: backend' but no token mediator is wired (standalone CLI does not have one \u2014 use 'pat:env:NAME' instead).`;
@@ -8601,6 +8681,11 @@ var ConnectorManager = class {
   mgrLog;
   /** Aborted on dispose; threaded into every `connect()` via `ctx.abortSignal`. */
   disposeController = new AbortController();
+  /**
+   * The last `watchAll` arguments, so a mount that turns live after it ran
+   * (a still-connecting fleet mount) gets its watcher then.
+   */
+  watchRequest;
   // ── Private helpers ──────────────────────────────────────────────────────────
   /**
    * Wrap the user-supplied `TokenMediator` so `reason: 'initial'` calls for an
@@ -8885,6 +8970,17 @@ var ConnectorManager = class {
         continue;
       }
       const outcome = await this.runConnect(decl);
+      if (outcome.ok && outcome.connecting) {
+        results.push({
+          id: decl.id,
+          connected: false,
+          connecting: true,
+          mountPath: outcome.handle.mountPath,
+          error: fleetMountConnectingMessage(decl.id),
+          access: decl.access
+        });
+        continue;
+      }
       if (outcome.ok) {
         results.push({
           id: decl.id,
@@ -8900,13 +8996,14 @@ var ConnectorManager = class {
     const report = { results };
     this.mgrLog.info("connectAll complete", {
       connected: results.filter((r) => r.connected).length,
-      failed: results.filter((r) => !r.connected).length
+      connecting: results.filter((r) => r.connecting).length,
+      failed: results.filter((r) => !r.connected && !r.connecting).length
     });
     if (options?.failOnReadWriteError) {
       const declById = new Map(declarations.map((d) => [d.id, d]));
       const failedRw = results.filter((r) => {
         const decl = declById.get(r.id);
-        return !r.connected && decl !== void 0 && resolveAccessPolicy(decl).required;
+        return !r.connected && !r.connecting && decl !== void 0 && resolveAccessPolicy(decl).required;
       }).map((r) => ({ id: r.id, error: r.error ?? "unknown error" }));
       for (const f of failedRw) {
         const decl = declById.get(f.id);
@@ -8948,6 +9045,8 @@ var ConnectorManager = class {
       connectorId: decl.id,
       status: "connecting"
     });
+    let connector;
+    let ctx;
     try {
       if (typeof decl.driver !== "string" || decl.driver === "") {
         throw new ClassifiedConnectError(
@@ -8955,7 +9054,7 @@ var ConnectorManager = class {
           "config"
         );
       }
-      const connector = await this.resolveConnector(decl.driver);
+      connector = await this.resolveConnector(decl.driver);
       connector.setLogger?.(
         createLogger({
           kind: "connector",
@@ -8963,7 +9062,8 @@ var ConnectorManager = class {
           instance: decl.id
         })
       );
-      const ctx = await this.buildConnectContext(decl, connector);
+      ctx = await this.buildConnectContext(decl, connector);
+      const live = { connector, ctx };
       const handle = await this.withSpan(
         "connector.connect",
         {
@@ -8971,7 +9071,7 @@ var ConnectorManager = class {
           "skaile.connector.driver": decl.driver,
           "skaile.connector.operation": "connect"
         },
-        () => connector.connect(decl, ctx)
+        () => live.connector.connect(decl, live.ctx)
       );
       this.active.set(decl.id, { connector, handle, declaration: decl });
       this.mounts.commit(decl.id);
@@ -8983,6 +9083,8 @@ var ConnectorManager = class {
       });
       return { ok: true, handle };
     } catch (err) {
+      const pending = connector && ctx ? this.registerConnecting(decl, connector, ctx, err) : void 0;
+      if (pending) return { ok: true, handle: pending, connecting: true };
       const live = this.active.get(decl.id);
       await this.mounts.rollback(
         decl.id,
@@ -9010,6 +9112,122 @@ var ConnectorManager = class {
       return { ok: false, error: err, message, ...errorKind ? { errorKind } : {} };
     }
   }
+  /**
+   * Keep a fleet mount whose readiness check missed its deadline (or failed
+   * transiently) registered as `connecting`, and retry it in the background.
+   * Returns the provisional handle, or `undefined` when `err` is not that case
+   * and the connect is a plain failure.
+   *
+   * The provisional handle has status `connecting`, so every path that writes
+   * back or acts on the mount (sync, hibernate/close hooks, watchers, tool
+   * calls, the runner's resource requests) skips or refuses it until it is live.
+   * No `connected` or `error` status is sent until a retry gives a verdict.
+   */
+  registerConnecting(decl, connector, ctx, err) {
+    if (!isFleetMountConnectingError(err)) return void 0;
+    if (connector.filesystem == null || ctx.mountTarget === void 0) return void 0;
+    if (this.active.has(decl.id)) return void 0;
+    if (this.disposeController.signal.aborted) return void 0;
+    const handle = {
+      id: decl.id,
+      driver: connector.name ?? decl.driver,
+      access: decl.access,
+      status: "connecting",
+      mountPath: ctx.mountTarget,
+      state: { fleetManaged: true }
+    };
+    const entry = { connector, handle, declaration: decl };
+    this.active.set(decl.id, entry);
+    this.mounts.commit(decl.id);
+    this.failedConnectors.delete(decl.id);
+    this.mgrLog.warn("fleet mount still connecting; retrying in the background", {
+      id: decl.id,
+      driver: decl.driver,
+      error: scrubLogText(err instanceof Error ? err.message : String(err))
+    });
+    this.retryConnecting(entry, ctx).catch((loopErr) => {
+      this.mgrLog.error("fleet mount retry loop failed", void 0, {
+        id: decl.id,
+        error: scrubLogText(loopErr instanceof Error ? loopErr.message : String(loopErr))
+      });
+    });
+    return handle;
+  }
+  /**
+   * Retry a `connecting` fleet mount with a doubling wait until it connects,
+   * fails with a dead verdict, or its entry is disconnected or replaced. The
+   * retry is the driver's own `connect`, so a driver that does more after the
+   * readiness check (git: branch, watcher) does it once the mount answers.
+   */
+  async retryConnecting(entry, ctx) {
+    const { declaration: decl, connector } = entry;
+    const signal = this.disposeController.signal;
+    const initial = this.opts.fleetMountRetry?.initialDelayMs ?? FLEET_RETRY_INITIAL_DELAY_MS;
+    const max = this.opts.fleetMountRetry?.maxDelayMs ?? FLEET_RETRY_MAX_DELAY_MS;
+    const current = () => !signal.aborted && this.active.get(decl.id) === entry;
+    let delay = initial;
+    let attempts = 0;
+    while (true) {
+      await abortableDelay(delay, signal);
+      if (!current()) return;
+      attempts++;
+      let handle;
+      try {
+        handle = await connector.connect(decl, ctx);
+      } catch (err) {
+        if (!current()) return;
+        if (isFleetMountConnectingError(err)) {
+          delay = Math.min(delay * 2, max);
+          continue;
+        }
+        this.failConnecting(entry, err);
+        return;
+      }
+      if (!current()) {
+        await connector.disconnect(handle).catch(() => {
+        });
+        return;
+      }
+      entry.handle = handle;
+      this.mgrLog.info("fleet mount connected after retry", { id: decl.id, attempts });
+      this.opts.onStatusChange?.({
+        type: "connector_status",
+        connectorId: decl.id,
+        status: "connected"
+      });
+      this.startWatcher(decl.id, entry);
+      return;
+    }
+  }
+  /** A background retry of a `connecting` mount got a dead verdict: fail it as a connect would. */
+  failConnecting(entry, err) {
+    const decl = entry.declaration;
+    this.active.delete(decl.id);
+    this.mounts.release(decl.id);
+    const message = redactCredentials(err instanceof Error ? err.message : String(err));
+    this.recordFailure(decl, message);
+    const errorKind = classifyConnectError(err);
+    this.mgrLog.error("fleet mount failed while connecting", void 0, {
+      id: decl.id,
+      driver: decl.driver,
+      error: scrubLogText(message),
+      ...errorKind ? { errorKind } : {}
+    });
+    this.opts.onStatusChange?.({
+      type: "connector_status",
+      connectorId: decl.id,
+      status: "error",
+      error: message,
+      ...errorKind ? { errorKind } : {}
+    });
+  }
+  /**
+   * Throw {@link ConnectorConnectingError} when `entry` is a mount still
+   * `connecting`: work on it would land on a path not yet verified.
+   */
+  assertNotConnecting(id, entry) {
+    if (entry.handle.status === "connecting") throw new ConnectorConnectingError(id);
+  }
   /**
    * Fail `decl` with the error a previous build's `connectAll` carried over,
    * without calling its driver. Same records and events as a failed attempt.
@@ -9054,7 +9272,7 @@ var ConnectorManager = class {
     await this.unwatchAll();
     for (const [id, entry] of this.active) {
       try {
-        await entry.connector.disconnect(entry.handle);
+        if (entry.handle.status !== "connecting") await entry.connector.disconnect(entry.handle);
       } catch {
       }
       this.opts.onStatusChange?.({
@@ -9066,6 +9284,7 @@ var ConnectorManager = class {
     this.active.clear();
     this.mounts.clear();
     this.failedConnectors.clear();
+    this.watchRequest = void 0;
     this.mgrLog.info("disconnectAll complete");
   }
   // ── Hot-plug ──────────────────────────────────────────────────────────────────
@@ -9073,6 +9292,13 @@ var ConnectorManager = class {
    * Connect a single connector (hot-plug). Resolves fields and allocates
    * mount target if the connector has a filesystem face.
    *
+   * A fleet mount whose readiness check missed its deadline resolves too, with
+   * a provisional handle whose `status` is `"connecting"`: it is registered and
+   * retried in the background, and `onStatusChange` reports `connected` (or
+   * `error`) when a retry decides. Until then its `mountPath` is unverified:
+   * a caller must check `status === "connected"` before it reads or writes
+   * there itself.
+   *
    * @returns The `ConnectorHandle` for subsequent operations.
    */
   async connect(declaration) {
@@ -9130,7 +9356,7 @@ var ConnectorManager = class {
       },
       async () => {
         try {
-          await entry.connector.disconnect(entry.handle);
+          if (entry.handle.status !== "connecting") await entry.connector.disconnect(entry.handle);
         } finally {
           this.active.delete(id);
           this.failedConnectors.delete(id);
@@ -9150,33 +9376,44 @@ var ConnectorManager = class {
    * For filesystem-face connectors, nested-mount-path exclusion logic is applied.
    */
   watchAll(callback, options) {
-    const allMountPaths = [...this.active.values()].map((e) => e.handle.mountPath).filter((p) => p != null);
-    for (const [id, entry] of this.active) {
-      if (!entry.connector.watch) continue;
-      if (!resolveAccessPolicy(entry.declaration).watch) continue;
-      let mergedOptions = options;
-      const myPath = entry.handle.mountPath;
-      if (myPath) {
-        const nestedPaths = allMountPaths.filter((p) => p !== myPath && p.startsWith(`${myPath}/`)).map((p) => `${p}/**`);
-        if (nestedPaths.length > 0) {
-          mergedOptions = {
-            ...options,
-            ignored: [...options?.ignored ?? [], ...nestedPaths]
-          };
-        }
-      }
-      try {
-        entry.watchHandle = entry.connector.watch(
-          entry.handle,
-          (event) => callback(id, event),
-          mergedOptions
-        );
-      } catch {
+    this.watchRequest = { callback, ...options !== void 0 ? { options } : {} };
+    for (const [id, entry] of this.active) this.startWatcher(id, entry);
+  }
+  /**
+   * Start `entry`'s watcher for the last `watchAll` request, if there was one
+   * and the connector watches. A still-connecting mount is skipped: its path
+   * is not verified, and its watcher starts when it connects.
+   */
+  startWatcher(id, entry) {
+    const request = this.watchRequest;
+    if (!request) return;
+    if (!entry.connector.watch) return;
+    if (entry.handle.status === "connecting") return;
+    if (!resolveAccessPolicy(entry.declaration).watch) return;
+    const { callback, options } = request;
+    let mergedOptions = options;
+    const myPath = entry.handle.mountPath;
+    if (myPath) {
+      const nestedPaths = [...this.active.values()].map((e) => e.handle.mountPath).filter((p) => p != null && p !== myPath && p.startsWith(`${myPath}/`)).map((p) => `${p}/**`);
+      if (nestedPaths.length > 0) {
+        mergedOptions = {
+          ...options,
+          ignored: [...options?.ignored ?? [], ...nestedPaths]
+        };
       }
     }
+    try {
+      entry.watchHandle = entry.connector.watch(
+        entry.handle,
+        (event) => callback(id, event),
+        mergedOptions
+      );
+    } catch {
+    }
   }
-  /** Stop all active watchers. */
+  /** Stop all active watchers. A mount that turns live later is not watched either. */
   async unwatchAll() {
+    this.watchRequest = void 0;
     for (const [, entry] of this.active) {
       if (entry.watchHandle) {
         try {
@@ -9302,6 +9539,7 @@ var ConnectorManager = class {
     if (!entry.connector.filesystem) {
       throw new Error(`Connector "${id}" has no filesystem face`);
     }
+    this.assertNotConnecting(id, entry);
     await this.assertMountNotDead(id);
     return entry.connector.filesystem.sync(entry.handle, options);
   }
@@ -9354,6 +9592,14 @@ var ConnectorManager = class {
    */
   async checkMountHealth(id) {
     const entry = this.active.get(id);
+    if (entry?.handle.status === "connecting") {
+      return {
+        status: "stale",
+        errorClass: "mount_connecting",
+        detail: fleetMountConnectingMessage(id),
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
     if (!entry || entry.handle.status !== "connected") return null;
     const host = this.fleetHealthVerdicts.get(id);
     const liveness = await this.checkMountLiveness(id);
@@ -9431,6 +9677,7 @@ var ConnectorManager = class {
   }
   async read(id, path) {
     const entry = this.get(id);
+    this.assertNotConnecting(id, entry);
     const tools = this.requireToolFace(id, entry);
     if (!tools.read) {
       throw new Error(`Connector "${id}" tool face does not implement "read"`);
@@ -9447,6 +9694,7 @@ var ConnectorManager = class {
   }
   async write(id, path, content) {
     const entry = this.get(id);
+    this.assertNotConnecting(id, entry);
     if (entry.declaration.access === "read-only") {
       throw new Error(`Connector "${id}" is read-only`);
     }
@@ -9466,6 +9714,7 @@ var ConnectorManager = class {
   }
   async delete(id, path) {
     const entry = this.get(id);
+    this.assertNotConnecting(id, entry);
     if (entry.declaration.access === "read-only") {
       throw new Error(`Connector "${id}" is read-only`);
     }
@@ -9485,6 +9734,7 @@ var ConnectorManager = class {
   }
   async list(id, path, options) {
     const entry = this.get(id);
+    this.assertNotConnecting(id, entry);
     const tools = this.requireToolFace(id, entry);
     if (!tools.list) {
       throw new Error(`Connector "${id}" tool face does not implement "list"`);
@@ -9501,6 +9751,7 @@ var ConnectorManager = class {
   }
   async search(id, query, options) {
     const entry = this.get(id);
+    this.assertNotConnecting(id, entry);
     const tools = this.requireToolFace(id, entry);
     if (!tools.search) {
       throw new Error(`Connector "${id}" tool face does not implement "search"`);
@@ -9524,6 +9775,7 @@ var ConnectorManager = class {
    */
   async executeOp(id, operation, args) {
     const entry = this.get(id);
+    this.assertNotConnecting(id, entry);
     const tools = this.requireToolFace(id, entry);
     const ops = tools.describeOperations(entry.handle);
     const opDesc = ops.find((o) => o.name === operation);
@@ -9583,6 +9835,19 @@ var ConnectorManager = class {
     return buildSkillBody(descriptor, ops, shellAccess);
   }
 };
+function abortableDelay(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve9) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve9();
+    };
+    const timer = setTimeout(done, ms);
+    timer.unref?.();
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 function redactMarker(marker) {
   return {
     ...marker,
@@ -10073,16 +10338,16 @@ function buildFilesystemSection(manager, fsConnectors, toolsMounted) {
       lines.push(`| ${c.id} | ${c.driver} | \`${mountPath}/\` | ${c.access} |`);
     } else {
       anyUnavailable = true;
-      const state = c.status === "error" ? "failed" : "syncing";
+      const state = c.status === "error" ? "failed" : "connecting";
       lines.push(
-        `| ${c.id} | ${c.driver} | \`${mountPath}/\` | unavailable (${state}) \u2014 read-only, do not write |`
+        `| ${c.id} | ${c.driver} | \`${mountPath}/\` | unavailable (${state}) \u2014 do not write |`
       );
     }
   }
   if (anyUnavailable) {
     lines.push("");
     lines.push(
-      "> **Unavailable mounts are read-only at the filesystem layer.** A mount marked `unavailable (syncing / failed)` is not live yet \u2014 its directory is mounted read-only, so writes fail. Do not create files there: the contents are not the real workspace, and anything you write would be a phantom that diverges from the remote once it mounts. Wait for it to become writable (watch the connector status)."
+      `> **Unavailable mounts are not live yet.** A mount marked \`unavailable (connecting)\` has not answered its first readiness check; the runner keeps retrying and the mount turns live without a restart. Until then nothing is synced from or to it, and requests addressed to it fail with \`still connecting \u2026 Retry shortly\`. Do not create files there: anything you write would not be the real workspace. Check again (${toolsMounted ? "`connector_list`" : "`skaile connector list`"}) before writing.`
     );
   }
   if (fsConnectors.some((c) => isFleetManaged2(manager, c.id))) {
@@ -13717,6 +13982,6 @@ function describeFlowOperations() {
   return new FlowAdapter().tools.describeOperations({ access: "read-write" });
 }
 
-export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, CONNECT_FAILURE_CARRY_OVER_TTL_MS, ClassifierSubpromptRunner, ConnectFailureCarryOver, ConnectorManager, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, NO_ACTIVE_FLOW_ERROR, PortPool, PostgresConnector, S3Connector, S3FetchStoppedError, S3PresignedRequestError, S3_PRESIGN_BATCH, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SessionSubpromptRunner, SharePointConnector, StaticServerConnector, SubFlowContractError, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, atomicReplaceCredential, buildConnectorListPayload, buildConnectorPromptSection, buildConnectorToolDefs, buildFlowPromptEvent, buildFlowToolDefs, buildLazyFlowToolDefs, buildLazySdkFlowTools, buildSdkConnectorTools, buildSdkFlowTools, checkFleetMountLiveness, classifierQuestion, classifyConnectError, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector20, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, describeFlowOperations, driveOrchestratorTurn, ensureDirMode, ensureFleetMounted, ensureRefreshAttemptStamp, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, missingTokenMediatorMessage, normalizeRuntimeFlow, parseListObjectsV2, presignScopePrefix, presignableKey, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, resolveAccessPolicy, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock, writeUserGitconfigInclude };
-//# sourceMappingURL=chunk-LJ6PLEDU.js.map
-//# sourceMappingURL=chunk-LJ6PLEDU.js.map
+export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, CONNECT_FAILURE_CARRY_OVER_TTL_MS, ClassifierSubpromptRunner, ConnectFailureCarryOver, ConnectorConnectingError, ConnectorManager, DeployConnector, DevServerConnector, FleetMountConnectingError, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, NO_ACTIVE_FLOW_ERROR, PortPool, PostgresConnector, S3Connector, S3FetchStoppedError, S3PresignedRequestError, S3_PRESIGN_BATCH, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SessionSubpromptRunner, SharePointConnector, StaticServerConnector, SubFlowContractError, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, atomicReplaceCredential, buildConnectorListPayload, buildConnectorPromptSection, buildConnectorToolDefs, buildFlowPromptEvent, buildFlowToolDefs, buildLazyFlowToolDefs, buildLazySdkFlowTools, buildSdkConnectorTools, buildSdkFlowTools, checkFleetMountLiveness, classifierQuestion, classifyConnectError, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector20, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, describeFlowOperations, driveOrchestratorTurn, ensureDirMode, ensureFleetMounted, ensureRefreshAttemptStamp, findGitRoot, findMissingPackages, fleetMountConnectingMessage, getConnector, installNpmPackages, isFleetManaged, isFleetMountConnectingError, isPackageResolvable, listConnectors, listWorktrees, missingTokenMediatorMessage, normalizeRuntimeFlow, parseListObjectsV2, presignScopePrefix, presignableKey, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, resolveAccessPolicy, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock, writeUserGitconfigInclude };
+//# sourceMappingURL=chunk-NAEXYRHR.js.map
+//# sourceMappingURL=chunk-NAEXYRHR.js.map