@desplega.ai/agent-swarm 1.119.1 → 1.119.3

package/dist/cli-95kferzh.js

@@ -0,0 +1,439 @@
+// src/fs/provider.ts
+class FilesError extends Error {
+  code;
+  status;
+  cause;
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "FilesError";
+    this.code = code;
+    this.status = opts.status;
+    this.cause = opts.cause;
+  }
+}
+function providerPath(scope) {
+  if (scope.key !== undefined && scope.key !== null && scope.key !== "") {
+    return normalizeStoredKey(scope.key);
+  }
+  const safeName = normalizeName(scope.name);
+  return `tasks/${encodeURIComponent(scope.taskId)}/${safeName}`;
+}
+function normalizeStoredKey(key) {
+  const trimmed = key.trim().replace(/^\/+/, "");
+  if (!trimmed || trimmed.includes("\x00")) {
+    throw new FilesError("Provider", "Stored file key must be a non-empty path");
+  }
+  if (trimmed.split("/").some((part) => part === "..")) {
+    throw new FilesError("Provider", "Stored file key must not contain parent path segments");
+  }
+  return trimmed;
+}
+function normalizeName(name) {
+  const trimmed = name.trim().replace(/^\/+/, "");
+  if (!trimmed || trimmed === "." || trimmed.includes("\x00")) {
+    throw new FilesError("Provider", "File name must be a non-empty relative path");
+  }
+  const parts = trimmed.split("/");
+  if (parts.some((part) => !part || part === "." || part === "..")) {
+    throw new FilesError("Provider", "File name must not contain empty or parent path segments");
+  }
+  return parts.map(encodeURIComponent).join("/");
+}
+function fileObjectFromHeaders(providerId, scope, headers, overrides = {}) {
+  const sizeHeader = headers.get("content-length");
+  return {
+    providerId,
+    key: providerPath(scope),
+    taskId: scope.taskId,
+    name: scope.name,
+    contentType: headers.get("content-type") ?? undefined,
+    sizeBytes: sizeHeader ? Number(sizeHeader) : undefined,
+    etag: headers.get("etag") ?? undefined,
+    sha256: headers.get("x-agent-fs-content-hash") ?? undefined,
+    version: headers.get("x-agent-fs-version") ?? undefined,
+    ...overrides
+  };
+}
+function normalizeFilesError(error) {
+  if (error instanceof FilesError) {
+    return error;
+  }
+  return new FilesError("Provider", error instanceof Error ? error.message : "File provider error", {
+    cause: error
+  });
+}
+
+// src/fs/agent-fs-provider.ts
+class AgentFsProvider {
+  id = "agent-fs";
+  capabilities = {
+    signedUrl: { supported: true, maxExpiresIn: 3600 },
+    search: true,
+    comments: true,
+    versioning: true
+  };
+  apiUrl;
+  apiKey;
+  orgId;
+  driveId;
+  fetchImpl;
+  constructor(options = {}) {
+    this.apiUrl = stripTrailingSlash(options.apiUrl ?? process.env.AGENT_FS_API_URL ?? "");
+    this.apiKey = options.apiKey ?? process.env.API_AGENT_FS_API_KEY ?? process.env.AGENT_FS_API_KEY ?? "";
+    this.orgId = options.orgId ?? process.env.AGENT_FS_DEFAULT_ORG_ID ?? process.env.AGENT_FS_SHARED_ORG_ID ?? "";
+    this.driveId = options.driveId ?? process.env.AGENT_FS_DEFAULT_DRIVE_ID ?? "";
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (!this.apiUrl || !this.apiKey || !this.orgId || !this.driveId) {
+      throw new FilesError("Provider", "AGENT_FS_API_URL, API_AGENT_FS_API_KEY or AGENT_FS_API_KEY, AGENT_FS_DEFAULT_ORG_ID, and AGENT_FS_DEFAULT_DRIVE_ID are required for the agent-fs provider");
+    }
+  }
+  async upload(scope, body, options = {}) {
+    const headers = new Headers(this.authHeaders());
+    if (options.contentType) {
+      headers.set("content-type", options.contentType);
+    }
+    if (options.ifNoneMatch) {
+      headers.set("if-none-match", options.ifNoneMatch);
+    }
+    if (options.ifMatch) {
+      headers.set("if-match", options.ifMatch);
+    }
+    if (options.message) {
+      headers.set("x-agent-fs-message", options.message);
+    }
+    const response = await this.fetchRaw(scope, { method: "PUT", headers, body });
+    const parsed = await response.json().catch(() => ({}));
+    return fileObjectFromHeaders(this.id, scope, response.headers, {
+      key: parsed.path ?? providerPath(scope),
+      version: parsed.version === undefined ? response.headers.get("x-agent-fs-version") ?? undefined : String(parsed.version),
+      sha256: parsed.contentHash ?? response.headers.get("x-agent-fs-content-hash") ?? undefined,
+      metadata: { deduped: parsed.deduped }
+    });
+  }
+  async download(scope) {
+    return this.fetchRaw(scope, { method: "GET", headers: this.authHeaders() });
+  }
+  async head(scope) {
+    const response = await this.download(scope);
+    await response.body?.cancel();
+    return fileObjectFromHeaders(this.id, scope, response.headers);
+  }
+  async exists(scope) {
+    try {
+      await this.head(scope);
+      return true;
+    } catch (error) {
+      if (error instanceof FilesError && error.code === "NotFound") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async delete(scope) {
+    await this.ops({ op: "rm", path: providerPath(scope) }, scope);
+  }
+  async copy(source, destination) {
+    await this.ops({ op: "cp", path: providerPath(source), dest: providerPath(destination) });
+    return this.head(destination);
+  }
+  async move(source, destination) {
+    await this.ops({ op: "mv", path: providerPath(source), dest: providerPath(destination) });
+    return this.head(destination);
+  }
+  async list(options) {
+    const prefix = `tasks/${encodeURIComponent(options.taskId)}/${options.prefix ?? ""}`;
+    const result = await this.ops({ op: "ls", path: prefix });
+    const resultRecord = asRecord(result);
+    const entries = Array.isArray(result) ? result : Array.isArray(resultRecord?.entries) ? resultRecord.entries : [];
+    return entries.slice(0, options.limit).map((entry) => {
+      const key = String(entry.path ?? entry.name ?? "");
+      const name = key.startsWith(`tasks/${encodeURIComponent(options.taskId)}/`) ? key.slice(`tasks/${encodeURIComponent(options.taskId)}/`.length) : key;
+      return {
+        providerId: this.id,
+        key,
+        taskId: options.taskId,
+        name: decodeURIComponent(name),
+        contentType: typeof entry.mimeType === "string" ? entry.mimeType : undefined,
+        sizeBytes: typeof entry.size === "number" ? entry.size : undefined,
+        version: entry.version === undefined ? undefined : String(entry.version)
+      };
+    });
+  }
+  async* listAll(options) {
+    for (const item of await this.list(options)) {
+      yield item;
+    }
+  }
+  async url(scope, options = {}) {
+    const expiresIn = Math.min(options.expiresIn ?? 3600, this.capabilities.signedUrl.maxExpiresIn);
+    const result = await this.ops({ op: "signed-url", path: providerPath(scope), expiresIn }, scope);
+    if (typeof result === "string") {
+      return result;
+    }
+    const resultRecord = asRecord(result);
+    if (typeof resultRecord?.url === "string") {
+      return resultRecord.url;
+    }
+    throw new FilesError("Provider", "agent-fs signed-url op did not return a URL");
+  }
+  async signedUploadUrl() {
+    throw new FilesError("ReadOnly", "agent-fs does not support signed upload URLs");
+  }
+  async search(query) {
+    const result = await this.ops({
+      op: "search",
+      query: query.query,
+      path: `tasks/${encodeURIComponent(query.taskId)}`,
+      limit: query.limit
+    });
+    return Array.isArray(result) ? result : [];
+  }
+  async addComment(input) {
+    return await this.ops({
+      op: "comment-add",
+      path: providerPath(input),
+      body: input.body,
+      range: input.range
+    });
+  }
+  async listComments(scope) {
+    const result = await this.ops({ op: "comment-list", path: providerPath(scope) });
+    return Array.isArray(result) ? result : [];
+  }
+  async listVersions(scope) {
+    const result = await this.ops({ op: "log", path: providerPath(scope) });
+    return Array.isArray(result) ? result : [];
+  }
+  async restoreVersion(scope) {
+    return await this.ops({
+      op: "revert",
+      path: providerPath(scope),
+      version: scope.version
+    });
+  }
+  async fetchRaw(scope, init) {
+    const response = await this.fetchImpl(this.rawUrl(scope), init);
+    if (!response.ok) {
+      throw await responseToFilesError(response);
+    }
+    return response;
+  }
+  async ops(body, scope) {
+    const response = await this.fetchImpl(`${this.apiUrl}/orgs/${encodeURIComponent(this.orgFor(scope))}/ops`, {
+      method: "POST",
+      headers: {
+        ...this.authHeaders(),
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({ driveId: this.driveFor(scope), ...body })
+    });
+    if (!response.ok) {
+      throw await responseToFilesError(response);
+    }
+    return response.json().catch(() => null);
+  }
+  rawUrl(scope) {
+    return `${this.apiUrl}/orgs/${encodeURIComponent(this.orgFor(scope))}/drives/${encodeURIComponent(this.driveFor(scope))}/files/${providerPath(scope)}/raw`;
+  }
+  orgFor(scope) {
+    return scope?.orgId?.trim() || this.orgId;
+  }
+  driveFor(scope) {
+    return scope?.driveId?.trim() || this.driveId;
+  }
+  authHeaders() {
+    return { authorization: `Bearer ${this.apiKey}` };
+  }
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+async function responseToFilesError(response) {
+  const text = await response.text().catch(() => "");
+  const message = text || `File provider returned HTTP ${response.status}`;
+  if (response.status === 401 || response.status === 403) {
+    return new FilesError("Unauthorized", message, { status: response.status });
+  }
+  if (response.status === 404) {
+    return new FilesError("NotFound", message, { status: response.status });
+  }
+  if (response.status === 409 || response.status === 412) {
+    return new FilesError("Conflict", message, { status: response.status });
+  }
+  return new FilesError("Provider", message, { status: response.status });
+}
+function stripTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+
+// src/fs/local-fs-provider.ts
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+var DEFAULT_ROOT_DIR = "./data/fs";
+
+class LocalFsProvider {
+  id = "local-fs";
+  capabilities = {
+    signedUrl: { supported: false }
+  };
+  rootDir;
+  constructor(options = {}) {
+    this.rootDir = options.rootDir ?? process.env.AGENT_FS_LOCAL_DIR ?? DEFAULT_ROOT_DIR;
+  }
+  async upload(scope, body, options = {}) {
+    const target = this.localPath(scope);
+    await mkdir(dirname(target), { recursive: true });
+    if (options.ifNoneMatch === "*" && await this.exists(scope)) {
+      throw new FilesError("Conflict", "File already exists");
+    }
+    await Bun.write(target, await new Response(body).arrayBuffer());
+    if (options.contentType) {
+      await Bun.write(this.metaPath(target), JSON.stringify({ contentType: options.contentType }));
+    }
+    return this.head(scope);
+  }
+  async download(scope) {
+    const target = this.localPath(scope);
+    if (!await this.exists(scope)) {
+      throw new FilesError("NotFound", "File not found");
+    }
+    return new Response(Bun.file(target));
+  }
+  async head(scope) {
+    const target = this.localPath(scope);
+    try {
+      const info = await stat(target);
+      const storedContentType = await this.readStoredContentType(target);
+      return {
+        providerId: this.id,
+        key: providerPath(scope),
+        taskId: scope.taskId,
+        name: scope.name,
+        contentType: storedContentType ?? Bun.file(target).type ?? undefined,
+        sizeBytes: info.size,
+        updatedAt: info.mtime.toISOString()
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new FilesError("NotFound", "File not found", { cause: error });
+      }
+      throw new FilesError("Provider", "Unable to read file metadata", { cause: error });
+    }
+  }
+  async exists(scope) {
+    try {
+      await stat(this.localPath(scope));
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw new FilesError("Provider", "Unable to check file existence", { cause: error });
+    }
+  }
+  async delete(scope) {
+    const target = this.localPath(scope);
+    await rm(target, { force: true });
+    await rm(this.metaPath(target), { force: true });
+  }
+  async copy(source, destination) {
+    const sourceHead = await this.head(source);
+    const response = await this.download(source);
+    await this.upload(destination, await response.arrayBuffer(), {
+      contentType: sourceHead.contentType
+    });
+    return this.head(destination);
+  }
+  async move(source, destination) {
+    const copied = await this.copy(source, destination);
+    await this.delete(source);
+    return copied;
+  }
+  async list(options) {
+    const taskRoot = join(this.rootDir, "tasks", encodeURIComponent(options.taskId));
+    const files = [];
+    await this.walk(taskRoot, async (path) => {
+      const rel = relative(taskRoot, path).split(sep).join("/");
+      const name = decodePath(rel);
+      if (options.prefix && !name.startsWith(options.prefix)) {
+        return;
+      }
+      files.push(await this.head({ taskId: options.taskId, name }));
+    });
+    return typeof options.limit === "number" ? files.slice(0, options.limit) : files;
+  }
+  async* listAll(options) {
+    for (const item of await this.list(options)) {
+      yield item;
+    }
+  }
+  async url(scope) {
+    return `/api/fs/tasks/${encodeURIComponent(scope.taskId)}/files/${encodeURIComponent(scope.name)}/raw`;
+  }
+  async signedUploadUrl() {
+    throw new FilesError("ReadOnly", "local-fs does not support signed upload URLs");
+  }
+  localPath(scope) {
+    return join(this.rootDir, providerPath(scope));
+  }
+  metaPath(target) {
+    return `${target}.meta.json`;
+  }
+  async readStoredContentType(target) {
+    try {
+      const metaFile = Bun.file(this.metaPath(target));
+      if (!await metaFile.exists()) {
+        return;
+      }
+      const meta = await metaFile.json();
+      return typeof meta?.contentType === "string" ? meta.contentType : undefined;
+    } catch {
+      return;
+    }
+  }
+  async walk(dir, visit) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw new FilesError("Provider", "Unable to list files", { cause: error });
+    }
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walk(path, visit);
+      } else if (entry.isFile() && !entry.name.endsWith(".meta.json")) {
+        await visit(path);
+      }
+    }
+  }
+}
+function decodePath(path) {
+  return path.split("/").map((part) => decodeURIComponent(part)).join("/");
+}
+
+// src/fs/registry.ts
+var memoizedProvider = null;
+function getFileStorageProvider() {
+  if (!memoizedProvider) {
+    memoizedProvider = selectProvider();
+  }
+  return memoizedProvider;
+}
+function selectProvider() {
+  if (process.env.AGENT_FS_API_URL && (process.env.API_AGENT_FS_API_KEY || process.env.AGENT_FS_API_KEY)) {
+    return new AgentFsProvider;
+  }
+  return new LocalFsProvider;
+}
+function resetFileStorageProvider() {
+  memoizedProvider = null;
+}
+function resetFileStorageProviderForTests() {
+  resetFileStorageProvider();
+}
+
+export { FilesError, normalizeFilesError, getFileStorageProvider, selectProvider, resetFileStorageProvider, resetFileStorageProviderForTests };

