@skaile/workspaces 4.34.0 → 4.36.0

package/dist/{chunk-OWN2W2IW.js → chunk-FWZTKSYI.js}

@@ -1,11 +1,11 @@
 import { declaredConnectErrorKind, ClassifiedConnectError, withConnectErrorKind } from './chunk-ZWTCXL3H.js';
-import { OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, resolveAuthRef, readUnavailableMarker, ConnectorStartupError } from './chunk-DHLE66FV.js';
-import { EventNormalizer } from './chunk-NVQLE4MK.js';
-import { resolveModelTier } from './chunk-75LXFKQR.js';
-import { createDriver } from './chunk-MTWZ7KHZ.js';
+import { OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, resolveAuthRef, readUnavailableMarker, ConnectorStartupError } from './chunk-S63H4HDH.js';
+import { EventNormalizer } from './chunk-3VUHHDZW.js';
+import { resolveModelTier } from './chunk-O63QZ6XX.js';
+import { createDriver } from './chunk-MQU632EK.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
-import { interpolateNodeInstruction, resolveNodeBindings, validateConsumedNodeOutput, appendAttempt, resolveTerminalFailureStatus, remainingActiveExecutionMs, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, persistedRouterSelection } from './chunk-7HJ6SFFF.js';
+import { interpolateNodeInstruction, resolveNodeBindings, validateConsumedNodeOutput, appendAttempt, resolveTerminalFailureStatus, remainingActiveExecutionMs, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, persistedRouterSelection } from './chunk-FLGLODDF.js';
 import { INPUT_SCHEMA_SHAPES_HINT, coerceInputSchema } from './chunk-YYH5EVPM.js';
 import { parseFlowDefinition } from './chunk-DIQDYNXZ.js';
 import { describeStimulus, buildOrchestratorPrompt, renderSubpromptPrompt, renderStimulusPrompt } from './chunk-K3IBZ2UZ.js';
@@ -13,7 +13,7 @@ import { deterministicNodeKindLabel, nodeInstruction, flowDefaults, isAgentNode,
 import { classifierDecision, getConsumedOutputSchema, withoutReservedClassifierFields, FLOW_CAPTURE_CHANNELS, captureDestinationFieldName, invalidCaptureDestinationMessage } from './chunk-ORH2BZEM.js';
 import { withActivityLabelDefs } from './chunk-JS7DCCDA.js';
 import { processAlive } from './chunk-4GY63JU6.js';
-import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-2FBPAR2V.js';
+import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-SQ7IN7KR.js';
 import { portableSpawn } from './chunk-ICSCSM5D.js';
 import { createLogger, redactCredentials } from './chunk-BOFL7GIF.js';
 import { resolve, relative, sep, isAbsolute, join, dirname } from 'path';
@@ -1534,6 +1534,28 @@ function resolveGitConfig(args) {
     lifecycle: parseLifecycleConfig(args.options, defaults.lifecycle)
   };
 }
+function applyReadOnly(config, options) {
+  const rawSync = options?.sync ?? {};
+  return {
+    session: { ...config.session, enabled: false },
+    sync: {
+      fetchIntervalSec: rawSync.fetchIntervalSec != null ? config.sync.fetchIntervalSec : MODE_DEFAULTS.sync.sync.fetchIntervalSec,
+      autoRebase: false,
+      autoPull: true
+    },
+    lifecycle: {
+      commitOnHibernate: false,
+      pushOnHibernate: false,
+      mergeOnClose: false,
+      pushOnClose: false,
+      autoCommitIdleMs: 0,
+      pushAfterCommit: false,
+      publishOnCreate: false
+    }
+  };
+}
+var READ_ONLY_PUSH_URL = "DISABLED";
+var READ_ONLY_HOOK_DETAIL = "read-only mount: nothing committed or pushed";
 var modeLog = createLogger({ kind: "connector", subkind: "git" });
 var REFRESH_LEAD_MS = 5 * 60 * 1e3;
 var MIN_REFRESH_DELAY_MS = 3e4;
