@ultrst-armada/kloks 1.4.3 → 1.4.4

package/packages/backend/dist/{chunk-DZ4ZGIZM.js → chunk-JXUSBKJ2.js}

@@ -1,121 +1,13 @@
-// src/workspace/WorkspaceFS.ts
-import { SkipoBase } from "@ultrst-armada/kloks/functions";
-var WorkspaceFS = class extends SkipoBase {
-  primary;
-  syncEngine;
-  config;
-  constructor(primary, config, syncEngine) {
-    super();
-    this.primary = primary;
-    this.config = config;
-    this.syncEngine = syncEngine;
-  }
-  setPrimary(newPrimary) {
-    this.primary = newPrimary;
-  }
-  setSyncEngine(engine) {
-    this.syncEngine = engine;
-  }
-  async exists(pathStr) {
-    return this.primary.exists(pathStr);
-  }
-  async stat(pathStr) {
-    return this.primary.stat(pathStr);
-  }
-  async list(pathStr = "") {
-    return this.primary.list(pathStr);
-  }
-  async read(pathStr) {
-    return this.primary.read(pathStr);
-  }
-  async readText(pathStr) {
-    const data = await this.read(pathStr);
-    return Buffer.from(data).toString("utf8");
-  }
-  async write(pathStr, data) {
-    await this.primary.write(pathStr, data);
-    if (this.syncEngine && this.config.sync?.enabled && this.config.sync.mode === "on_write") {
-      this.syncEngine.syncFile(pathStr).catch((err) => {
-        console.warn(`[WorkspaceFS] Async backup sync warning for '${pathStr}':`, err.message);
-      });
-    }
-  }
-  async mkdir(pathStr) {
-    await this.primary.mkdir(pathStr);
-  }
-  async delete(pathStr) {
-    await this.primary.delete(pathStr);
-    if (this.syncEngine && this.config.sync?.enabled && this.config.sync.deletePropagation) {
-      this.syncEngine.deleteFile(pathStr).catch((err) => {
-        console.warn(`[WorkspaceFS] Async delete sync warning for '${pathStr}':`, err.message);
-      });
-    }
-  }
-};
-
-// src/workspace/SyncEngine.ts
-import { SkipoBase as SkipoBase2 } from "@ultrst-armada/kloks/functions";
-var SyncEngine = class extends SkipoBase2 {
-  primary;
-  backups;
-  config;
-  constructor(primary, backups, config) {
-    super({ name: "SyncEngine" });
-    this.primary = primary;
-    this.backups = backups;
-    this.config = config;
-  }
-  async syncFile(pathStr) {
-    const data = await this.primary.read(pathStr);
-    for (const backup of this.backups) {
-      try {
-        await backup.write(pathStr, data);
-      } catch (e) {
-        console.error(`[SyncEngine] Failed to sync ${pathStr} to backup:`, e.message);
-      }
-    }
-  }
-  async deleteFile(pathStr) {
-    for (const backup of this.backups) {
-      try {
-        await backup.delete(pathStr);
-      } catch (e) {
-        console.error(`[SyncEngine] Failed to delete ${pathStr} on backup:`, e.message);
-      }
-    }
-  }
-};
-
-// src/workspace/WorkspaceCloneSyncEngine.ts
-import { SkipoBase as SkipoBase3 } from "@ultrst-armada/kloks/functions";
-var WorkspaceCloneSyncEngine = class extends SkipoBase3 {
-  constructor() {
-    super({ name: "WorkspaceCloneSyncEngine" });
-  }
-  async replicateToClones(files, clones, uploadFn) {
-    const results = [];
-    let totalSynced = 0;
-    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-    for (const clone of clones) {
-      try {
-        let count = 0;
-        for (const file of files) {
-          await uploadFn(clone, file.relPath, file.content, file.contentType);
-          count++;
-        }
-        clone.lastSyncedAt = nowIso;
-        clone.filesSynced = count;
-        clone.status = "SYNCED";
-        results.push({ cloneId: clone.id, label: clone.label, provider: clone.provider, filesSynced: count, status: "SYNCED" });
-        totalSynced += count;
-      } catch (err) {
-        clone.status = "ERROR";
-        results.push({ cloneId: clone.id, label: clone.label, provider: clone.provider, filesSynced: 0, status: "ERROR", error: err.message });
-      }
-    }
-    return { results, totalSynced };
-  }
-};
+// src/workspace/WorkspaceCanonical.ts
+function formatCanonicalWorkspaceFolderName(appName, userName, workspaceName) {
+  const safeApp = appName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  const safeUser = userName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  const safeWs = workspaceName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  return `ultrst_${safeApp}_${safeUser}_${safeWs}`;
+}
+function sanitizeWorkspaceName(name) {
+  return name.replace(/[^a-zA-Z0-9-_\s]/g, "").trim();
+}
 
 // src/core/unifiedDb.ts
 import { neon } from "@neondatabase/serverless";