package/dist/{cli-2dsbab02.js → cli-9aqtt1dn.js}

@@ -1,20 +1,20 @@
 import {
   createAdditiveBuffer,
   extractSlackMessageText
-} from "./cli-q8bgrc7c.js";
+} from "./cli-9y4z25ke.js";
 import {
   getSlackApp,
   registerTreeMessage
-} from "./cli-wt7b0vr9.js";
+} from "./cli-emgzr4ja.js";
 import {
   rewriteSlackMentions
-} from "./cli-xjb2jg7b.js";
+} from "./cli-j6n9at34.js";
+import {
+  createTaskWithSiblingAwareness
+} from "./cli-td2x0s9b.js";
 import {
   buildBufferFlushBlocks
 } from "./cli-ma04faw5.js";
-import {
-  createTaskWithSiblingAwareness
-} from "./cli-226nz7j1.js";
 import {
   getLatestActiveTaskInThread,
   getLeadAgent,
@@ -24,7 +24,7 @@ import {
   init_registry,
   registerTemplate,
   slackContextKey
-} from "./cli-6637ryhr.js";
+} from "./cli-y82m27mq.js";
 
 // src/slack/event-dedup.ts
 var DEFAULT_TTL_MS = 300000;

package/dist/{cli-q8bgrc7c.js → cli-9y4z25ke.js}

