@ultrst-armada/kloks 1.6.0 → 1.7.1

package/.krusbl-release-attestation.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "packageName": "@ultrst-armada/kloks",
-  "version": "1.6.0",
-  "sourceCommit": "a44775f58baed156dbc5590d9d920e6b582f2eee",
+  "version": "1.7.1",
+  "sourceCommit": "67d641336636d076f15240809b73c0a4f9f438b5",
   "releaseWorkflow": "npm Release",
-  "workflowRunId": "39983348775"
+  "workflowRunId": "40193283076"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "private": false,
   "publishConfig": {
     "access": "public",

package/packages/backend/dist/{BaseStorageAdapter-tosOoSUg.d.ts → BaseStorageAdapter-6x_BQiB3.d.ts}

@@ -1,7 +1,7 @@
 import { SkipoBase } from '@ultrst-armada/kloks/functions';
 
 type StorageMode = 'local' | 'local_hosted' | 'remote';
-type StorageProviderType = 'local_fs' | 's3' | 'backblaze_b2' | 'b2' | 'cloudflare_r2' | 'r2' | 'supabase' | 'firebase' | 'google_drive';
+type StorageProviderType = 'local_fs' | 'backblaze_b2' | 'b2' | 'supabase' | 'firebase' | 'google_drive';
 interface StorageConfig {
     provider: StorageProviderType;
     mode?: StorageMode;
@@ -19,6 +19,11 @@ interface StorageConfig {
     keyId?: string;
     applicationKey?: string;
     accountId?: string;
+    googleClientId?: string;
+    googleRedirectUri?: string;
+    googleAccessToken?: string;
+    googleRefreshToken?: string;
+    googleRootFolderId?: string;
 }
 interface FileInfo {
     path: string;

package/packages/backend/dist/{chunk-OZDYAEH4.js → chunk-3IUA66RS.js}

@@ -1,3 +1,8 @@
+import {
+  b2ListBuckets,
+  queryUnifiedDb
+} from "./chunk-VAFCR2MS.js";
+
 // src/srkl/SrklClient.ts
 var CANONICAL_SRKL_URL = "https://srkl-engine.vercel.app";
 var SrklClient = class {
@@ -116,9 +121,10 @@ var SrklClient = class {
     const creds = account.credentials || {};
     const sId = (account.serviceId || "").toLowerCase();
     const isB2 = sId.includes("backblaze") || sId === "b2";
+    const isGoogle = sId.includes("google_drive") || sId.includes("googledrive") || sId === "google";
     return {
       id: `conn-srkl-${account.id}`,
-      provider: isB2 ? "backblaze_b2" : "aws_s3",
+      provider: isB2 ? "backblaze_b2" : isGoogle ? "google_drive" : "aws_s3",
       label: `SRKL: ${account.name || (isB2 ? "Backblaze" : "S3")}`,
       role: "redundant_clone",
       enabled: true,
@@ -132,7 +138,13 @@ var SrklClient = class {
       s3SecretAccessKey: creds.secretAccessKey || creds.applicationKey || creds.s3SecretAccessKey,
       s3BucketName: creds.bucketName || creds.s3BucketName,
       s3Region: creds.region || creds.s3Region,
-      s3Endpoint: creds.endpoint || creds.s3Endpoint
+      s3Endpoint: creds.endpoint || creds.s3Endpoint,
+      googleEmail: creds.email || account.credentials?.email || account.name,
+      googleRootFolderId: creds.rootFolderId,
+      googleRootFolderName: creds.rootFolderName,
+      googleAccessToken: creds.accessToken,
+      googleAccessTokenExpiresAt: creds.accessTokenExpiresAt,
+      googleRefreshToken: creds.refreshToken
     };
   }
 };
@@ -492,6 +504,200 @@ async function syncSrklAccounts(userId, sessionToken, srklUrl) {
   return await resp.json();
 }
 
+// src/core/srklCore.ts
+var cachedSrklUrl = null;
+async function getPrimarySrklDeploymentUrl(env) {
+  if (cachedSrklUrl && Date.now() < cachedSrklUrl.expiresAt) return cachedSrklUrl.url;
+  try {
+    const res = await queryUnifiedDb(
+      `SELECT url FROM "ultrst-srkl-deployments" WHERE is_active = true ORDER BY is_primary DESC, priority DESC, created_at ASC LIMIT 1`,
+      [],
+      env
+    );
+    if (res.rows.length > 0 && res.rows[0].url) {
+      const url = res.rows[0].url.trim().replace(/\/+$/, "");
+      cachedSrklUrl = { url, expiresAt: Date.now() + 10 * 60 * 1e3 };
+      return url;
+    }
+  } catch (err) {
+    console.warn("[SrklCore] Deployment DB lookup fallback:", err.message);
+  }
+  const fallback = "https://srkl-engine.vercel.app";
+  cachedSrklUrl = { url: fallback, expiresAt: Date.now() + 10 * 60 * 1e3 };
+  return fallback;
+}
+function deduplicateAccounts(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const a of items) {
+    if (!a) continue;
+    const creds = a.credentials || a.metadata?.credentials || a;
+    const keyId = (creds.keyId || creds.b2KeyId || creds.accessKeyId || "").trim();
+    const token = (creds.token || creds.apiToken || creds.applicationKey || creds.b2ApplicationKey || "").trim();
+    const sId = (a.serviceId || a.provider || "").toLowerCase().trim();
+    const sig = keyId ? `key:${keyId}` : token ? `tok:${sId}:${token.slice(-12)}` : a.id ? `id:${a.id}` : `nam:${sId}:${a.name || a.label}`;
+    if (!seen.has(sig)) {
+      seen.add(sig);
+      if (a.id) seen.add(`id:${a.id}`);
+      out.push(a);
+    }
+  }
+  return out;
+}
+async function getSrklAccounts(userId, service2, env) {
+  const rawAccounts = [];
+  const srklUrl = await getPrimarySrklDeploymentUrl(env);
+  if (userId) {
+    try {
+      const uRes = await queryUnifiedDb(
+        `SELECT app_profiles FROM "ultrst-users" WHERE id = $1 OR email = $1 LIMIT 1`,
+        [userId],
+        env
+      );
+      if (uRes.rows.length > 0) {
+        const p = typeof uRes.rows[0].app_profiles === "string" ? JSON.parse(uRes.rows[0].app_profiles) : uRes.rows[0].app_profiles || {};
+        const conns = [];
+        for (const app of Object.values(p)) {
+          if (app && typeof app === "object" && Array.isArray(app.storage_connections)) {
+            conns.push(...app.storage_connections);
+          }
+        }
+        for (const c of conns) {
+          if (!service2 || (c.provider || "").toLowerCase().includes(service2.toLowerCase())) {
+            rawAccounts.push({
+              id: c.id,
+              name: c.label || c.name || "Backblaze B2 Account",
+              provider: c.provider === "backblaze_b2" ? "backblaze" : c.provider,
+              serviceId: "backblaze",
+              category: "storage",
+              groupIds: c.groupIds || (c.groupId ? [c.groupId] : []),
+              credentials: {
+                keyId: c.b2KeyId || c.keyId || c.accessKeyId || "",
+                applicationKey: c.b2ApplicationKey || c.applicationKey || c.secretAccessKey || "",
+                bucketName: c.b2BucketName || c.bucketName || "",
+                bucketId: c.b2BucketId || c.bucketId || "",
+                endpoint: c.b2Endpoint || c.endpoint || "s3.eu-central-003.backblazeb2.com",
+                region: c.b2Region || c.region || "eu-central-003"
+              }
+            });
+          }
+        }
+      }
+    } catch (err) {
+      console.warn("[SrklCore] Storage connection DB lookup fallback:", err.message);
+    }
+  }
+  try {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const accPath = path.resolve(".skipo/accounts.json");
+    const raw = await fs.readFile(accPath, "utf-8");
+    const localUsers = JSON.parse(raw);
+    for (const u of Object.values(localUsers)) {
+      const conns = Array.isArray(u.storage_connections) ? u.storage_connections : [];
+      for (const c of conns) {
+        if (!service2 || (c.provider || "").toLowerCase().includes(service2.toLowerCase())) {
+          rawAccounts.push({
+            id: c.id,
+            name: c.label || c.name || "Local B2 Account",
+            provider: "backblaze",
+            serviceId: "backblaze",
+            credentials: {
+              keyId: c.b2KeyId || c.keyId || "",
+              applicationKey: c.b2ApplicationKey || c.applicationKey || "",
+              bucketName: c.b2BucketName || c.bucketName || "",
+              bucketId: c.b2BucketId || "",
+              endpoint: c.b2Endpoint || "s3.eu-central-003.backblazeb2.com",
+              region: c.b2Region || "eu-central-003"
+            }
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  let fetchError;
+  try {
+    const srklRes = await fetch(`${srklUrl}/api/srkl/accounts?service=${service2 || "backblaze"}`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (srklRes.ok) {
+      const sData = await srklRes.json();
+      if (Array.isArray(sData.accounts)) {
+        for (const sa of sData.accounts) {
+          rawAccounts.push(sa);
+        }
+      }
+    }
+  } catch (err) {
+    fetchError = err.message;
+  }
+  const accounts = deduplicateAccounts(rawAccounts);
+  return {
+    success: true,
+    deploymentUrl: srklUrl,
+    userId,
+    count: accounts.length,
+    accounts,
+    error: accounts.length > 0 ? void 0 : fetchError
+  };
+}
+async function listBackblazeBuckets(payload, rawUserId, env) {
+  try {
+    const userId = rawUserId || payload?.userId || payload?.credentials?.userId || "";
+    const creds = payload?.credentials || {};
+    let keyId = (payload?.keyId || payload?.b2KeyId || payload?.accessKeyId || creds.keyId || creds.b2KeyId || creds.accessKeyId || "").trim();
+    let appKey = (payload?.applicationKey || payload?.b2ApplicationKey || payload?.appKey || payload?.secretAccessKey || creds.applicationKey || creds.b2ApplicationKey || creds.appKey || creds.secretAccessKey || "").trim();
+    const bucketId = (payload?.bucketId || creds.bucketId || "").trim();
+    const bucketName = (payload?.bucketName || payload?.b2BucketName || creds.bucketName || creds.b2BucketName || "").trim();
+    if ((!keyId || !appKey) && (payload?.accountId || payload?.id)) {
+      const srkl = await getSrklAccounts(userId, "backblaze", env);
+      const matched = srkl.accounts?.find((a) => a.id === (payload.accountId || payload.id));
+      if (matched?.credentials) {
+        keyId = (matched.credentials.keyId || matched.credentials.b2KeyId || matched.credentials.accessKeyId || keyId).trim();
+        appKey = (matched.credentials.applicationKey || matched.credentials.b2ApplicationKey || matched.credentials.appKey || matched.credentials.secretAccessKey || appKey).trim();
+      }
+    }
+    if (!keyId || !appKey) return { success: false, error: "Backblaze credentials (Key ID and Application Key) required." };
+    try {
+      const buckets = await b2ListBuckets(keyId, appKey, bucketId || void 0, bucketName || void 0);
+      if (Array.isArray(buckets) && buckets.length > 0) return { success: true, buckets };
+    } catch (err) {
+      console.warn("[SrklCore] Direct B2 bucket query failed, trying SRKL fallback:", err.message);
+    }
+    const srklUrl = await getPrimarySrklDeploymentUrl(env);
+    const srklRes = await fetch(`${srklUrl}/api/backblaze/buckets`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-user-id": userId || "" },
+      body: JSON.stringify({ keyId, applicationKey: appKey, bucketId: bucketId || void 0 }),
+      signal: AbortSignal.timeout(6e3)
+    });
+    if (srklRes.ok) {
+      const data = await srklRes.json();
+      if (data.success && Array.isArray(data.buckets)) return { success: true, buckets: data.buckets };
+    }
+    return { success: true, buckets: [] };
+  } catch (err) {
+    return { success: false, error: err.message || "Failed to list Backblaze buckets" };
+  }
+}
+var srklListBackblazeBuckets = (keyId, applicationKey, bucketId, bucketName, userId, accountId) => listBackblazeBuckets({ keyId, applicationKey, bucketId, bucketName, accountId }, userId);
+async function getSrklStatus(env) {
+  const srklUrl = await getPrimarySrklDeploymentUrl(env);
+  const start = Date.now();
+  try {
+    const resp = await fetch(`${srklUrl}/api/ecosystem/health`, { signal: AbortSignal.timeout(5e3) });
+    const latencyMs = Date.now() - start;
+    if (resp.ok) {
+      const data = await resp.json().catch(() => ({}));
+      return { success: true, deploymentUrl: srklUrl, online: true, latencyMs, details: data };
+    }
+    return { success: false, deploymentUrl: srklUrl, online: false, status: resp.status, latencyMs };
+  } catch (err) {
+    return { success: false, deploymentUrl: srklUrl, online: false, error: err.message, latencyMs: Date.now() - start };
+  }
+}
+
 // src/srkl/srkl.ts
 var runtime = {
   VaultAccessClient: SrklVaultAccessClient,
@@ -508,7 +714,12 @@ var service = {
   name: "srkl",
   description: "SRKL Ecosystem Volatile Memory Credential Vault Service",
   runtime,
-  deployment
+  deployment,
+  getSrklAccounts: (userId, serviceName, env) => getSrklAccounts(userId, serviceName, env),
+  getAccounts: (userId, serviceName, env) => getSrklAccounts(userId, serviceName, env),
+  listBackblazeBuckets: (payload, userId, env) => listBackblazeBuckets(payload, userId, env),
+  getSrklStatus: (env) => getSrklStatus(env),
+  getDeploymentUrl: (env) => getPrimarySrklDeploymentUrl(env)
 };
 var srklService = service;
 
@@ -523,5 +734,10 @@ export {
   globalCredentialRegistry,
   SrklVaultAccessClient,
   syncSrklAccounts,
+  getPrimarySrklDeploymentUrl,
+  getSrklAccounts,
+  listBackblazeBuckets,
+  srklListBackblazeBuckets,
+  getSrklStatus,
   srklService
 };

package/packages/backend/dist/{chunk-E72GXBXF.js → chunk-6K75XXFD.js}

@@ -1,193 +1,12 @@
-// src/core/unifiedDb.ts
-var neon;
-function cleanDbUrl(url) {
-  if (!url || typeof url !== "string") return "";
-  return url.trim().replace(/^["']|["']$/g, "");
-}
-function getUnifiedDbUrl(env) {
-  const fromEnv = cleanDbUrl(env?.SYSTEM_DATABASE_URL_1) || cleanDbUrl(env?.DATABASE_URL) || cleanDbUrl(env?.SYSTEM_DATABASE_URL_2);
-  if (fromEnv) return fromEnv;
-  if (typeof process !== "undefined" && process.env) {
-    return cleanDbUrl(process.env.SYSTEM_DATABASE_URL_1) || cleanDbUrl(process.env.DATABASE_URL) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_2) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_3) || "";
-  }
-  return "";
-}
-async function queryUnifiedDb(sqlText, params = [], env) {
-  const dbUrl = getUnifiedDbUrl(env);
-  if (!dbUrl) {
-    throw new Error("[UnifiedDB] No database URL configured in environment.");
-  }
-  if (!neon) {
-    const mod = await import("@neondatabase/serverless");
-    neon = mod.neon;
-  }
-  const sql = neon(dbUrl);
-  try {
-    const rows = await (sql.query ? sql.query(sqlText, params) : sql(sqlText, params));
-    return {
-      rows: Array.isArray(rows) ? rows : [],
-      rowCount: Array.isArray(rows) ? rows.length : 0
-    };
-  } catch (err) {
-    console.error("[UnifiedDB] Query execution error:", err.message);
-    throw err;
-  }
-}
-
-// src/core/b2DirectCore.ts
-var authCache = /* @__PURE__ */ new Map();
-var bucketIdCache = /* @__PURE__ */ new Map();
-async function authorizeB2(keyId, applicationKey) {
-  const cacheKey = `${keyId.trim()}:${applicationKey.trim()}`;
-  const cached = authCache.get(cacheKey);
-  if (cached && Date.now() < cached.expiresAt) return cached.auth;
-  const authHeader = typeof Buffer !== "undefined" ? Buffer.from(`${keyId.trim()}:${applicationKey.trim()}`).toString("base64") : btoa(`${keyId.trim()}:${applicationKey.trim()}`);
-  let res = await fetch("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", {
-    headers: { Authorization: `Basic ${authHeader}` },
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!res.ok) {
-    res = await fetch("https://api.backblazeb2.com/b2api/v4/b2_authorize_account", {
-      headers: { Authorization: `Basic ${authHeader}` },
-      signal: AbortSignal.timeout(1e4)
-    });
-  }
-  if (!res.ok) {
-    const errText = await res.text();
-    throw new Error(`Backblaze B2 authorization failed (${res.status}): ${errText}`);
-  }
-  const data = await res.json();
-  const auth = {
-    accountId: data.accountId,
-    authorizationToken: data.authorizationToken,
-    apiUrl: (data.apiInfo?.storageApi?.apiUrl || data.apiUrl || "https://api.backblazeb2.com").replace(/\/+$/, ""),
-    downloadUrl: (data.apiInfo?.storageApi?.downloadUrl || data.downloadUrl || data.apiUrl || "https://f003.backblazeb2.com").replace(/\/+$/, ""),
-    s3ApiUrl: data.apiInfo?.storageApi?.s3ApiUrl || data.s3ApiUrl,
-    allowed: data.apiInfo?.storageApi?.allowed || data.allowed
-  };
-  authCache.set(cacheKey, { auth, expiresAt: Date.now() + 20 * 60 * 1e3 });
-  return auth;
-}
-async function b2ListBuckets(keyId, applicationKey, bucketId, bucketName) {
-  const auth = await authorizeB2(keyId, applicationKey);
-  const rBucketId = bucketId || auth.allowed?.bucketId || auth.allowed?.buckets?.[0]?.bucketId;
-  const rBucketName = bucketName || auth.allowed?.bucketName || auth.allowed?.buckets?.[0]?.bucketName;
-  if (!auth.allowed?.bucketId && !auth.allowed?.bucketName) {
-    try {
-      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
-        method: "POST",
-        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-        body: JSON.stringify({ accountId: auth.accountId }),
-        signal: AbortSignal.timeout(8e3)
-      });
-      if (res.ok) {
-        const data = await res.json();
-        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
-      }
-    } catch (err) {
-      console.warn("[B2DirectCore] list_buckets query failed:", err.message);
-    }
-  }
-  if (rBucketId || rBucketName) {
-    const body = { accountId: auth.accountId };
-    if (rBucketId) body.bucketId = rBucketId;
-    else if (rBucketName) body.bucketName = rBucketName;
-    try {
-      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
-        method: "POST",
-        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(8e3)
-      });
-      if (res.ok) {
-        const data = await res.json();
-        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
-      }
-    } catch {
-    }
-    return [{
-      accountId: auth.accountId,
-      bucketId: rBucketId || "restricted",
-      bucketName: rBucketName || (bucketName || "default-bucket"),
-      bucketType: "allPrivate"
-    }];
-  }
-  return [];
-}
-async function getB2BucketId(keyId, applicationKey, bucketName) {
-  const cacheKey = `${keyId.trim()}:${bucketName.trim()}`;
-  if (bucketIdCache.has(cacheKey)) return bucketIdCache.get(cacheKey);
-  const buckets = await b2ListBuckets(keyId, applicationKey, void 0, bucketName);
-  const match = buckets.find((b) => b.bucketName === bucketName);
-  if (!match) throw new Error(`B2 bucket "${bucketName}" not found in account`);
-  bucketIdCache.set(cacheKey, match.bucketId);
-  return match.bucketId;
-}
-async function b2UploadFile(keyId, applicationKey, bucketName, fileName, buffer, contentType = "b2/x-auto") {
-  const auth = await authorizeB2(keyId, applicationKey);
-  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
-  const urlRes = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_upload_url`, {
-    method: "POST",
-    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-    body: JSON.stringify({ bucketId })
-  });
-  if (!urlRes.ok) throw new Error(`B2 get upload url failed (${urlRes.status})`);
-  const { uploadUrl, authorizationToken } = await urlRes.json();
-  const encodedFileName = encodeURIComponent(fileName).replace(/%2F/g, "/");
-  const uploadRes = await fetch(uploadUrl, {
-    method: "POST",
-    headers: {
-      Authorization: authorizationToken,
-      "X-Bz-File-Name": encodedFileName,
-      "Content-Type": contentType,
-      "Content-Length": String(buffer.byteLength),
-      "X-Bz-Content-Sha1": "do_not_verify"
-    },
-    body: buffer
-  });
-  if (!uploadRes.ok) throw new Error(`B2 upload failed for ${fileName} (${uploadRes.status}): ${await uploadRes.text()}`);
-  return uploadRes.json();
-}
-async function b2DownloadFile(keyId, applicationKey, bucketName, fileName) {
-  const auth = await authorizeB2(keyId, applicationKey);
-  const encodedName = encodeURIComponent(fileName).replace(/%2F/g, "/");
-  const res = await fetch(`${auth.downloadUrl}/file/${bucketName}/${encodedName}`, { headers: { Authorization: auth.authorizationToken } });
-  if (res.status === 404) return null;
-  if (!res.ok) throw new Error(`B2 download failed for ${fileName} (${res.status})`);
-  return new Uint8Array(await res.arrayBuffer());
-}
-async function b2ListFileNames(keyId, applicationKey, bucketName, prefix = "") {
-  const auth = await authorizeB2(keyId, applicationKey);
-  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
-  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_file_names`, {
-    method: "POST",
-    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-    body: JSON.stringify({ bucketId, prefix, maxFileCount: 1e3 })
-  });
-  if (!res.ok) throw new Error(`B2 list files failed (${res.status})`);
-  const data = await res.json();
-  return data.files || [];
-}
-async function b2DeleteFileVersion(keyId, applicationKey, fileName, fileId) {
-  const auth = await authorizeB2(keyId, applicationKey);
-  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_delete_file_version`, {
-    method: "POST",
-    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-    body: JSON.stringify({ fileName, fileId })
-  });
-  if (!res.ok) throw new Error(`B2 delete file version failed (${res.status})`);
-  return res.json();
-}
-async function b2DeleteFolder(keyId, applicationKey, bucketName, folderPrefix) {
-  const cleanPrefix = folderPrefix.replace(/\/+$/, "") + "/";
-  const files = await b2ListFileNames(keyId, applicationKey, bucketName, cleanPrefix);
-  let deletedCount = 0;
-  for (const file of files) {
-    await b2DeleteFileVersion(keyId, applicationKey, file.fileName, file.fileId);
-    deletedCount++;
-  }
-  return { success: true, deletedCount };
-}
+import {
+  b2DeleteFileVersion,
+  b2DeleteFolder,
+  b2DownloadFile,
+  b2ListBuckets,
+  b2ListFileNames,
+  b2UploadFile,
+  queryUnifiedDb
+} from "./chunk-VAFCR2MS.js";
 
 // src/core/workspaceFileCore.ts
 async function getFs() {
@@ -718,16 +537,6 @@ async function getWorkspaceStorageDetails(workspaceId, env) {
 }
 
 export {
-  cleanDbUrl,
-  getUnifiedDbUrl,
-  queryUnifiedDb,
-  b2ListBuckets,
-  getB2BucketId,
-  b2UploadFile,
-  b2DownloadFile,
-  b2ListFileNames,
-  b2DeleteFileVersion,
-  b2DeleteFolder,
   getWorkspaceFolderPrefix,
   isB2Workspace,
   writeWorkspaceFile,