@skaile/workspaces 4.13.0 → 4.15.0

package/dist/{chunk-N6XJGVSK.js → chunk-E4Q5GKO2.js}

@@ -1,8 +1,8 @@
-import { declaredConnectErrorKind, ClassifiedConnectError, withConnectErrorKind } from './chunk-YZSMZK37.js';
-import { OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, resolveAuthRef, readUnavailableMarker, ConnectorStartupError } from './chunk-UOJW2DOZ.js';
-import { EventNormalizer } from './chunk-IQFSXFYG.js';
-import { resolveModelTier } from './chunk-XKPFQ3JT.js';
-import { createDriver } from './chunk-PQF3NDQH.js';
+import { declaredConnectErrorKind, ClassifiedConnectError, withConnectErrorKind } from './chunk-UF4AEO54.js';
+import { OAuthRequiredError, ConnectorFieldMissingError, LegacyAuthGrammarError, resolveAuthRef, readUnavailableMarker, ConnectorStartupError } from './chunk-MK3OCWBG.js';
+import { EventNormalizer } from './chunk-W64ZXABT.js';
+import { resolveModelTier } from './chunk-ZXQMKXWR.js';
+import { createDriver } from './chunk-LQMALDDB.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeStimulus } from './chunk-IFGTRL2I.js';
 import { interpolateNodeInstruction, resolveNodeBindings, getConsumedOutputSchema, validateConsumedNodeOutput, appendAttempt, resolveTerminalFailureStatus, remainingActiveExecutionMs, deriveCheckEvidence, computeFlowStateFromSnapshots, availableRouterFrontier, evaluateRouterSelection, routerSelectionOutput, planRouterSkips, unsettledRouterBranchIds, countFailedAttempts, hasAutomaticRetryBudget, persistedRouterSelection } from './chunk-A2T4WIZL.js';
@@ -11,7 +11,7 @@ import { parseFlowDefinition } from './chunk-ALLCAFHQ.js';
 import { describeStimulus, buildOrchestratorPrompt, renderSubpromptPrompt, renderStimulusPrompt } from './chunk-RQLL7L72.js';
 import { deterministicNodeKindLabel, nodeInstruction, flowDefaults, isAgentNode, isGateNode, isCheckNode, nodeRequiresApproval, isSubFlowNode, isFunctionNode, isSubpromptNode, isRouterNode, isActiveRuntimeNode, nodeIsOptional, nodeLabel, nodeAssets } from './chunk-V4RGCKYC.js';
 import { classifierDecision, withoutReservedClassifierFields } from './chunk-DHMBE5J7.js';
-import { withActivityLabelDefs } from './chunk-O64WU6WS.js';
+import { withActivityLabelDefs } from './chunk-QQ3G5N7X.js';
 import { processAlive } from './chunk-4GY63JU6.js';
 import { withFsDeadline, tryWithFsDeadline, FsDeadlineError, fsDeadlineMs } from './chunk-2FBPAR2V.js';
 import { portableSpawn } from './chunk-DPLIN2RA.js';
@@ -4876,13 +4876,44 @@ function createConnector12() {
 }
 var s3Pkg = "@aws-sdk/client-s3";
 var DOWNLOAD_DEADLINE_FACTOR = 20;