@@ -2072,6 +2094,7 @@ async function assertOriginIsMount(s, cwd, op) {
     ["remote", "get-url", "--push", "origin"]
   ]) {
     const actual = await gitOrNull(args, cwd);
+    if (s.readOnly && args.includes("--push") && actual === READ_ONLY_PUSH_URL) continue;
     if (actual === null || comparableRemoteUrl(actual) !== expected) {
       throw new Error(
         `git ${op}: origin${args.includes("--push") ? " (push)" : ""} resolves to ${actual === null ? "nothing" : redactCredentials(actual)}, not this mount's remote ${expected}. Remove the pushurl / insteadOf / url override from the git config first.`
@@ -2461,10 +2484,9 @@ var GitConnector = class extends AbstractConnector {
       this.log.info("mount start", { url, branch, targetDir });
       this.clearUnavailableCredentialHelper(declaration.id, url);
       const initial = await this.acquireInitialToken(declaration, secrets, tokenMediator);
-      const { session, sync, lifecycle } = resolveGitConfig({
-        mode: declaration.mode,
-        options: opts
-      });
+      const readOnly = declaration.access === "read-only" && declaration.accessDefaulted !== true;
+      const resolved = resolveGitConfig({ mode: declaration.mode, options: opts });
+      const { session, sync, lifecycle } = readOnly ? applyReadOnly(resolved, opts) : resolved;
       const state = {
         url,
         branch,
@@ -2474,7 +2496,8 @@ var GitConnector = class extends AbstractConnector {
         sync,
         lifecycle,
         targetDir,
-        tokenMediator: initial.authRef?.kind === "backend" ? tokenMediator : void 0
+        tokenMediator: initial.authRef?.kind === "backend" ? tokenMediator : void 0,
+        readOnly
       };
       await this.prepareCheckout(
         targetDir,
@@ -2491,9 +2514,6 @@ var GitConnector = class extends AbstractConnector {
         }
         await this.checkoutSessionBranch(state, session, targetDir);
       }
-      if (sync.fetchIntervalSec > 0) {
-        this.startPeriodicFetch(state, targetDir);
-      }
       if (declaration.mount?.exposeAccessToken === true) {
         try {
           if (initial.token && (url.startsWith("https://") || url.startsWith("http://")) && process.env.GIT_CONFIG_GLOBAL) {
@@ -2542,6 +2562,18 @@ var GitConnector = class extends AbstractConnector {
         }
       }
       await ensureSkaileExcluded(targetDir, this.log);
+      if (readOnly) {
+        state.readOnlySaveOwed = await gitOrNull(["config", "--get", "remote.origin.pushurl"], targetDir) !== READ_ONLY_PUSH_URL;
+        await this.withMountLock(
+          state,
+          () => this.refreshReadOnly(state, targetDir, { tolerateFetchFailure: true })
+        );
+      } else {
+        await this.applyPushGuard(state, targetDir);
+      }
+      if (sync.fetchIntervalSec > 0) {
+        this.startPeriodicFetch(state, targetDir);
+      }
       this.log.info("mount ok", {
         targetDir,
         activeBranch: state.activeBranch,
@@ -2852,6 +2884,9 @@ var GitConnector = class extends AbstractConnector {
    * so a base branch that origin moved past is pushed rather than rejected.
    */
   async pushActiveBranch(s, cwd) {
+    if (s.readOnly) {
+      throw new Error(`git push refused: this mount is read-only (branch ${s.activeBranch})`);
+    }
     if (s.activeBranch === s.branch) {
       await integrateOriginBaseBranch(s.branch, cwd, s);
       await gitRemote(["push", "origin", s.activeBranch], cwd, s, 6e4);
@@ -3011,6 +3046,11 @@ var GitConnector = class extends AbstractConnector {
     return this.withMountLock(s, async () => {
       this.log.debug("sync (pull) start", { branch: s.activeBranch });
       try {
+        if (s.readOnly) {
+          await this.refreshReadOnly(s, handle.mountPath, { tolerateFetchFailure: false });
+          this.log.debug("sync ok");
+          return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
+        }
         await pullByMerge(s.activeBranch, handle.mountPath, s, 6e4);
         await syncSubmodules(handle.mountPath, this.log, s);
         this.log.debug("sync ok");
@@ -3069,7 +3109,7 @@ var GitConnector = class extends AbstractConnector {
     }
     const cwd = handle.mountPath;
     return this.withMountLock(s, async () => {
-      const detail = await this.hibernateSave(s, cwd);
+      const detail = s.readOnly ? READ_ONLY_HOOK_DETAIL : await this.hibernateSave(s, cwd);
       const pushState = await this.readPushState(s, cwd);
       return detail === void 0 ? { pushState } : { detail, pushState };
     });
@@ -3217,6 +3257,7 @@ var GitConnector = class extends AbstractConnector {
     const details = [];
     return this.withMountLock(s, async () => {
       try {
+        if (s.readOnly) return READ_ONLY_HOOK_DETAIL;
         const commitResult = await commitAll(handle.mountPath, `skaile: session close`, this.log);
         if (commitResult) {
           const sha = await git(["rev-parse", "--short", "HEAD"], handle.mountPath);
@@ -3908,6 +3949,145 @@ var GitConnector = class extends AbstractConnector {
       });
     }
   }
+  // ── Read-only mount ────────────────────────────────────────────────────────
+  /**
+   * Set `remote.origin.pushurl` to {@link READ_ONLY_PUSH_URL} on a read-only
+   * mount, and remove it again (only that value) once the mount is read-write,
+   * because the driver's own pushes go through `origin` and would hit it too.
+   */
+  async applyPushGuard(s, cwd) {
+    const current = await gitOrNull(["config", "--get", "remote.origin.pushurl"], cwd);
+    if (s.readOnly) {
+      if (current === READ_ONLY_PUSH_URL) return;
+      await git(["config", "remote.origin.pushurl", READ_ONLY_PUSH_URL], cwd, 5e3);
+    } else if (current === READ_ONLY_PUSH_URL) {
+      await git(["config", "--unset", "remote.origin.pushurl"], cwd, 5e3);
+    }
+  }
+  /**
+   * Bring a read-only mount to origin's base branch tip and drop every local
+   * change: edits, untracked files (ignored ones stay, so `.skaile/` and build
+   * output survive), local commits, an unfinished merge or rebase, and a branch
+   * switch. Replaces the pull, so the rebase and merge-conflict paths never run.
+   *
+   * With `tolerateFetchFailure` (connect), an unreachable origin is logged and
+   * the checkout is reset to the last fetched `origin/<base>` instead, so a
+   * mount that was usable stays usable. With `skipWhenAtTarget` (periodic tick)
+   * a checkout already on origin's tip is left as it is. While
+   * `readOnlySaveOwed` is set the work is saved first ({@link preserveLocalWork});
+   * when that fails nothing is discarded. The first reset after a save sets the
+   * push block. Runs under the mount lock. True when the checkout was reset.
+   */
+  async refreshReadOnly(s, cwd, opts) {
+    let fetched = false;
+    try {
+      await runRemoteGit(["fetch", "origin", s.branch], repoScopedAuth(s), {
+        cwd,
+        safeDir: cwd,
+        timeout: 6e4,
+        env: cLocaleEnv()
+      });
+      fetched = true;
+    } catch (err) {
+      if (!opts.tolerateFetchFailure) throw err;
+      this.log.warn("read-only mount: fetch failed, resetting to the last fetched base branch", {
+        branch: s.branch,
+        error: redactCredentials(err instanceof Error ? err.message : String(err))
+      });
+    }
+    if (s.disposed) return false;
+    const target = fetched ? await gitOrNull(["rev-parse", "--verify", "--quiet", "FETCH_HEAD^{commit}"], cwd) : await gitOrNull(
+      ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${s.branch}^{commit}`],
+      cwd
+    ) ?? await gitOrNull(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], cwd);
+    if (!target) {
+      this.log.warn("read-only mount: no commit to reset to, local edits kept", {
+        branch: s.branch
+      });
+      return false;
+    }
+    if (opts.skipWhenAtTarget && await gitOrNull(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd) === s.branch && await gitOrNull(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], cwd) === target) {
+      return false;
+    }
+    if (s.readOnlySaveOwed && !await this.preserveLocalWork(s, cwd, target)) return false;
+    await gitOrNull(["rebase", "--quit"], cwd);
+    await git(["checkout", "-f", "-B", s.branch, target], cwd, 12e4);
+    await git(["clean", "-fd"], cwd, 12e4);
+    if (fetched) {
+      await gitOrNull(["update-ref", `refs/remotes/origin/${s.branch}`, target], cwd);
+      await syncSubmodules(cwd, this.log, s);
+    } else {
+      await checkoutSubmodulesOffline(cwd);
+    }
+    s.activeBranch = s.branch;
+    if (s.readOnlySaveOwed) {
+      await this.applyPushGuard(s, cwd);
+      s.readOnlySaveOwed = false;
+    }
+    this.log.info("read-only mount refreshed", { branch: s.branch, fetched });
+    return true;
+  }
+  /**
+   * Save what the first read-only discard would destroy on a checkout that was
+   * used read-write: local commits on the base branch or a detached HEAD go to a
+   * `skaile/pre-read-only-<time>` branch, uncommitted edits and untracked files
+   * to a stash. Other local branches are left alone by the discard anyway.
+   * False (logged) when the stash fails, e.g. over unmerged paths.
+   */
+  async preserveLocalWork(s, cwd, target) {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..*$/, "");
+    const saved = [];
+    const tips = /* @__PURE__ */ new Set();
+    for (const ref of ["HEAD", `refs/heads/${s.branch}`]) {
+      const tip = await gitOrNull(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd);
+      if (!tip || tips.has(tip)) continue;
+      tips.add(tip);
+      if (await isAncestor(tip, target, cwd)) continue;
+      const existing = await gitOrNull(
+        [
+          "for-each-ref",
+          "--points-at",
+          tip,
+          "--format=%(refname:short)",
+          "refs/heads/skaile/pre-read-only-*"
+        ],
+        cwd
+      );
+      if (existing) {
+        saved.push(existing.split("\n")[0]);
+        continue;
+      }
+      let name = `skaile/pre-read-only-${stamp}`;
+      for (let n = 1; await localBranchExists(name, cwd); n++) {
+        name = `skaile/pre-read-only-${stamp}-${n}`;
+      }
+      await git(["branch", name, tip], cwd);
+      saved.push(name);
+    }
+    const dirty = await gitOrNull(["status", "--porcelain", "--untracked-files=normal"], cwd);
+    if (dirty) {
+      try {
+        await gitCommitting(
+          ["stash", "push", "--include-untracked", "-m", `skaile: before read-only ${stamp}`],
+          cwd,
+          12e4
+        );
+        saved.push("stash@{0}");
+      } catch (err) {
+        this.log.error("read-only mount: could not save local edits, nothing discarded", err, {
+          branch: s.branch
+        });
+        return false;
+      }
+    }
+    if (saved.length > 0) {
+      this.log.warn("read-only mount: saved local work before discarding it", {
+        branch: s.branch,
+        saved
+      });
+    }
+    return true;
+  }
   // ── Periodic fetch ─────────────────────────────────────────────────────────
   startPeriodicFetch(s, mountPath) {
     if (s.fetchTimer) clearInterval(s.fetchTimer);
@@ -3935,6 +4115,13 @@ var GitConnector = class extends AbstractConnector {
   }
   /** One periodic-fetch tick. Bails out at each resumption point once disconnected. */
   async runPeriodicFetch(s, mountPath) {
+    if (s.readOnly) {
+      await this.refreshReadOnly(s, mountPath, {
+        tolerateFetchFailure: false,
+        skipWhenAtTarget: true
+      });
+      return;
+    }
     await this.fetchOrigin(s, mountPath);
     if (s.disposed) return;
     if (s.sync.autoRebase && s.activeBranch !== s.branch) {
@@ -4148,6 +4335,7 @@ var GitConnector = class extends AbstractConnector {
     }, s.lifecycle.autoCommitIdleMs);
   }
   async performAutoCommit(s, mountPath) {
+    if (s.readOnly) return;
     try {
       if (await refuseUnfinishedOperation(mountPath, this.log)) return;
       const message = await this.generateCommitMessage(mountPath);
@@ -7945,6 +8133,8 @@ var ConnectorManager = class {
    * that will never sync. See {@link listFailedConnectors}.
    */
   failedConnectors = /* @__PURE__ */ new Map();
+  /** Kind of each failed bulk-connect attempt, so a carried failure replays it. */
+  attemptErrorKinds = /* @__PURE__ */ new Map();
   // Allocated absolute mount target → owning connector id; collisions rejected at setup, released on disconnect.
   mountTargets = /* @__PURE__ */ new Map();
   /**
@@ -8275,8 +8465,13 @@ var ConnectorManager = class {
       throw err;
     }
     const results = [];
+    const carriedIds = /* @__PURE__ */ new Set();
     for (const decl of declarations) {
-      results.push(await this.attemptConnect(decl));
+      const carried = this.opts.failureCarryOver?.take(decl);
+      if (carried !== void 0) carriedIds.add(decl.id);
+      results.push(
+        carried !== void 0 ? this.carryFailure(decl, carried) : await this.attemptConnect(decl)
+      );
     }
     const report = { results };
     this.mgrLog.info("connectAll complete", {
@@ -8289,6 +8484,15 @@ var ConnectorManager = class {
         const decl = declById.get(r.id);
         return !r.connected && r.access === "read-write" && decl?.mount != null && !readUnavailableMarker(decl.unavailable);
       }).map((r) => ({ id: r.id, error: r.error ?? "unknown error" }));
+      for (const f of failedRw) {
+        const decl = declById.get(f.id);
+        if (!decl || carriedIds.has(f.id)) continue;
+        const errorKind = this.attemptErrorKinds.get(f.id);
+        this.opts.failureCarryOver?.record(decl, {
+          error: f.error,
+          ...errorKind ? { errorKind } : {}
+        });
+      }
       if (failedRw.length > 0) {
         const summary = failedRw.map((f) => `"${f.id}": ${f.error}`).join("; ");
         this.mgrLog.error("connectAll failed: required read-write connector(s) failed", void 0, {
@@ -8344,6 +8548,7 @@ var ConnectorManager = class {
       });
       this.createdMountDirs.delete(decl.id);
       this.failedConnectors.delete(decl.id);
+      this.attemptErrorKinds.delete(decl.id);
       this.opts.onStatusChange?.({
         type: "connector_status",
         connectorId: decl.id,
@@ -8363,6 +8568,8 @@ var ConnectorManager = class {
       const msg = redactCredentials(err instanceof Error ? err.message : String(err));
       this.recordFailure(decl, msg);
       const errorKind = classifyConnectError(err);
+      if (errorKind) this.attemptErrorKinds.set(decl.id, errorKind);
+      else this.attemptErrorKinds.delete(decl.id);
       this.mgrLog.error("connect failed", err, {
         id: decl.id,
         driver: decl.driver,
@@ -8383,6 +8590,26 @@ var ConnectorManager = class {
       };
     }
   }
+  /**
+   * Fail `decl` with the error a previous build's `connectAll` carried over,
+   * without calling its driver. Same records and events as a failed attempt.
+   */
+  carryFailure(decl, { error, errorKind }) {
+    if (!this.active.has(decl.id)) this.releaseMountTarget(decl.id);
+    this.recordFailure(decl, error);
+    this.mgrLog.warn("connect skipped: it failed in the previous build moments ago", {
+      id: decl.id,
+      driver: decl.driver
+    });
+    this.opts.onStatusChange?.({
+      type: "connector_status",
+      connectorId: decl.id,
+      status: "error",
+      error,
+      ...errorKind ? { errorKind } : {}
+    });
+    return { id: decl.id, connected: false, error, access: decl.access };
+  }
   /**
    * Compatibility no-op for the removed in-container fleet health gate. Host
    * fleet-managed cloud mounts are verified at connect time by their drivers.
@@ -8414,6 +8641,7 @@ var ConnectorManager = class {
     this.mountTargets.clear();
     this.createdMountDirs.clear();
     this.failedConnectors.clear();
+    this.attemptErrorKinds.clear();
     this.mgrLog.info("disconnectAll complete");
   }
   // ── Hot-plug ──────────────────────────────────────────────────────────────────
@@ -8923,6 +9151,43 @@ function redactMarker(marker) {
     ...marker.detail !== void 0 ? { detail: redactCredentials(marker.detail) } : {}
   };
 }
+
+// connectors/src/connect-failure-carry-over.ts
+var CONNECT_FAILURE_CARRY_OVER_TTL_MS = 3e4;
+var ConnectFailureCarryOver = class {
+  entries = /* @__PURE__ */ new Map();
+  ttlMs;
+  now;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? CONNECT_FAILURE_CARRY_OVER_TTL_MS;
+    this.now = opts.now ?? Date.now;
+  }
+  /** Remember how `decl` failed in the bulk connect that just ran. */
+  record(decl, failure) {
+    const fingerprint = fingerprintOf(decl);
+    if (fingerprint === void 0) return;
+    this.entries.set(decl.id, { ...failure, fingerprint, at: this.now() });
+  }
+  /**
+   * The carried failure for `decl`, or `undefined` when it must connect.
+   * Removes the entry either way, so a failure is carried over once at most.
+   */
+  take(decl) {
+    const entry = this.entries.get(decl.id);
+    if (!entry) return void 0;
+    this.entries.delete(decl.id);
+    if (this.now() - entry.at > this.ttlMs) return void 0;
+    if (fingerprintOf(decl) !== entry.fingerprint) return void 0;
+    return { error: entry.error, ...entry.errorKind ? { errorKind: entry.errorKind } : {} };
+  }
+};
+function fingerprintOf(decl) {
+  try {
+    return JSON.stringify(decl);
+  } catch {
+    return void 0;
+  }
+}
 var zStatic = z4.z ?? z4.default ?? z4;
 function readFailedConnectors(manager) {
   if (typeof manager.listFailedConnectors !== "function") return [];
@@ -12875,6 +13140,6 @@ function describeFlowOperations() {
   return new FlowAdapter().tools.describeOperations({ access: "read-write" });
 }
 
-export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, ClassifierSubpromptRunner, ConnectorManager, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, MAX_REARM_MS, MIN_REFRESH_DELAY_MS, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, NO_ACTIVE_FLOW_ERROR, PortPool, PostgresConnector, REFRESH_LEAD_MS, S3Connector, S3FetchStoppedError, S3PresignedRequestError, S3_PRESIGN_BATCH, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SessionSubpromptRunner, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, 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, parseListObjectsV2, presignScopePrefix, presignableKey, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock };
-//# sourceMappingURL=chunk-OWN2W2IW.js.map
-//# sourceMappingURL=chunk-OWN2W2IW.js.map
+export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, BoxConnector, CONNECT_FAILURE_CARRY_OVER_TTL_MS, ClassifierSubpromptRunner, ConnectFailureCarryOver, ConnectorManager, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, MAX_REARM_MS, MIN_REFRESH_DELAY_MS, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, NO_ACTIVE_FLOW_ERROR, PortPool, PostgresConnector, REFRESH_LEAD_MS, S3Connector, S3FetchStoppedError, S3PresignedRequestError, S3_PRESIGN_BATCH, SQLiteConnector, SessionInlineSubFlowRunner, SessionNodeExecutor, SessionSubpromptRunner, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, 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, parseListObjectsV2, presignScopePrefix, presignableKey, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock };
+//# sourceMappingURL=chunk-FWZTKSYI.js.map
+//# sourceMappingURL=chunk-FWZTKSYI.js.map