@ultrst-armada/kloks 1.4.3 → 1.4.4

package/packages/backend/dist/chunk-5336MTXD.js

@@ -0,0 +1,597 @@
+import {
+  b2DownloadFile,
+  b2ListFileNames,
+  b2UploadFile,
+  createWorkspace,
+  deleteWorkspace,
+  deleteWorkspaceFile,
+  findUserWorkspace,
+  getWorkspaces,
+  listWorkspaceFiles,
+  queryUnifiedDb,
+  readWorkspaceFile,
+  updateWorkspace,
+  writeWorkspaceFile
+} from "./chunk-JXUSBKJ2.js";
+
+// 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/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,
+  RemoteWorkspaceService,
+  remoteWorkspaceService,
+  getDefaultWorkingWorkspaceDir,
+  getWorkingWorkspaceConfig,
+  setWorkingWorkspaceConfig,
+  getWorkingWorkspaceDir,
+  findWorkspaceRecord,
+  getWorkspaceFolderKey,
+  syncWorkspace,
+  WorkingWorkspaceService,
+  workingWorkspaceService
+};