+var ERROR_BODY_WAIT_MS = 5e3;
+var LIST_PAGE_DEADLINE_FACTOR = 2;
+var PRESIGN_REFUSAL_KINDS = {
+  "not-configured": "credential",
+  "not-in-scope": "config",
+  "invalid-request": "config"
+};
+var S3_PRESIGN_BATCH = 100;
+var MAX_PRESIGN_KEY_BYTES = 1024;
+var S3FetchStoppedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "S3FetchStoppedError";
+  }
+};
+var S3PresignedRequestError = class extends Error {
+  constructor(op, status, s3Code, expired, detail) {
+    super(detail);
+    this.op = op;
+    this.status = status;
+    this.s3Code = s3Code;
+    this.expired = expired;
+    this.name = "S3PresignedRequestError";
+  }
+  op;
+  status;
+  s3Code;
+  expired;
+};
 var S3Connector = class extends AbstractConnector {
   name = "s3";
   /** Optional SDK module override — used in tests to avoid importing the real AWS SDK. */
   _sdkOverride;
-  constructor(sdkOverride) {
+  _fetch;
+  constructor(sdkOverride, deps = {}) {
     super();
     this._sdkOverride = sdkOverride;
+    this._fetch = deps.fetch ?? ((url, init) => fetch(url, init));
   }
   filesystem = {
     sync: (handle, options) => {
@@ -4904,6 +4935,9 @@ var S3Connector = class extends AbstractConnector {
     const secrets = ctx.secrets;
     const started = Date.now();
     const opts = declaration.options;
+    if (declaration.auth === "backend") {
+      return this.connectPresigned(declaration, ctx, targetDir, started);
+    }
     const bucket = String(opts?.bucket ?? "");
     if (!bucket) {
       this.log.error("connect failed: missing bucket option", void 0);
@@ -4922,7 +4956,7 @@ var S3Connector = class extends AbstractConnector {
       clientConfig.profile = profile;
     }
     const client = new S3Client(clientConfig);
-    const state = { client, bucket, prefix, region };
+    const state = { kind: "sdk", client, bucket, prefix, region };
     await withFsDeadline(`mkdir ${targetDir}`, () => mkdir(targetDir, { recursive: true }));
     try {
       const result = await this.downloadAll(state, targetDir);
@@ -4937,10 +4971,47 @@ var S3Connector = class extends AbstractConnector {
       throw err;
     }
   }
+  /**
+   * `auth: backend`: the platform holds the keys and signs every request, so
+   * nothing here builds an S3 client or loads the SDK. Bucket and endpoint are
+   * the platform's business; the prefix is only needed to place files.
+   */
+  async connectPresigned(declaration, ctx, targetDir, started) {
+    if (!ctx.s3Presigner) {
+      const err = new ClassifiedConnectError(
+        `S3Connector '${declaration.id}': auth: backend needs the platform presign channel (host.s3_presign), which this runner does not have`,
+        "config"
+      );
+      this.log.error("connect failed: no presigner", err);
+      throw err;
+    }
+    const prefix = presignScopePrefix(declaration);
+    const state = {
+      kind: "presign",
+      presign: ctx.s3Presigner,
+      mountId: declaration.id,
+      prefix,
+      ...ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}
+    };
+    this.log.info("mount start", { mode: "presign", prefix, targetDir });
+    await withFsDeadline(`mkdir ${targetDir}`, () => mkdir(targetDir, { recursive: true }));
+    try {
+      const result = await this.downloadAll(state, targetDir);
+      this.log.info("mount ok", {
+        targetDir,
+        filesWritten: result.filesWritten,
+        durationMs: Date.now() - started
+      });
+      return this.makeHandle(declaration, state, targetDir);
+    } catch (err) {
+      this.log.error("connect failed", err, { mode: "presign", targetDir });
+      throw err;
+    }
+  }
   async disconnect(handle) {
     this.log.info("unmount");
-    const { client } = handle.state;
-    client.destroy();
+    const state = handle.state;
+    if (state.kind === "sdk") state.client.destroy();
   }
   async _sync(handle, _options) {
     this.log.debug("sync start");
@@ -4977,7 +5048,22 @@ var S3Connector = class extends AbstractConnector {
     }
   }
   async downloadAll(state, targetDir) {
+    if (state.kind === "presign") {
+      const entries2 = await this.listPresigned(state);
+      return this.writeEntries(
+        entries2,
+        targetDir,
+        (deadlineAt) => this.presignedBodies(state, entries2, deadlineAt)
+      );
+    }
     const s3Mod = await this._loadSdk();
+    const entries = await this.listSdk(s3Mod, state);
+    const bodies = async function* (self) {
+      for (const { key } of entries) yield await self.fetchObject(s3Mod, state, key);
+    };
+    return this.writeEntries(entries, targetDir, () => bodies(this));
+  }
+  async listSdk(s3Mod, state) {
     const { client, bucket, prefix } = state;
     const entries = [];
     let continuationToken;
@@ -4997,40 +5083,331 @@ var S3Connector = class extends AbstractConnector {
       }
       continuationToken = resp.IsTruncated ? resp.NextContinuationToken : void 0;
     } while (continuationToken);
+    return entries;
+  }
+  /**
+   * List the mount through presigned ListObjectsV2 URLs, page by page. Folder
+   * markers and keys the platform would refuse to sign (see
+   * {@link presignableKey}) are dropped here, so one odd key cannot fail a
+   * whole `get` batch. Each page is bounded by {@link LIST_PAGE_DEADLINE_FACTOR}.
+   */
+  async listPresigned(state) {
+    const entries = [];
+    let continuationToken;
+    do {
+      const token = continuationToken;
+      const xml = await this.withRepresign(
+        () => this.presignOrThrow(state, {
+          mountId: state.mountId,
+          op: "list",
+          ...token ? { continuationToken: token } : {}
+        }),
+        async (signed) => {
+          if (signed.op !== "list") throw new Error("host.s3_presign answered list with get");
+          const timeoutMs = fsDeadlineMs() * LIST_PAGE_DEADLINE_FACTOR;
+          return this.readBounded(
+            state,
+            async (signal) => {
+              const resp = await this._fetch(signed.url, { signal });
+              if (!resp.ok) throw await presignedError("list", resp, signed.expiresAt, "listing");
+              return resp.text();
+            },
+            timeoutMs,
+            "listing"
+          );
+        }
+      );
+      const page = parseListObjectsV2(xml);
+      if (page.prefix !== void 0 && page.prefix !== state.prefix) {
+        this.log.info("listing prefix differs from the declaration; using the listing's", {
+          declared: state.prefix,
+          listed: page.prefix
+        });
+        state.prefix = normalizeScopePrefix(page.prefix);
+      }
+      for (const key of page.keys) {
+        if (key.endsWith("/")) continue;
+        if (!presignableKey(key, state.prefix)) {
+          this.log.warn("object skipped: key cannot be presigned", { key });
+          continue;
+        }
+        const relPath = key.slice(state.prefix.length);
+        if (!safeRelPath(relPath)) {
+          this.log.warn("object skipped: key does not map to a path inside the mount", { key });
+          continue;
+        }
+        entries.push({ key, relPath });
+      }
+      continuationToken = page.isTruncated ? page.nextContinuationToken : void 0;
+      if (page.isTruncated && !continuationToken) {
+        throw new Error("S3 listing is truncated but carries no NextContinuationToken");
+      }
+    } while (continuationToken);
+    return entries;
+  }
+  /**
+   * Object bodies in `entries` order, presigned in batches of
+   * {@link S3_PRESIGN_BATCH}. A batch whose URLs expired mid-download is
+   * re-presigned once (the rest of it); a second expiry is an error. Every
+   * download is bounded by the loop's shared budget (`deadlineAt`).
+   */
+  async *presignedBodies(state, entries, deadlineAt) {
+    for (let start = 0; start < entries.length; start += S3_PRESIGN_BATCH) {
+      const keys = entries.slice(start, start + S3_PRESIGN_BATCH).map((e) => e.key);
+      let signed = await this.presignGet(state, keys);
+      let represigned = false;
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const url = signed.urls.get(key);
+        if (url === void 0) {
+          yield null;
+          continue;
+        }
+        try {
+          yield await this.fetchObjectPresigned(state, key, url, signed.expiresAt, deadlineAt);
+        } catch (err) {
+          if (!(err instanceof S3PresignedRequestError) || !err.expired || represigned) throw err;
+          represigned = true;
+          this.log.info("presigned URLs expired; presigning the batch again", { key });
+          signed = await this.presignGet(state, keys.slice(i));
+          i--;
+        }
+      }
+    }
+  }
+  async presignGet(state, keys) {
+    const signed = await this.presignOrThrow(state, { mountId: state.mountId, op: "get", keys });
+    if (signed.op !== "get") throw new Error("host.s3_presign answered get with list");
+    return { urls: new Map(signed.urls.map((u) => [u.key, u.url])), expiresAt: signed.expiresAt };
+  }
+  /**
+   * One object through its presigned URL. Like an SDK `GetObject` miss, a 404
+   * (deleted since the listing), a 5xx or a network failure is survivable and
+   * skips the object. A 403 or other client error means the mount cannot be
+   * read, and a spent budget or a disposed manager means the sync must stop:
+   * those fail it.
+   */
+  async fetchObjectPresigned(state, key, url, expiresAt, deadlineAt) {
+    const what = `object '${key}'`;
+    try {
+      const bytes = await this.readBounded(
+        state,
+        async (signal) => {
+          const resp = await this._fetch(url, { signal });
+          if (!resp.ok) throw await presignedError("get", resp, expiresAt, what);
+          return resp.arrayBuffer();
+        },
+        deadlineAt - Date.now(),
+        what
+      );
+      return Buffer.from(bytes);
+    } catch (err) {
+      const survivable = err instanceof S3PresignedRequestError ? err.status === 404 || err.status >= 500 : !(err instanceof S3FetchStoppedError);
+      if (!survivable) throw err;
+      this.log.warn("object download failed", {
+        key,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async presignOrThrow(state, request) {
+    const result = await state.presign(request);
+    if (!result.ok) {
+      const message = `S3 mount '${state.mountId}': the platform refused to presign ${request.op} (${result.code}): ${result.message}`;
+      const kind = PRESIGN_REFUSAL_KINDS[result.code];
+      throw kind ? new ClassifiedConnectError(message, kind) : new Error(message);
+    }
+    return result;
+  }
+  /** Run `use` on a fresh signature; if the URL turns out expired, sign once more and retry. */
+  async withRepresign(sign, use) {
+    try {
+      return await use(await sign());
+    } catch (err) {
+      if (!(err instanceof S3PresignedRequestError) || !err.expired) throw err;
+      this.log.info("presigned URL expired; presigning again", { op: err.op });
+      return use(await sign());
+    }
+  }
+  /**
+   * Run one network step under a timeout and the manager's dispose signal,
+   * naming which one stopped it. Raw `fetch` has no socket timeout of its own,
+   * so without this a half-open connection would park `connect()` / `sync()`.
+   */
+  async readBounded(state, step, timeoutMs, what) {
+    const disposed = `S3 read of ${what} stopped: the connector was disposed`;
+    if (state.abortSignal?.aborted) throw new S3FetchStoppedError(disposed);
+    if (timeoutMs <= 0) {
+      throw new S3FetchStoppedError(`S3 read of ${what} stopped: the download budget is spent`);
+    }
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signal = state.abortSignal ? AbortSignal.any([state.abortSignal, timeout]) : timeout;
+    let onAbort;
+    const stopped = new Promise((_, reject) => {
+      onAbort = () => reject(
+        new S3FetchStoppedError(
+          state.abortSignal?.aborted ? disposed : `S3 read of ${what} timed out after ${timeoutMs}ms`
+        )
+      );
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      return await Promise.race([step(signal), stopped]);
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    }
+  }
+  /**
+   * Write each entry's body under `targetDir`. `bodies` yields one body (or
+   * `null` for a survivable miss) per entry, in order; it receives the loop's
+   * deadline so a download inside it is bounded by the same budget.
+   */
+  async writeEntries(entries, targetDir, bodies) {
     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) {
-      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)) {
+    const iterator = bodies(deadlineAt)[Symbol.asyncIterator]();
+    try {
+      for (const { relPath } of entries) {
+        if (deadlineAt - Date.now() <= 0) {
+          throw new FsDeadlineError(`downloadAll ${targetDir}`, budgetMs);
+        }
+        const next = await iterator.next();
+        if (next.done) {
+          throw new Error(
+            `S3 download produced fewer bodies than the ${entries.length} listed objects`
+          );
+        }
+        const body = next.value;
+        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(
-          `mkdir ${parent}`,
-          () => mkdir(parent, { recursive: true }),
+          `writeFile ${localPath}`,
+          () => writeFile(localPath, body),
           deadlineAt - Date.now()
         );
-        created.add(parent);
+        filesWritten++;
+        bytesTransferred += body.byteLength;
       }
-      await withFsDeadline(
-        `writeFile ${localPath}`,
-        () => writeFile(localPath, body),
-        deadlineAt - Date.now()
-      );
-      filesWritten++;
-      bytesTransferred += body.byteLength;
+    } finally {
+      await iterator.return?.(void 0);
     }
     return { filesWritten, filesDeleted: 0, bytesTransferred };
   }
 };
-function createConnector13(sdkOverride) {
-  return new S3Connector(sdkOverride);
+function presignScopePrefix(declaration) {
+  const opts = declaration.options ?? {};
+  const explicit = typeof opts.prefix === "string" ? opts.prefix.trim() : "";
+  let raw = explicit;
+  if (raw === "") {
+    const source = declaration.mount?.source ?? opts.source;
+    const parsed = typeof source === "string" ? parseS3Source(source) : null;
+    const bucket = typeof opts.bucket === "string" ? opts.bucket.trim() : "";
+    if (parsed && (bucket === "" || bucket === parsed.bucket)) raw = parsed.prefix;
+  }
+  return normalizeScopePrefix(raw);
+}
+function normalizeScopePrefix(raw) {
+  const trimmed = raw.replace(/^\/+/, "");
+  return trimmed === "" || trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+function safeRelPath(relPath) {
+  return relPath.replace(/^\/+/, "") !== "" && !relPath.split("/").some((segment) => segment === "." || segment === "..");
+}
+function parseS3Source(source) {
+  let rest = source.trim();
+  if (rest.toLowerCase().startsWith("s3://")) rest = rest.slice("s3://".length);
+  else if (/^[a-z][a-z0-9+.-]*:/i.test(rest)) return null;
+  rest = rest.replace(/^\/+/, "");
+  const slash = rest.indexOf("/");
+  const bucket = slash === -1 ? rest : rest.slice(0, slash);
+  if (bucket === "") return null;
+  return { bucket, prefix: slash === -1 ? "" : rest.slice(slash + 1) };
+}
+function presignableKey(key, prefix) {
+  return key.startsWith(prefix) && key.length > prefix.length && Buffer.byteLength(key, "utf8") <= MAX_PRESIGN_KEY_BYTES && !key.split("/").some((segment) => segment === "." || segment === "..") && // biome-ignore lint/suspicious/noControlCharactersInRegex: rejecting control characters is the point
+  !/[\u0000-\u001f\u007f]/.test(key);
+}
+function parseListObjectsV2(xml) {
+  const urlEncoded = /<EncodingType>\s*url\s*<\/EncodingType>/i.test(xml);
+  const decode = (raw) => {
+    const text = unescapeXml(raw);
+    if (!urlEncoded) return text;
+    try {
+      return decodeURIComponent(text.replace(/\+/g, " "));
+    } catch {
+      return text;
+    }
+  };
+  const prefixMatch = /<Prefix>([\s\S]*?)<\/Prefix>|<Prefix\s*\/>/.exec(
+    xml.replace(/<CommonPrefixes>[\s\S]*?<\/CommonPrefixes>/g, "")
+  );
+  const keys = [];
+  for (const contents of xml.matchAll(/<Contents>([\s\S]*?)<\/Contents>/g)) {
+    const raw = /<Key>([\s\S]*?)<\/Key>/.exec(contents[1])?.[1];
+    if (raw === void 0) continue;
+    keys.push(decode(raw));
+  }
+  const isTruncated = /<IsTruncated>\s*true\s*<\/IsTruncated>/i.test(xml);
+  const token = /<NextContinuationToken>([\s\S]*?)<\/NextContinuationToken>/.exec(xml)?.[1];
+  return {
+    keys,
+    ...prefixMatch ? { prefix: decode(prefixMatch[1] ?? "") } : {},
+    isTruncated,
+    ...token ? { nextContinuationToken: unescapeXml(token) } : {}
+  };
+}
+function unescapeXml(text) {
+  return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|amp|lt|gt|quot|apos);/g, (_m, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default:
+        return String.fromCodePoint(
+          entity[1] === "x" ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10)
+        );
+    }
+  });
+}
+async function presignedError(op, resp, expiresAt, what) {
+  let body = "";
+  try {
+    body = await Promise.race([
+      resp.text(),
+      new Promise((resolve7) => setTimeout(() => resolve7(""), ERROR_BODY_WAIT_MS).unref?.())
+    ]);
+  } catch {
+  }
+  const code = /<Code>([\s\S]*?)<\/Code>/.exec(body)?.[1];
+  const message = /<Message>([\s\S]*?)<\/Message>/.exec(body)?.[1];
+  const pastExpiry = Date.parse(expiresAt) <= Date.now();
+  const expired = resp.status === 403 && (/expired/i.test(message ?? "") || code === "ExpiredToken" || pastExpiry);
+  const detail = [code, message].filter(Boolean).join(": ");
+  const lead = resp.status === 403 && !expired ? `S3 denied access to ${what} (HTTP 403${detail ? `, ${detail}` : ""}); check the S3 link's permissions for this bucket and prefix` : `S3 ${op} of ${what} failed (HTTP ${resp.status}${detail ? `, ${detail}` : ""})`;
+  return new S3PresignedRequestError(op, resp.status, code, expired, lead);
+}
+function createConnector13(sdkOverride, deps) {
+  return new S3Connector(sdkOverride, deps);
 }
 
 // factory-assets/connectors/sharepoint/driver.ts
@@ -6993,6 +7370,7 @@ var ConnectorManager = class {
       secrets: this.chain ?? this.secrets,
       // Both filesystem and tool faces use this for the auth: backend initial-mint path.
       tokenMediator: this.buildWrappedMediator(declaration),
+      ...this.opts.s3Presigner ? { s3Presigner: this.opts.s3Presigner } : {},
       abortSignal: this.disposeController.signal
     };
     if (this.chain && connector.describeFields && declaration.auth !== "backend") {
@@ -11502,6 +11880,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, 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, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock };
-//# sourceMappingURL=chunk-N6XJGVSK.js.map
-//# sourceMappingURL=chunk-N6XJGVSK.js.map
+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, parseListObjectsV2, presignScopePrefix, presignableKey, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, removeUnavailableMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock, writeUnavailableMountBlock };
+//# sourceMappingURL=chunk-E4Q5GKO2.js.map
+//# sourceMappingURL=chunk-E4Q5GKO2.js.map