@@ -343,12 +235,12 @@ async function writeWorkspaceFile(workspace, connection, relativePath, content,
     await b2UploadFile(keyId, appKey, bucketName, fullKey, buffer, contentType);
     return;
   }
-  const fs3 = await getFs();
-  const path3 = await getPath();
-  if (!fs3 || !path3) throw new Error("Local filesystem operations not supported in this runtime.");
-  const localDir = path3.resolve(process.cwd(), prefix, path3.dirname(cleanRel));
-  await fs3.mkdir(localDir, { recursive: true });
-  await fs3.writeFile(path3.resolve(process.cwd(), prefix, cleanRel), buffer);
+  const fs = await getFs();
+  const path = await getPath();
+  if (!fs || !path) throw new Error("Local filesystem operations not supported in this runtime.");
+  const localDir = path.resolve(process.cwd(), prefix, path.dirname(cleanRel));
+  await fs.mkdir(localDir, { recursive: true });
+  await fs.writeFile(path.resolve(process.cwd(), prefix, cleanRel), buffer);
 }
 async function readWorkspaceFile(workspace, connection, relativePath) {
   const cleanRel = relativePath.replace(/^\/+/, "");
@@ -360,12 +252,12 @@ async function readWorkspaceFile(workspace, connection, relativePath) {
     const fullKey = `${prefix}/${cleanRel}`;
     return await b2DownloadFile(keyId, appKey, bucketName, fullKey);
   }
-  const fs3 = await getFs();
-  const path3 = await getPath();
-  if (!fs3 || !path3) return null;
-  const fullPath = path3.resolve(process.cwd(), prefix, cleanRel);
+  const fs = await getFs();
+  const path = await getPath();
+  if (!fs || !path) return null;
+  const fullPath = path.resolve(process.cwd(), prefix, cleanRel);
   try {
-    const buf = await fs3.readFile(fullPath);
+    const buf = await fs.readFile(fullPath);
     return new Uint8Array(buf);
   } catch {
     return null;
@@ -387,12 +279,12 @@ async function deleteWorkspaceFile(workspace, connection, relativePath) {
     }
     return false;
   }
-  const fs3 = await getFs();
-  const path3 = await getPath();
-  if (!fs3 || !path3) return false;
-  const fullPath = path3.resolve(process.cwd(), prefix, cleanRel);
+  const fs = await getFs();
+  const path = await getPath();
+  if (!fs || !path) return false;
+  const fullPath = path.resolve(process.cwd(), prefix, cleanRel);
   try {
-    await fs3.unlink(fullPath);
+    await fs.unlink(fullPath);
     return true;
   } catch {
     return false;
@@ -412,19 +304,19 @@ async function listWorkspaceFiles(workspace, connection, subPrefix = "") {
       uploadTimestamp: f.uploadTimestamp
     }));
   }