@@ -3,7 +3,7 @@ import {
   getAgentWorkingOnThread,
   getAllAgents,
   init_db
-} from "./cli-6637ryhr.js";
+} from "./cli-y82m27mq.js";
 
 // src/slack/router.ts
 init_db();

package/dist/{cli-6j7ftsbs.js → cli-cx30v78p.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "1.119.1",
+    version: "1.119.3",
     description: "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
     license: "MIT",
     author: "desplega.sh <contact@desplega.sh>",

package/dist/{cli-wh91zby6.js → cli-dh9eb7tt.js}

@@ -1,15 +1,15 @@
-import {
-  resolveCodexPrompt
-} from "./cli-r94z9p1z.js";
-import {
-  summarizeSession
-} from "./cli-e7306swv.js";
 import {
   createSwarmEventHandler
 } from "./cli-07er7wrs.js";
+import {
+  resolveCodexPrompt
+} from "./cli-r94z9p1z.js";
 import {
   readPkgVersion
 } from "./cli-d6n0thxw.js";
+import {
+  summarizeSession
+} from "./cli-hcpm1e90.js";
 import {
   buildRatingsFromLlm,
   fetchRetrievalsForTask,

package/dist/{cli-gpyx6t1w.js → cli-e5hdn9nx.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   init_db
-} from "./cli-6637ryhr.js";
+} from "./cli-y82m27mq.js";
 
 // src/be/seed-pricing.ts
 init_db();

package/dist/{cli-34194d2q.js → cli-eb3s7zwh.js}

@@ -8,16 +8,22 @@ import {
   REFERENCES_SOURCE_MAX_LENGTH,
   sanitizeReferencesSource
 } from "./cli-ftyf58xj.js";
+import {
+  calculateNextRun,
+  ensure,
+  require_dist,
+  runScheduleNow
+} from "./cli-yzxg93ma.js";
 import {
   startPricingRefreshLoop
-} from "./cli-p750jfs0.js";
+} from "./cli-8y1kmyn7.js";
 import {
   seedPricingFromModelsDev
-} from "./cli-gpyx6t1w.js";
+} from "./cli-e5hdn9nx.js";
 import {
   ensureRbacSeedsSynced,
   getUserGrant
-} from "./cli-2teefgw6.js";
+} from "./cli-7yfmb4ne.js";
 import {
   can,
   decideAdmission,
@@ -37,17 +43,7 @@ import {
   repointTrackerSyncBySwarmId,
   updateTrackerSync,
   updateTrackerSyncSwarmId
-} from "./cli-gat4kjhe.js";
-import {
-  ZodFirstPartyTypeKind,
-  objectType
-} from "./cli-fad8m16k.js";
-import {
-  calculateNextRun,
-  ensure,
-  require_dist,
-  runScheduleNow
-} from "./cli-03hw3tdq.js";
+} from "./cli-z612d1nc.js";
 import {
   TriggerSchemaError,
   applyDefinitionPatch,
@@ -61,10 +57,18 @@ import {
   startWorkflowExecution,
   validateDefinition,
   validateJsonSchema
-} from "./cli-zyjvbdgq.js";
+} from "./cli-j5da6jb2.js";
 import {
   getApiKey
 } from "./cli-f14fvzag.js";
