@ultrst-armada/kloks 1.3.0 → 1.4.1

package/packages/backend/dist/chunk-DZ4ZGIZM.js

@@ -0,0 +1,1323 @@
+// 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/core/unifiedDb.ts
+import { neon } from "@neondatabase/serverless";
+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.");
+  }
+  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 };
+}
+
+// src/core/workspaceFileCore.ts
+async function getFs() {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    try {
+      const mod = await import("fs");
+      return mod.promises || mod.default?.promises || mod;
+    } catch {
+    }
+  }
+  return null;
+}
+async function getPath() {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    try {
+      const mod = await import("path");
+      return mod.default || mod;
+    } catch {
+    }
+  }
+  return null;
+}
+function getWorkspaceFolderPrefix(workspace) {
+  return workspace.localFolderKey || workspace.localFolderName || (workspace.workspacePath ? workspace.workspacePath.replace(/^\.\//, "") : workspace.id);
+}
+function isB2Workspace(workspace, connection) {
+  return connection?.provider === "backblaze_b2" || connection?.provider === "BACKBLAZE_B2" || workspace?.storageProvider === "backblaze_b2";
+}
+async function writeWorkspaceFile(workspace, connection, relativePath, content, contentType = "application/json") {
+  const cleanRel = relativePath.replace(/^\/+/, "");
+  const prefix = getWorkspaceFolderPrefix(workspace);
+  const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
+  if (isB2Workspace(workspace, connection)) {
+    const keyId = connection.b2KeyId || connection.keyId;
+    const appKey = connection.b2ApplicationKey || connection.appKey;
+    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
+    const fullKey = `${prefix}/${cleanRel}`;
+    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);
+}
+async function readWorkspaceFile(workspace, connection, relativePath) {
+  const cleanRel = relativePath.replace(/^\/+/, "");
+  const prefix = getWorkspaceFolderPrefix(workspace);
+  if (isB2Workspace(workspace, connection)) {
+    const keyId = connection.b2KeyId || connection.keyId;
+    const appKey = connection.b2ApplicationKey || connection.appKey;
+    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
+    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);
+  try {
+    const buf = await fs3.readFile(fullPath);
+    return new Uint8Array(buf);
+  } catch {
+    return null;
+  }
+}
+async function deleteWorkspaceFile(workspace, connection, relativePath) {
+  const cleanRel = relativePath.replace(/^\/+/, "");
+  const prefix = getWorkspaceFolderPrefix(workspace);
+  if (isB2Workspace(workspace, connection)) {
+    const keyId = connection.b2KeyId || connection.keyId;
+    const appKey = connection.b2ApplicationKey || connection.appKey;
+    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
+    const fullKey = `${prefix}/${cleanRel}`;
+    const files = await b2ListFileNames(keyId, appKey, bucketName, fullKey);
+    const match = files.find((f) => f.fileName === fullKey);
+    if (match) {
+      await b2DeleteFileVersion(keyId, appKey, match.fileName, match.fileId);
+      return true;
+    }
+    return false;
+  }
+  const fs3 = await getFs();
+  const path3 = await getPath();
+  if (!fs3 || !path3) return false;
+  const fullPath = path3.resolve(process.cwd(), prefix, cleanRel);
+  try {
+    await fs3.unlink(fullPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listWorkspaceFiles(workspace, connection, subPrefix = "") {
+  const folderPrefix = getWorkspaceFolderPrefix(workspace);
+  const targetPrefix = subPrefix ? `${folderPrefix}/${subPrefix.replace(/^\/+/, "")}` : `${folderPrefix}/`;
+  if (isB2Workspace(workspace, connection)) {
+    const keyId = connection.b2KeyId || connection.keyId;
+    const appKey = connection.b2ApplicationKey || connection.appKey;
+    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
+    const rawFiles = await b2ListFileNames(keyId, appKey, bucketName, targetPrefix);
+    return rawFiles.map((f) => ({
+      fileName: f.fileName.slice(folderPrefix.length + 1),
+      sizeBytes: f.contentLength,
+      uploadTimestamp: f.uploadTimestamp
+    }));
+  }
+  const fs3 = await getFs();
+  const path3 = await getPath();
+  if (!fs3 || !path3) return [];
+  const baseDir = path3.resolve(process.cwd(), folderPrefix, subPrefix);
+  try {
+    const entries = await fs3.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);
+        result.push({
+          fileName: path3.relative(path3.resolve(process.cwd(), folderPrefix), full),
+          sizeBytes: st.size
+        });
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+async function deleteWorkspaceFolder(workspace, connection) {
+  const prefix = getWorkspaceFolderPrefix(workspace);
+  if (isB2Workspace(workspace, connection)) {
+    const keyId = connection.b2KeyId || connection.keyId;
+    const appKey = connection.b2ApplicationKey || connection.appKey;
+    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
+    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);
+  try {
+    await fs3.rm(localDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/core/workspaceBucketSyncCore.ts
+function resolveWorkspaceConnection(profiles, workspace) {
+  const depm = profiles.depm || {};
+  const conns = depm.storage_connections?.length ? depm.storage_connections : profiles.srkl?.storage_connections || profiles.docustack?.storage_connections || [];
+  return conns.find((c) => c.id === workspace.storageConnectionId) || conns.find((c) => c.role === "primary") || conns[0] || null;
+}
+async function syncWorkspaceCreateToBucket(workspace, connection, env) {
+  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") return;
+  try {
+    const wsMeta = {
+      id: workspace.id,
+      name: workspace.name,
+      createdAt: workspace.createdAt,
+      updatedAt: workspace.updatedAt,
+      storageProvider: "backblaze_b2",
+      bucket: connection.b2BucketName || "ultrst-apps"
+    };
+    await writeWorkspaceFile(workspace, connection, ".bzEmpty", new Uint8Array(0), "application/x-empty");
+    await writeWorkspaceFile(workspace, connection, "workspace.json", JSON.stringify(wsMeta, null, 2), "application/json");
+    await writeWorkspaceFile(
+      workspace,
+      connection,
+      "ecosystem.json",
+      JSON.stringify({ apps: [], nodes: [], edges: [], ecosystems: [] }, null, 2),
+      "application/json"
+    );
+  } catch (err) {
+    console.warn("[WorkspaceBucketSync] Create sync error:", err.message);
+  }
+}
+async function syncWorkspaceDeleteToBucket(workspace, connection, env) {
+  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") return;
+  try {
+    await deleteWorkspaceFolder(workspace, connection);
+  } catch (err) {
+    console.warn("[WorkspaceBucketSync] Delete sync error:", err.message);
+  }
+}
+async function syncWorkspaceDataToBucket(workspace, connection, data, env) {
+  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") return;
+  try {
+    await writeWorkspaceFile(workspace, connection, "ecosystem.json", JSON.stringify(data, null, 2), "application/json");
+  } catch (err) {
+    console.warn("[WorkspaceBucketSync] Data sync error:", err.message);
+  }
+}
+
+// src/core/workspaceDataCore.ts
+async function resolveUserRow(userId, env) {
+  if (userId) {
+    const res = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR email = $1 LIMIT 1`, [userId], env);
+    if (res.rows.length > 0) return res.rows[0];
+  }
+  return null;
+}
+async function loadWorkspaceData(userId, workspaceId, env) {
+  if (!workspaceId) return { success: false, error: "workspaceId required", workspace: null };
+  const user = await resolveUserRow(userId, env);
+  if (!user) return { success: false, error: "User not found", workspace: null };
+  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
+  const depm = profiles.depm || {};
+  const workspaceDataMap = depm.workspace_data || {};
+  let data = workspaceDataMap[workspaceId];
+  const isEmptyData = !data || (!data.nodes || data.nodes.length === 0) && (!data.apps || data.apps.length === 0);
+  if (isEmptyData) {
+    const ws = (depm.workspaces || []).find((w) => w.id === workspaceId);
+    if (ws) {
+      const conn = resolveWorkspaceConnection(profiles, ws);
+      if (conn) {
+        try {
+          const fileBuf = await readWorkspaceFile(ws, conn, "ecosystem.json");
+          if (fileBuf && fileBuf.length > 0) {
+            const parsed = JSON.parse(new TextDecoder().decode(fileBuf));
+            if (parsed.nodes && parsed.nodes.length > 0 || parsed.apps && parsed.apps.length > 0) {
+              if (!profiles.depm) profiles.depm = {};
+              if (!profiles.depm.workspace_data) profiles.depm.workspace_data = {};
+              profiles.depm.workspace_data[workspaceId] = parsed;
+              data = parsed;
+              await queryUnifiedDb(
+                `UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`,
+                [JSON.stringify(profiles), user.id],
+                env
+              );
+              return { success: true, workspace: data, workspaceId };
+            }
+          }
+        } catch (err) {
+          console.warn("[WorkspaceDataCore] Storage recovery check:", err.message);
+        }
+      }
+    }
+  }
+  if (!data) {
+    const ws = (depm.workspaces || []).find((w) => w.id === workspaceId);
+    const ecoName = ws?.ecosystemName || `${ws?.name || "Workspace"} Ecosystem`;
+    const fallback = {
+      apps: [],
+      accounts: [],
+      deployments: [],
+      nodes: [],
+      edges: [],
+      ecosystems: [
+        {
+          id: `eco_${workspaceId}`,
+          name: ecoName,
+          icon: "Globe",
+          health: "HEALTHY",
+          status: "SYSTEM ONLINE",
+          connectedAppsCount: 0,
+          meshLinkCount: 0,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ],
+      ecosystemName: ecoName,
+      ecosystemNodes: [
+        {
+          id: `node_eco_root_${workspaceId}`,
+          type: "ECOSYSTEM",
+          name: ecoName,
+          x: 0,
+          y: 0,
+          appId: "__ecosystem__",
+          icon: "Globe",
+          ecosystemData: { connectedAppsCount: 0, health: "HEALTHY", status: "SYSTEM ONLINE" }
+        }
+      ],
+      ecosystemEdges: []
+    };
+    return { success: true, workspace: fallback, workspaceId };
+  }
+  return { success: true, workspace: data, workspaceId };
+}
+async function saveWorkspaceData(userId, workspaceId, data, env) {
+  if (!workspaceId) return { success: false, error: "workspaceId required" };
+  const user = await resolveUserRow(userId, env);
+  if (!user) return { success: false, error: "User not found" };
+  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
+  if (!profiles.depm) profiles.depm = {};
+  if (!profiles.depm.workspace_data) profiles.depm.workspace_data = {};
+  const existing = profiles.depm.workspace_data[workspaceId];
+  const incomingEmpty = (!data.nodes || data.nodes.length === 0) && (!data.apps || data.apps.length === 0);
+  const existingHasData = existing && (existing.nodes && existing.nodes.length > 0 || existing.apps && existing.apps.length > 0);
+  if (incomingEmpty && existingHasData && !data._forceEmptySave) {
+    console.warn(`[WorkspaceDataCore] Blocked empty overwrite for workspace ${workspaceId}.`);
+    return { success: true, workspaceId, workspace: existing, protected: true };
+  }
+  profiles.depm.workspace_data[workspaceId] = data;
+  if (Array.isArray(profiles.depm.workspaces)) {
+    const ws2 = profiles.depm.workspaces.find((w) => w.id === workspaceId);
+    if (ws2) {
+      ws2.appsCount = Array.isArray(data.apps) ? data.apps.length : 0;
+      ws2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  await queryUnifiedDb(
+    `UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`,
+    [JSON.stringify(profiles), user.id],
+    env
+  );
+  const ws = Array.isArray(profiles.depm?.workspaces) ? profiles.depm.workspaces.find((w) => w.id === workspaceId) : null;
+  if (ws) {
+    const conn = resolveWorkspaceConnection(profiles, ws);
+    await syncWorkspaceDataToBucket(ws, conn, data, env);
+  }
+  return { success: true, workspaceId, workspace: data };
+}
+async function renameAppInWorkspaceData(userId, workspaceId, appId, newName, env) {
+  if (!workspaceId || !appId || !newName) {
+    return { success: false, error: "workspaceId, appId and newName required" };
+  }
+  const loadRes = await loadWorkspaceData(userId, workspaceId, env);
+  if (!loadRes.success || !loadRes.workspace) return loadRes;
+  const wsData = loadRes.workspace;
+  const trimmed = newName.trim();
+  const folderName = trimmed.replace(/[/\\?%*:|"<>]/g, "_");
+  if (Array.isArray(wsData.apps)) {
+    const targetApp = wsData.apps.find((a) => a.id === appId);
+    if (targetApp) {
+      targetApp.name = trimmed;
+      targetApp.folderName = folderName;
+      targetApp.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  if (Array.isArray(wsData.nodes)) {
+    wsData.nodes = wsData.nodes.map((n) => {
+      if (n.appId === appId && (n.type === "APP" || n.type === "APP_NODE" || n.type === "APP_GRAPH_NODE")) {
+        return { ...n, name: trimmed, appData: n.appData ? { ...n.appData, name: trimmed, folderName } : void 0 };
+      }
+      return n;
+    });
+  }
+  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);
+  for (const user of res.rows) {
+    const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
+    const depm = profiles.depm || {};
+    const workspaces = Array.isArray(depm.workspaces) ? depm.workspaces : [];
+    const ws = workspaces.find((w) => w.id === workspaceId);
+    if (ws) {
+      const conns = depm.storage_connections || profiles.srkl?.storage_connections || profiles.docustack?.storage_connections || [];
+      const conn = conns.find((c) => c.id === ws.storageConnectionId) || conns.find((c) => c.role === "primary") || conns[0] || null;
+      return { user, workspace: ws, connection: conn };
+    }
+  }
+  return { user: null, workspace: null, connection: null };
+}
+async function getWorkspaces(userId, env) {
+  if (!userId) {
+    return { success: true, workspaces: [], activeWorkspaceId: null, storage_connections: [] };
+  }
+  const res = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR email = $1 LIMIT 1`, [userId], env);
+  const userRow = res.rows[0];
+  if (!userRow) {
+    return { success: true, workspaces: [], activeWorkspaceId: null, storage_connections: [] };
+  }
+  const profiles = typeof userRow.app_profiles === "string" ? JSON.parse(userRow.app_profiles) : userRow.app_profiles || {};
+  const depm = profiles.depm || {};
+  const workspaces = Array.isArray(depm.workspaces) ? depm.workspaces : [];
+  const activeWorkspaceId = depm.activeWorkspaceId || null;
+  const conns = depm.storage_connections?.length ? depm.storage_connections : profiles.srkl?.storage_connections || [];
+  return { success: true, workspaces, activeWorkspaceId, storage_connections: conns };
+}
+async function createWorkspace(userId, wsData, env) {
+  const uRes = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1`, [userId], env);
+  const user = uRes.rows[0];
+  if (!user) throw new Error("User account not found.");
+  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
+  if (!profiles.depm) profiles.depm = {};
+  const workspaces = Array.isArray(profiles.depm.workspaces) ? profiles.depm.workspaces : [];
+  const wsName = (wsData.name || "New Workspace").trim();
+  const wsId = wsData.id || `ws-depm-${Date.now()}`;
+  const userName = user.username || user.name || "user";
+  const folderKey = `ultrst_depm_${userName.toLowerCase().replace(/[^a-z0-9]/g, "_")}_${wsName.toLowerCase().replace(/[^a-z0-9]/g, "_")}`;
+  const newWs = {
+    ...wsData,
+    id: wsId,
+    name: wsName,
+    localFolderName: folderKey,
+    localFolderKey: folderKey,
+    workspacePath: `./${folderKey}`,
+    storageProvider: wsData.storageProvider || "backblaze_b2",
+    b2BucketName: wsData.b2BucketName || "ultrst-apps",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  workspaces.push(newWs);
+  profiles.depm.workspaces = workspaces;
+  profiles.depm.activeWorkspaceId = wsId;
+  await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(profiles), user.id], env);
+  const conn = resolveWorkspaceConnection(profiles, newWs);
+  await syncWorkspaceCreateToBucket(newWs, conn, env);
+  return { success: true, workspace: newWs, workspaces };
+}
+async function updateWorkspace(userId, params, env) {
+  const uRes = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1`, [userId], env);
+  const user = uRes.rows[0];
+  if (!user) throw new Error("User not found.");
+  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
+  if (!profiles.depm) profiles.depm = {};
+  const workspaces = Array.isArray(profiles.depm.workspaces) ? profiles.depm.workspaces : [];
+  const { action, workspaceId, updates } = params;
+  const targetId = workspaceId || updates?.id;
+  const match = workspaces.find((w) => w.id === targetId);
+  if (!match) throw new Error("Workspace not found.");
+  if (action === "switch") {
+    profiles.depm.activeWorkspaceId = targetId;
+  } else {
+    const safeUpdates = { ...updates || params };
+    delete safeUpdates.storageProvider;
+    delete safeUpdates.storageConnectionId;
+    delete safeUpdates.b2BucketName;
+    delete safeUpdates.b2Endpoint;
+    delete safeUpdates.b2Region;
+    delete safeUpdates.localFolderName;
+    delete safeUpdates.localFolderKey;
+    delete safeUpdates.workspacePath;
+    delete safeUpdates.primaryStorage;
+    delete safeUpdates.id;
+    delete safeUpdates.action;
+    delete safeUpdates.workspaceId;
+    Object.assign(match, safeUpdates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(profiles), user.id], env);
+  return { success: true, workspace: match, workspaces };
+}
+async function deleteWorkspace(userId, wsId, env) {
+  const uRes = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1`, [userId], env);
+  const user = uRes.rows[0];
+  if (!user) throw new Error("User not found.");
+  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
+  if (!profiles.depm?.workspaces) return { success: true, workspaces: [] };
+  const targetWs = profiles.depm.workspaces.find((w) => w.id === wsId);
+  const conn = targetWs ? resolveWorkspaceConnection(profiles, targetWs) : null;
+  profiles.depm.workspaces = profiles.depm.workspaces.filter((w) => w.id !== wsId);
+  if (profiles.depm.activeWorkspaceId === wsId) {
+    profiles.depm.activeWorkspaceId = profiles.depm.workspaces[0]?.id || null;
+  }
+  if (profiles.depm.workspace_data?.[wsId]) {
+    delete profiles.depm.workspace_data[wsId];
+  }
+  await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(profiles), user.id], env);
+  if (targetWs && conn) {
+    await syncWorkspaceDeleteToBucket(targetWs, conn, 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) {
+    return {
+      success: false,
+      workspaceId,
+      folderKey: workspaceId,
+      workingDir: getWorkingWorkspaceDir(),
+      persistenceType: "local_fs",
+      targetLocation: "Unknown",
+      syncedFiles: [],
+      uploadedCount: 0,
+      downloadedCount: 0,
+      syncedAt: nowIso,
+      error: `Workspace '${workspaceId}' not found.`
+    };
+  }
+  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 });
+        }
+      }
+      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."
+      };
+    }
+  }
+  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 });
+      }
+    }
+    return {
+      success: true,
+      workspaceId,
+      folderKey,
+      workingDir,
+      persistenceType: "local_fs",
+      targetLocation: vaultDir,
+      syncedFiles,
+      uploadedCount,
+      downloadedCount,
+      syncedAt: nowIso
+    };
+  } catch (err) {
+    return {
+      success: false,
+      workspaceId,
+      folderKey,
+      workingDir,
+      persistenceType: "local_fs",
+      targetLocation: vaultDir,
+      syncedFiles,
+      uploadedCount,
+      downloadedCount,
+      syncedAt: nowIso,
+      error: err.message
+    };
+  }
+}
+
+// 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,
+  cleanDbUrl,
+  getUnifiedDbUrl,
+  queryUnifiedDb,
+  b2ListBuckets,
+  getB2BucketId,
+  b2DeleteFileVersion,
+  b2DeleteFolder,
+  getWorkspaceFolderPrefix,
+  isB2Workspace,
+  writeWorkspaceFile,
+  readWorkspaceFile,
+  deleteWorkspaceFile,
+  listWorkspaceFiles,
+  deleteWorkspaceFolder,
+  resolveWorkspaceConnection,
+  syncWorkspaceCreateToBucket,
+  syncWorkspaceDeleteToBucket,
+  syncWorkspaceDataToBucket,
+  loadWorkspaceData,
+  saveWorkspaceData,
+  renameAppInWorkspaceData,
+  getWorkspaceStorageDetails,
+  findUserWorkspace,
+  getWorkspaces,
+  createWorkspace,
+  updateWorkspace,
+  deleteWorkspace,
+  RemoteWorkspaceService,
+  remoteWorkspaceService,
+  getDefaultWorkingWorkspaceDir,
+  getWorkingWorkspaceConfig,
+  setWorkingWorkspaceConfig,
+  getWorkingWorkspaceDir,
+  findWorkspaceRecord,
+  getWorkspaceFolderKey,
+  syncWorkspace,
+  WorkingWorkspaceService,
+  workingWorkspaceService
+};