-  const fs3 = await getFs();
-  const path3 = await getPath();
-  if (!fs3 || !path3) return [];
-  const baseDir = path3.resolve(process.cwd(), folderPrefix, subPrefix);
+  const fs = await getFs();
+  const path = await getPath();
+  if (!fs || !path) return [];
+  const baseDir = path.resolve(process.cwd(), folderPrefix, subPrefix);
   try {
-    const entries = await fs3.readdir(baseDir, { withFileTypes: true, recursive: true });
+    const entries = await fs.readdir(baseDir, { withFileTypes: true, recursive: true });
     const result = [];
     for (const entry of entries) {
       if (entry.isFile()) {
-        const full = path3.join(entry.parentPath || baseDir, entry.name);
-        const st = await fs3.stat(full);
+        const full = path.join(entry.parentPath || baseDir, entry.name);
+        const st = await fs.stat(full);
         result.push({
-          fileName: path3.relative(path3.resolve(process.cwd(), folderPrefix), full),
+          fileName: path.relative(path.resolve(process.cwd(), folderPrefix), full),
           sizeBytes: st.size
         });
       }
@@ -443,12 +335,12 @@ async function deleteWorkspaceFolder(workspace, connection) {
     await b2DeleteFolder(keyId, appKey, bucketName, prefix);
     return;
   }
-  const fs3 = await getFs();
-  const path3 = await getPath();
-  if (!fs3 || !path3) return;
-  const localDir = path3.resolve(process.cwd(), prefix);
+  const fs = await getFs();
+  const path = await getPath();
+  if (!fs || !path) return;
+  const localDir = path.resolve(process.cwd(), prefix);
   try {
-    await fs3.rm(localDir, { recursive: true, force: true });
+    await fs.rm(localDir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -648,73 +540,6 @@ async function renameAppInWorkspaceData(userId, workspaceId, appId, newName, env
   return await saveWorkspaceData(userId, workspaceId, wsData, env);
 }
 
-// src/core/workspaceStorageDetailsCore.ts
-async function getWorkspaceStorageDetails(workspaceId, env) {
-  if (!workspaceId) return { success: false, error: "workspaceId is required" };
-  const { workspace, connection } = await findUserWorkspace(workspaceId, env);
-  const folderPrefix = workspace?.localFolderKey || workspace?.localFolderName || (workspace?.workspacePath ? workspace.workspacePath.replace(/^\.\//, "") : workspaceId);
-  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") {
-    return {
-      success: true,
-      workspaceId,
-      storageProvider: workspace?.storageProvider || "local_fs",
-      connection: connection || null,
-      folderPrefix,
-      localStats: { exists: false, appsCount: 0, ecosystemsCount: 0 },
-      bucket: null,
-      files: []
-    };
-  }
-  const keyId = connection.b2KeyId || connection.keyId;
-  const applicationKey = connection.b2ApplicationKey || connection.appKey;
-  const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-  try {
-    const buckets = await b2ListBuckets(keyId, applicationKey, void 0, bucketName);
-    const bucketObj = buckets.find((b) => b.bucketName === bucketName);
-    if (!bucketObj) {
-      return {
-        success: true,
-        workspaceId,
-        storageProvider: "backblaze_b2",
-        connection: { id: connection.id, label: connection.label, provider: connection.provider },
-        folderPrefix,
-        bucket: { name: bucketName, status: "BUCKET_NOT_FOUND" },
-        files: []
-      };
-    }
-    const rawFiles = await b2ListFileNames(keyId, applicationKey, bucketName, `${folderPrefix}/`);
-    return {
-      success: true,
-      workspaceId,
-      storageProvider: "backblaze_b2",
-      connection: { id: connection.id, label: connection.label, provider: connection.provider },
-      folderPrefix,
-      bucket: {
-        id: bucketObj.bucketId,
-        name: bucketObj.bucketName,
-        type: bucketObj.bucketType,
-        endpoint: connection.b2Endpoint || "s3.eu-central-003.backblazeb2.com",
-        region: connection.b2Region || "eu-central-003",
-        status: "CONNECTED"
-      },
-      fileCount: rawFiles.length,
-      files: rawFiles.map((f) => ({
-        fileName: f.fileName,
-        sizeBytes: f.contentLength,
-        uploadTimestamp: f.uploadTimestamp
-      }))
-    };
-  } catch (err) {
-    return {
-      success: false,
-      workspaceId,
-      storageProvider: "backblaze_b2",
-      error: err.message,
-      folderPrefix
-    };
-  }
-}
-
 // src/core/workspaceCore.ts
 async function findUserWorkspace(workspaceId, env) {
   const res = await queryUnifiedDb(`SELECT id, email, username, app_profiles FROM "ultrst-users"`, [], env);
@@ -832,461 +657,84 @@ async function deleteWorkspace(userId, wsId, env) {
   return { success: true, workspaces: profiles.depm.workspaces };
 }
 
-// src/workspace/RemoteWorkspaceService.ts
-var RemoteWorkspaceService = class {
-  type = "remote";
-  async findWorkspace(workspaceId, env) {
-    return await findUserWorkspace(workspaceId, env);
-  }
-  async listWorkspaces(userId, env) {
-    return await getWorkspaces(userId, env);
-  }
-  async createWorkspace(userId, data, env) {
-    return await createWorkspace(userId, data, env);
-  }
-  async updateWorkspace(userId, params, env) {
-    return await updateWorkspace(userId, params, env);
-  }
-  async deleteWorkspace(userId, workspaceId, env) {
-    return await deleteWorkspace(userId, workspaceId, env);
-  }
-  async readFile(workspaceId, filePath, env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    const data = await readWorkspaceFile(workspace, connection, filePath);
-    if (!data) throw new Error(`File "${filePath}" not found in workspace "${workspaceId}".`);
-    return data;
-  }
-  async writeFile(workspaceId, filePath, content, env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    await writeWorkspaceFile(workspace, connection, filePath, content);
-    const size = typeof content === "string" ? new TextEncoder().encode(content).length : content.byteLength;
-    return { success: true, path: filePath, sizeBytes: size };
-  }
-  async deleteFile(workspaceId, filePath, env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    const deleted = await deleteWorkspaceFile(workspace, connection, filePath);
-    return { success: deleted };
-  }
-  async listFiles(workspaceId, subfolder = "", env) {
-    const { workspace, connection } = await this.findWorkspace(workspaceId, env);
-    if (!workspace) throw new Error(`Workspace "${workspaceId}" not found.`);
-    const files = await listWorkspaceFiles(workspace, connection, subfolder);
-    return files.map((f) => ({
-      path: f.fileName,
-      name: f.fileName.split("/").pop() || f.fileName,
-      sizeBytes: f.sizeBytes,
-      updatedAt: f.uploadTimestamp
-    }));
-  }
-};
-var remoteWorkspaceService = new RemoteWorkspaceService();
-
-// src/workspace/WorkingWorkspaceService.ts
-import fs2 from "fs";
-import path2 from "path";
-
-// src/core/workspaceSyncEngine.ts
-import fs from "fs";
-import path from "path";
-
-// src/core/workspaceCanonical.ts
-function formatCanonicalWorkspaceFolderName(appName, userName, workspaceName) {
-  const safeApp = (appName || "qwnsr").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeUser = (userName || "user").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeWs = (workspaceName || "workspace").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  return `ultrst_${safeApp}_${safeUser}_${safeWs}`;
-}
-
-// src/core/workspaceSyncEngine.ts
-var ACCOUNTS_FILE = path.resolve(".skipo/accounts.json");
-var CONFIG_FILE = path.resolve(".skipo/workspace_config.json");
-function getDefaultWorkingWorkspaceDir() {
-  if (process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME) {
-    return path.join("/tmp", "workspace");
-  }
-  return path.join(process.cwd(), "workspace");
-}
-function getWorkingWorkspaceConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (parsed.workingDirectory) {
-        return {
-          workingDirectory: parsed.workingDirectory,
-          autoSyncIntervalMinutes: parsed.autoSyncIntervalMinutes || 5
-        };
-      }
-    }
-  } catch {
-  }
-  return {
-    workingDirectory: getDefaultWorkingWorkspaceDir(),
-    autoSyncIntervalMinutes: 5
-  };
-}
-function setWorkingWorkspaceConfig(cfg) {
-  const current = getWorkingWorkspaceConfig();
-  const updated = {
-    workingDirectory: (cfg.workingDirectory || current.workingDirectory).trim(),
-    autoSyncIntervalMinutes: cfg.autoSyncIntervalMinutes || current.autoSyncIntervalMinutes
-  };
-  try {
-    fs.mkdirSync(path.dirname(CONFIG_FILE), { recursive: true });
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), "utf-8");
-  } catch (err) {
-    console.warn("[WorkspaceSync] Failed to persist working config:", err);
-  }
-  return updated;
-}
-function getWorkingWorkspaceDir() {
-  const dir = getWorkingWorkspaceConfig().workingDirectory;
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-async function findWorkspaceRecord(workspaceId) {
-  try {
-    if (fs.existsSync(ACCOUNTS_FILE)) {
-      const raw = fs.readFileSync(ACCOUNTS_FILE, "utf-8");
-      const accounts = JSON.parse(raw);
-      for (const u of Object.values(accounts)) {
-        if (Array.isArray(u.workspaces)) {
-          const ws = u.workspaces.find((w) => w.id === workspaceId);
-          if (ws) {
-            const conns = Array.isArray(u.storage_connections) ? u.storage_connections : [];
-            const conn = conns.find((c) => c.id === ws.storageConnectionId) || conns[0] || null;
-            return { user: u, workspace: ws, connection: conn };
-          }
-        }
-      }
-    }
-  } catch {
-  }
-  try {
-    const res = await queryUnifiedDb(`SELECT id, email, username, app_profiles FROM "ultrst-users"`);
-    for (const u of res.rows) {
-      const profiles = typeof u.app_profiles === "string" ? JSON.parse(u.app_profiles) : u.app_profiles || {};
-      const qwnsr = profiles.qwnsr || {};
-      const workspaces = Array.isArray(qwnsr.workspaces) ? qwnsr.workspaces : [];
-      const ws = workspaces.find((w) => w.id === workspaceId);
-      if (ws) {
-        const conns = qwnsr.storage_connections || profiles.srkl?.storage_connections || [];
-        const conn = conns.find((c) => c.id === ws.storageConnectionId) || conns[0] || null;
-        return { user: u, workspace: ws, connection: conn };
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-function getWorkspaceFolderKey(workspace, user) {
-  if (workspace.localFolderKey) return workspace.localFolderKey;
-  if (workspace.localFolderName && workspace.localFolderName.startsWith("ultrst_")) return workspace.localFolderName;
-  const userName = user?.username || user?.name || (user?.email ? user.email.split("@")[0] : "user");
-  return formatCanonicalWorkspaceFolderName("qwnsr", userName, workspace.name);
-}
-async function collectLocalFiles(dir, baseDir = dir) {
-  if (!fs.existsSync(dir)) return [];
-  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-  const results = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") && entry.name !== ".bzEmpty") continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const nested = await collectLocalFiles(full, baseDir);
-      results.push(...nested);
-    } else if (entry.isFile()) {
-      const st = await fs.promises.stat(full);
-      const rel = path.relative(baseDir, full).replace(/\\/g, "/");
-      results.push({ relPath: rel, fullPath: full, mtimeMs: st.mtimeMs, sizeBytes: st.size });
-    }
-  }
-  return results;
-}
-async function syncWorkspace(workspaceId) {
-  const match = await findWorkspaceRecord(workspaceId);
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-  if (!match) {
+// src/core/workspaceStorageDetailsCore.ts
+async function getWorkspaceStorageDetails(workspaceId, env) {
+  if (!workspaceId) return { success: false, error: "workspaceId is required" };
+  const { workspace, connection } = await findUserWorkspace(workspaceId, env);
+  const folderPrefix = workspace?.localFolderKey || workspace?.localFolderName || (workspace?.workspacePath ? workspace.workspacePath.replace(/^\.\//, "") : workspaceId);
+  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") {
     return {
-      success: false,
+      success: true,
       workspaceId,
-      folderKey: workspaceId,
-      workingDir: getWorkingWorkspaceDir(),
-      persistenceType: "local_fs",
-      targetLocation: "Unknown",
-      syncedFiles: [],
-      uploadedCount: 0,
-      downloadedCount: 0,
-      syncedAt: nowIso,
-      error: `Workspace '${workspaceId}' not found.`
+      storageProvider: workspace?.storageProvider || "local_fs",
+      connection: connection || null,
+      folderPrefix,
+      localStats: { exists: false, appsCount: 0, ecosystemsCount: 0 },
+      bucket: null,
+      files: []
     };
   }
-  const { workspace, user, connection } = match;
-  const folderKey = getWorkspaceFolderKey(workspace, user);
-  const workingDir = getWorkingWorkspaceDir();
-  const isB2 = workspace.storageProvider === "backblaze_b2" || workspace.storageConfig?.type === "b2";
-  const syncedFiles = [];
-  let uploadedCount = 0;
-  let downloadedCount = 0;
-  if (isB2) {
-    const creds = workspace.storageConfig || connection?.credentials || connection || {};
-    const keyId = creds.keyId || creds.b2KeyId;
-    const appKey = creds.applicationKey || creds.b2ApplicationKey || creds.appKey;
-    const bucketName = creds.bucketName || creds.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    if (!keyId || !appKey) {
-      return {
-        success: false,
-        workspaceId,
-        folderKey,
-        workingDir,
-        persistenceType: "backblaze_b2",
-        targetLocation: bucketName,
-        syncedFiles: [],
-        uploadedCount: 0,
-        downloadedCount: 0,
-        syncedAt: nowIso,
-        error: "Missing Backblaze B2 credentials for sync."
-      };
-    }
-    try {
-      const b2Prefix = `${folderKey}/`;
-      const remoteFiles = await b2ListFileNames(keyId, appKey, bucketName, b2Prefix);
-      const remoteMap = /* @__PURE__ */ new Map();
-      for (const rf of remoteFiles) {
-        const cleanName = rf.fileName.slice(b2Prefix.length);
-        if (cleanName) remoteMap.set(cleanName, { fileId: rf.fileId, size: rf.contentLength, timestamp: rf.uploadTimestamp });
-      }
-      const localFiles = await collectLocalFiles(workingDir);
-      const localMap = /* @__PURE__ */ new Map();
-      for (const lf of localFiles) {
-        localMap.set(lf.relPath, lf);
-      }
-      for (const [relPath, rInfo] of remoteMap.entries()) {
-        const lFile = localMap.get(relPath);
-        const shouldDownload = !lFile || rInfo.timestamp > lFile.mtimeMs + 2e3;
-        if (shouldDownload) {
-          const buf = await b2DownloadFile(keyId, appKey, bucketName, `${b2Prefix}${relPath}`);
-          if (buf) {
-            const destPath = path.join(workingDir, relPath);
-            await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
-            await fs.promises.writeFile(destPath, buf);
-            try {
-              const fileTime = new Date(rInfo.timestamp);
-              await fs.promises.utimes(destPath, fileTime, fileTime);
-            } catch {
-            }
-            syncedFiles.push({ fileName: relPath, action: "DOWNLOADED", sizeBytes: buf.byteLength });
-            downloadedCount++;
-          }
-        }
-      }
-      for (const [relPath, lFile] of localMap.entries()) {
-        const rInfo = remoteMap.get(relPath);
-        const shouldUpload = !rInfo || lFile.mtimeMs > rInfo.timestamp + 2e3;
-        if (shouldUpload) {
-          const content = await fs.promises.readFile(lFile.fullPath);
-          await b2UploadFile(keyId, appKey, bucketName, `${b2Prefix}${relPath}`, new Uint8Array(content));
-          syncedFiles.push({ fileName: relPath, action: "UPLOADED", sizeBytes: lFile.sizeBytes });
-          uploadedCount++;
-        } else if (!syncedFiles.some((f) => f.fileName === relPath)) {
-          syncedFiles.push({ fileName: relPath, action: "UP_TO_DATE", sizeBytes: lFile.sizeBytes });
-        }
-      }
+  const keyId = connection.b2KeyId || connection.keyId;
+  const applicationKey = connection.b2ApplicationKey || connection.appKey;
+  const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
+  try {
+    const buckets = await b2ListBuckets(keyId, applicationKey, void 0, bucketName);
+    const bucketObj = buckets.find((b) => b.bucketName === bucketName);
+    if (!bucketObj) {
       return {
         success: true,
         workspaceId,
-        folderKey,
-        workingDir,
-        persistenceType: "backblaze_b2",
-        targetLocation: `B2://${bucketName}/${folderKey}/`,
-        syncedFiles,
-        uploadedCount,
-        downloadedCount,
-        syncedAt: nowIso
-      };
-    } catch (err) {
-      return {
-        success: false,
-        workspaceId,
-        folderKey,
-        workingDir,
-        persistenceType: "backblaze_b2",
-        targetLocation: bucketName,
-        syncedFiles,
-        uploadedCount,
-        downloadedCount,
-        syncedAt: nowIso,
-        error: err.message || "Backblaze sync failed."
+        storageProvider: "backblaze_b2",
+        connection: { id: connection.id, label: connection.label, provider: connection.provider },
+        folderPrefix,
+        bucket: { name: bucketName, status: "BUCKET_NOT_FOUND" },
+        files: []
       };
     }
-  }
-  const vaultDir = path.resolve(process.cwd(), folderKey);
-  await fs.promises.mkdir(vaultDir, { recursive: true });
-  try {
-    const vaultFiles = await collectLocalFiles(vaultDir);
-    const vaultMap = new Map(vaultFiles.map((f) => [f.relPath, f]));
-    const workingFiles = await collectLocalFiles(workingDir);
-    const workingMap = new Map(workingFiles.map((f) => [f.relPath, f]));
-    for (const [relPath, vFile] of vaultMap.entries()) {
-      const wFile = workingMap.get(relPath);
-      const shouldDownload = !wFile || vFile.mtimeMs > wFile.mtimeMs + 1e3;
-      if (shouldDownload) {
-        const dest = path.join(workingDir, relPath);
-        await fs.promises.mkdir(path.dirname(dest), { recursive: true });
-        await fs.promises.copyFile(vFile.fullPath, dest);
-        try {
-          const vTime = new Date(vFile.mtimeMs);
-          await fs.promises.utimes(dest, vTime, vTime);
-        } catch {
-        }
-        syncedFiles.push({ fileName: relPath, action: "DOWNLOADED", sizeBytes: vFile.sizeBytes });
-        downloadedCount++;
-      }
-    }
-    for (const [relPath, wFile] of workingMap.entries()) {
-      const vFile = vaultMap.get(relPath);
-      const shouldUpload = !vFile || wFile.mtimeMs > vFile.mtimeMs + 1e3;
-      if (shouldUpload) {
-        const dest = path.join(vaultDir, relPath);
-        await fs.promises.mkdir(path.dirname(dest), { recursive: true });
-        await fs.promises.copyFile(wFile.fullPath, dest);
-        try {
-          const wTime = new Date(wFile.mtimeMs);
-          await fs.promises.utimes(dest, wTime, wTime);
-        } catch {
-        }
-        syncedFiles.push({ fileName: relPath, action: "UPLOADED", sizeBytes: wFile.sizeBytes });
-        uploadedCount++;
-      } else if (!syncedFiles.some((f) => f.fileName === relPath)) {
-        syncedFiles.push({ fileName: relPath, action: "UP_TO_DATE", sizeBytes: wFile.sizeBytes });
-      }
-    }
+    const rawFiles = await b2ListFileNames(keyId, applicationKey, bucketName, `${folderPrefix}/`);
     return {
       success: true,
       workspaceId,
-      folderKey,
-      workingDir,
-      persistenceType: "local_fs",
-      targetLocation: vaultDir,
-      syncedFiles,
-      uploadedCount,
-      downloadedCount,
-      syncedAt: nowIso
+      storageProvider: "backblaze_b2",
+      connection: { id: connection.id, label: connection.label, provider: connection.provider },
+      folderPrefix,
+      bucket: {
+        id: bucketObj.bucketId,
+        name: bucketObj.bucketName,
+        type: bucketObj.bucketType,
+        endpoint: connection.b2Endpoint || "s3.eu-central-003.backblazeb2.com",
+        region: connection.b2Region || "eu-central-003",
+        status: "CONNECTED"
+      },
+      fileCount: rawFiles.length,
+      files: rawFiles.map((f) => ({
+        fileName: f.fileName,
+        sizeBytes: f.contentLength,
+        uploadTimestamp: f.uploadTimestamp
+      }))
     };
   } catch (err) {
     return {
       success: false,
       workspaceId,
-      folderKey,
-      workingDir,
-      persistenceType: "local_fs",
-      targetLocation: vaultDir,
-      syncedFiles,
-      uploadedCount,
-      downloadedCount,
-      syncedAt: nowIso,
-      error: err.message
+      storageProvider: "backblaze_b2",
+      error: err.message,
+      folderPrefix
     };
   }
 }
 
-// src/workspace/WorkingWorkspaceService.ts
-var WorkingWorkspaceService = class {
-  constructor(workingDirResolver) {
-    this.workingDirResolver = workingDirResolver;
-  }
-  workingDirResolver;
-  type = "working";
-  getWorkingDir() {
-    return this.workingDirResolver ? this.workingDirResolver() : getWorkingWorkspaceDir();
-  }
-  async findWorkspace(workspaceId, env) {
-    return await findUserWorkspace(workspaceId, env);
-  }
-  async listWorkspaces(userId, env) {
-    return await getWorkspaces(userId, env);
-  }
-  async createWorkspace(userId, data, env) {
-    const res = await createWorkspace(userId, data, env);
-    const dir = this.getWorkingDir();
-    try {
-      await fs2.promises.mkdir(dir, { recursive: true });
-    } catch {
-    }
-    return res;
-  }
-  async updateWorkspace(userId, params, env) {
-    return await updateWorkspace(userId, params, env);
-  }
-  async deleteWorkspace(userId, workspaceId, env) {
-    return await deleteWorkspace(userId, workspaceId, env);
-  }
-  async readFile(_workspaceId, filePath) {
-    const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
-    return await fs2.promises.readFile(fullPath);
-  }
-  async writeFile(_workspaceId, filePath, content) {
-    const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
-    await fs2.promises.mkdir(path2.dirname(fullPath), { recursive: true });
-    const buffer = typeof content === "string" ? Buffer.from(content) : Buffer.from(content.buffer, content.byteOffset, content.byteLength);
-    await fs2.promises.writeFile(fullPath, buffer);
-    return { success: true, path: filePath, sizeBytes: buffer.byteLength };
-  }
-  async deleteFile(_workspaceId, filePath) {
-    const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
-    try {
-      await fs2.promises.unlink(fullPath);
-      return { success: true };
-    } catch {
-      return { success: false };
-    }
-  }
-  async listFiles(_workspaceId, subfolder = "") {
-    const baseDir = path2.resolve(this.getWorkingDir(), subfolder.replace(/^\/+/, ""));
-    if (!fs2.existsSync(baseDir)) return [];
-    const entries = await fs2.promises.readdir(baseDir, { withFileTypes: true });
-    return entries.map((e) => {
-      const full = path2.join(baseDir, e.name);
-      let sizeBytes = 0;
-      let updatedAt = Date.now();
-      try {
-        const s = fs2.statSync(full);
-        sizeBytes = s.size;
-        updatedAt = s.mtimeMs;
-      } catch {
-      }
-      return {
-        path: path2.relative(this.getWorkingDir(), full),
-        name: e.name,
-        isFolder: e.isDirectory(),
-        sizeBytes,
-        updatedAt
-      };
-    });
-  }
-  async sync(workspaceId, _options, _env) {
-    return await syncWorkspace(workspaceId);
-  }
-};
-var workingWorkspaceService = new WorkingWorkspaceService();
-
 export {
-  WorkspaceFS,
-  SyncEngine,
-  WorkspaceCloneSyncEngine,
+  formatCanonicalWorkspaceFolderName,
+  sanitizeWorkspaceName,
   cleanDbUrl,
   getUnifiedDbUrl,
   queryUnifiedDb,
   b2ListBuckets,
   getB2BucketId,
+  b2UploadFile,
+  b2DownloadFile,
+  b2ListFileNames,
   b2DeleteFileVersion,
   b2DeleteFolder,
   getWorkspaceFolderPrefix,
@@ -1308,16 +756,5 @@ export {
   getWorkspaces,
   createWorkspace,
   updateWorkspace,
-  deleteWorkspace,
-  RemoteWorkspaceService,
-  remoteWorkspaceService,
-  getDefaultWorkingWorkspaceDir,
-  getWorkingWorkspaceConfig,
-  setWorkingWorkspaceConfig,
-  getWorkingWorkspaceDir,
-  findWorkspaceRecord,
-  getWorkspaceFolderKey,
-  syncWorkspace,
-  WorkingWorkspaceService,
-  workingWorkspaceService
+  deleteWorkspace
 };