+import {
+  buildAuthorizationUrl,
+  ensureToken,
+  ensureTokenOrThrow,
+  getOAuthApp,
+  getOAuthTokens,
+  upsertOAuthApp
+} from "./cli-p4yn675m.js";
 import {
   CREDENTIAL_BINDINGS_CONFIG_KEY,
   CredentialBindingSchema,
@@ -81,7 +85,7 @@ import {
   setScriptConnectionEnabled,
   upsertCredentialBinding,
   upsertScriptConnection
-} from "./cli-3hqj0r0f.js";
+} from "./cli-gzng1fst.js";
 import {
   CANDIDATE_SET_MULTIPLIER,
   computeScore,
@@ -93,25 +97,21 @@ import {
   isGraphExpansionEnabled,
   rerank,
   rowToCandidate
-} from "./cli-bwkxh7pa.js";
+} from "./cli-6expbmb3.js";
 import {
-  buildAuthorizationUrl,
-  ensureToken,
-  ensureTokenOrThrow,
-  getOAuthApp,
-  getOAuthTokens,
-  upsertOAuthApp
-} from "./cli-gq46dx9q.js";
+  ZodFirstPartyTypeKind,
+  objectType
+} from "./cli-fad8m16k.js";
 import {
   createAdditiveBuffer,
   extractSlackMessageText,
   parseSlackTs
-} from "./cli-q8bgrc7c.js";
+} from "./cli-9y4z25ke.js";
 import {
   getSlackApp,
   startSlackApp,
   stopSlackApp
-} from "./cli-wt7b0vr9.js";
+} from "./cli-emgzr4ja.js";
 import {
   findOrCreateUserByEmail,
   findUserByExternalId,
@@ -127,13 +127,13 @@ import {
   resolveIdentityByEmail,
   resolveUserByToken,
   unlinkIdentity
-} from "./cli-wmep6bjt.js";
+} from "./cli-3sew4a9j.js";
+import {
+  createTaskWithSiblingAwareness
+} from "./cli-td2x0s9b.js";
 import {
   markdownToSlack
 } from "./cli-ma04faw5.js";
-import {
-  createTaskWithSiblingAwareness
-} from "./cli-226nz7j1.js";
 import {
   getAppUrl,
   getMcpBaseUrl,
@@ -377,7 +377,7 @@ import {
   upsertService,
   upsertSwarmConfig,
   validateConfigValue
-} from "./cli-6637ryhr.js";
+} from "./cli-y82m27mq.js";
 import {
   init_zod
 } from "./cli-bw80ck94.js";
@@ -422,7 +422,7 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-6j7ftsbs.js";
+} from "./cli-cx30v78p.js";
 import {
   init_secret_scrubber,
   refreshSecretScrubberCache,
@@ -19710,7 +19710,7 @@ async function initOtel(serviceRole = process.env.AGENT_ROLE || "api") {
     return;
   initialized2 = true;
   try {
-    const impl = await import("./otel-impl-z3cdybex.js");
+    const impl = await import("./otel-impl-qw4pakj6.js");
     await impl.boot(serviceRole);
     realWithSpan = impl.withSpan;
     realStartSpan = impl.startSpan;
@@ -34997,7 +34997,7 @@ async function notifySlack(text) {
     return;
   }
   try {
-    const { getSlackApp: getSlackApp2 } = await import("./app-2t2t6qtm.js");
+    const { getSlackApp: getSlackApp2 } = await import("./app-p1gqacgd.js");
     const app = getSlackApp2();
     if (!app) {
       console.warn("[Jira webhook keepalive] Slack not available, cannot send notification");
@@ -35066,7 +35066,7 @@ async function deleteJiraWebhook(webhookId) {
   console.log(`[Jira webhook keepalive] Deleted webhook id=${webhookId}`);
 }
 async function overwriteWebhookIds(next) {
-  const { getDb: getDb2 } = await import("./db-93qmw47d.js");
+  const { getDb: getDb2 } = await import("./db-c9wx8pbf.js");
   const db = getDb2();
   const txn = db.transaction(() => {
     const row = db.query("SELECT metadata FROM oauth_apps WHERE provider = 'jira'").get();
@@ -109263,6 +109263,8 @@ function loadGlobalConfigsIntoEnv(override = false) {
 }
 async function reloadGlobalConfigsAndIntegrations() {
   const updated = loadGlobalConfigsIntoEnv(true);
+  const { resetFileStorageProvider } = await import("./registry-wejfsj31.js");
+  resetFileStorageProvider();
   const integrations = [];
   resetAgentMail();
   if (initAgentMail())