@ultrst-armada/kloks 1.6.0 → 1.7.1

package/packages/backend/dist/{chunk-GPXV4GBD.js → chunk-6W7OAGNV.js}

@@ -1,18 +1,16 @@
 import {
-  b2DownloadFile,
-  b2ListFileNames,
-  b2UploadFile,
   createWorkspace,
   deleteWorkspace,
-  deleteWorkspaceFile,
   findUserWorkspace,
   getWorkspaces,
-  listWorkspaceFiles,
-  queryUnifiedDb,
-  readWorkspaceFile,
-  updateWorkspace,
-  writeWorkspaceFile
-} from "./chunk-E72GXBXF.js";
+  updateWorkspace
+} from "./chunk-6K75XXFD.js";
+import {
+  b2DownloadFile,
+  b2ListFileNames,
+  b2UploadFile,
+  queryUnifiedDb
+} from "./chunk-VAFCR2MS.js";
 
 // src/workspace/WorkspaceFS.ts
 import { SkipoBase } from "@ultrst-armada/kloks/functions";
@@ -133,58 +131,6 @@ var WorkspaceCloneSyncEngine = class extends SkipoBase3 {
   }
 };
 
-// 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";
@@ -243,8 +189,10 @@ function setWorkingWorkspaceConfig(cfg) {
   }
   return updated;
 }
-function getWorkingWorkspaceDir() {
-  const dir = getWorkingWorkspaceConfig().workingDirectory;
+function getWorkingWorkspaceDir(workspaceId = "default") {
+  const root = getWorkingWorkspaceConfig().workingDirectory;
+  const safeId = workspaceId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const dir = path.join(root, safeId);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -329,7 +277,7 @@ async function syncWorkspace(workspaceId) {
   }
   const { workspace, user, connection } = match;
   const folderKey = getWorkspaceFolderKey(workspace, user);
-  const workingDir = getWorkingWorkspaceDir();
+  const workingDir = getWorkingWorkspaceDir(workspaceId);
   const isB2 = workspace.storageProvider === "backblaze_b2" || workspace.storageConfig?.type === "b2";
   const syncedFiles = [];
   let uploadedCount = 0;
@@ -503,8 +451,8 @@ var WorkingWorkspaceService = class {
   }
   workingDirResolver;
   type = "working";
-  getWorkingDir() {
-    return this.workingDirResolver ? this.workingDirResolver() : getWorkingWorkspaceDir();
+  getWorkingDir(workspaceId) {
+    return this.workingDirResolver ? this.workingDirResolver(workspaceId) : getWorkingWorkspaceDir(workspaceId);
   }
   async findWorkspace(workspaceId, env) {
     return await findUserWorkspace(workspaceId, env);
@@ -514,7 +462,7 @@ var WorkingWorkspaceService = class {
   }
   async createWorkspace(userId, data, env) {
     const res = await createWorkspace(userId, data, env);
-    const dir = this.getWorkingDir();
+    const dir = this.getWorkingDir(res.workspace?.id || data?.id || "default");
     try {
       await fs2.promises.mkdir(dir, { recursive: true });
     } catch {
@@ -529,12 +477,12 @@ var WorkingWorkspaceService = class {
   }
   async readFile(_workspaceId, filePath) {
     const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
+    const fullPath = path2.resolve(this.getWorkingDir(_workspaceId), cleanRel);
     return await fs2.promises.readFile(fullPath);
   }
   async writeFile(_workspaceId, filePath, content) {
     const cleanRel = filePath.replace(/^\/+/, "");
-    const fullPath = path2.resolve(this.getWorkingDir(), cleanRel);
+    const fullPath = path2.resolve(this.getWorkingDir(_workspaceId), 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);
@@ -551,7 +499,7 @@ var WorkingWorkspaceService = class {
     }
   }
   async listFiles(_workspaceId, subfolder = "") {
-    const baseDir = path2.resolve(this.getWorkingDir(), subfolder.replace(/^\/+/, ""));
+    const baseDir = path2.resolve(this.getWorkingDir(_workspaceId), subfolder.replace(/^\/+/, ""));
     if (!fs2.existsSync(baseDir)) return [];
     const entries = await fs2.promises.readdir(baseDir, { withFileTypes: true });
     return entries.map((e) => {
@@ -565,7 +513,7 @@ var WorkingWorkspaceService = class {
       } catch {
       }
       return {
-        path: path2.relative(this.getWorkingDir(), full),
+        path: path2.relative(this.getWorkingDir(_workspaceId), full),
         name: e.name,
         isFolder: e.isDirectory(),
         sizeBytes,
@@ -579,12 +527,46 @@ var WorkingWorkspaceService = class {
 };
 var workingWorkspaceService = new WorkingWorkspaceService();
 
+// src/workspace/RemoteWorkspaceService.ts
+var RemoteWorkspaceService = class {
+  type = "working";
+  findWorkspace(id, env) {
+    return workingWorkspaceService.findWorkspace(id, env);
+  }
+  listWorkspaces(userId, env) {
+    return workingWorkspaceService.listWorkspaces(userId, env);
+  }
+  createWorkspace(userId, data, env) {
+    return workingWorkspaceService.createWorkspace(userId, data, env);
+  }
+  updateWorkspace(userId, params, env) {
+    return workingWorkspaceService.updateWorkspace(userId, params, env);
+  }
+  deleteWorkspace(userId, id, env) {
+    return workingWorkspaceService.deleteWorkspace(userId, id, env);
+  }
+  readFile(id, path3, env) {
+    return workingWorkspaceService.readFile(id, path3);
+  }
+  writeFile(id, path3, content, env) {
+    return workingWorkspaceService.writeFile(id, path3, content);
+  }
+  deleteFile(id, path3, env) {
+    return workingWorkspaceService.deleteFile(id, path3);
+  }
+  listFiles(id, subfolder, env) {
+    return workingWorkspaceService.listFiles(id, subfolder);
+  }
+  sync(id, options, env) {
+    return workingWorkspaceService.sync(id, options);
+  }
+};
+var remoteWorkspaceService = workingWorkspaceService;
+
 export {
   WorkspaceFS,
   SyncEngine,
   WorkspaceCloneSyncEngine,
-  RemoteWorkspaceService,
-  remoteWorkspaceService,
   getDefaultWorkingWorkspaceDir,
   getWorkingWorkspaceConfig,
   setWorkingWorkspaceConfig,
@@ -593,5 +575,7 @@ export {
   getWorkspaceFolderKey,
   syncWorkspace,
   WorkingWorkspaceService,
-  workingWorkspaceService
+  workingWorkspaceService,
+  RemoteWorkspaceService,
+  remoteWorkspaceService
 };

package/packages/backend/dist/{chunk-GQUNN7SA.js → chunk-7ZT2ZPPH.js}

@@ -1,13 +1,13 @@
 import {
   workspaceGraphService
-} from "./chunk-DBZVGMJ7.js";
+} from "./chunk-F6IDQLC2.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
-} from "./chunk-VDROUXFT.js";
+} from "./chunk-XHADDA75.js";
 import {
   StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
+} from "./chunk-R45CEV46.js";
 import {
   b2ListBuckets
 } from "./chunk-4QEMALXF.js";
@@ -20,9 +20,11 @@ import {
   deleteWorkspace,
   findUserWorkspace,
   getWorkspaces,
-  queryUnifiedDb,
   updateWorkspace
-} from "./chunk-E72GXBXF.js";
+} from "./chunk-6K75XXFD.js";
+import {
+  queryUnifiedDb
+} from "./chunk-VAFCR2MS.js";
 import {
   RateLimiter,
   SessionManager,

package/packages/backend/dist/{chunk-DBZVGMJ7.js → chunk-F6IDQLC2.js}

@@ -1,9 +1,9 @@
 import {
   StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
+} from "./chunk-R45CEV46.js";
 import {
   findUserWorkspace
-} from "./chunk-E72GXBXF.js";
+} from "./chunk-6K75XXFD.js";
 
 // src/services/workspaceGraphService.ts
 function slugify(name) {

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

@@ -0,0 +1,134 @@
+import {
+  BaseStorageAdapter,
+  ensureS3DirectoryMarker,
+  permanentDeleteS3Folder,
+  permanentDeleteS3Object,
+  renameS3Folder
+} from "./chunk-R45CEV46.js";
+
+// src/storage/S3Adapter.ts
+var S3Client;
+var PutObjectCommand;
+var GetObjectCommand;
+var ListObjectsV2Command;
+var HeadObjectCommand;
+var S3Adapter = class extends BaseStorageAdapter {
+  client;
+  bucket;
+  constructor(config) {
+    super(config);
+    this.bucket = config.bucket || "";
+  }
+  async ensureClient() {
+    if (this.client) return;
+    try {
+      const aws = await import("@aws-sdk/client-s3");
+      S3Client = aws.S3Client;
+      PutObjectCommand = aws.PutObjectCommand;
+      GetObjectCommand = aws.GetObjectCommand;
+      ListObjectsV2Command = aws.ListObjectsV2Command;
+      HeadObjectCommand = aws.HeadObjectCommand;
+      this.client = new S3Client({
+        region: this.config.region || "us-east-1",
+        endpoint: this.config.endpoint,
+        credentials: {
+          accessKeyId: this.config.accessKey,
+          secretAccessKey: this.config.secretKey
+        },
+        forcePathStyle: Boolean(this.config.endpoint)
+      });
+    } catch (e) {
+      throw new Error(`@aws-sdk/client-s3 failed to initialize: ${e.message}`);
+    }
+  }
+  async read(pathStr) {
+    await this.ensureClient();
+    const command = new GetObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
+    const response = await this.client.send(command);
+    return response.Body ? await response.Body.transformToByteArray() : new Uint8Array();
+  }
+  async write(pathStr, data, contentType = "application/octet-stream") {
+    await this.ensureClient();
+    const body = typeof data === "string" ? Buffer.from(data, "utf-8") : Buffer.from(data);
+    const command = new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: this.normalizePath(pathStr),
+      Body: body,
+      ContentType: contentType
+    });
+    await this.client.send(command);
+  }
+  async delete(pathStr) {
+    await this.ensureClient();
+    await permanentDeleteS3Object(this.client, this.bucket, this.normalizePath(pathStr));
+  }
+  async deleteFolder(pathStr) {
+    await this.ensureClient();
+    return await permanentDeleteS3Folder(this.client, this.bucket, this.normalizePath(pathStr));
+  }
+  async renameFolder(oldPath, newPath) {
+    await this.ensureClient();
+    return await renameS3Folder(this.client, this.bucket, this.normalizePath(oldPath), this.normalizePath(newPath));
+  }
+  async ensureDirectory(pathStr) {
+    await this.ensureClient();
+    await ensureS3DirectoryMarker(this.client, this.bucket, this.normalizePath(pathStr));
+  }
+  async exists(pathStr) {
+    await this.ensureClient();
+    try {
+      const command = new HeadObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
+      await this.client.send(command);
+      return true;
+    } catch (e) {
+      if (e.name === "NotFound" || e.$metadata?.httpStatusCode === 404) return false;
+      throw e;
+    }
+  }
+  async list(pathStr = "") {
+    await this.ensureClient();
+    const prefix = pathStr ? this.normalizePath(pathStr).replace(/\/+$/, "") + "/" : "";
+    const command = new ListObjectsV2Command({ Bucket: this.bucket, Prefix: prefix });
+    const response = await this.client.send(command);
+    return (response.Contents || []).map((item) => ({
+      path: item.Key,
+      size: item.Size || 0,
+      modifiedAt: item.LastModified ? item.LastModified.getTime() : 0
+    }));
+  }
+  async stat(pathStr) {
+    await this.ensureClient();
+    const command = new HeadObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
+    const response = await this.client.send(command);
+    return {
+      path: pathStr,
+      size: response.ContentLength || 0,
+      modifiedAt: response.LastModified ? response.LastModified.getTime() : 0
+    };
+  }
+  async mkdir(pathStr) {
+    await this.ensureDirectory(pathStr);
+  }
+  async testConnection() {
+    const start = performance.now();
+    try {
+      await this.ensureClient();
+      const res = await this.client.send(new ListObjectsV2Command({ Bucket: this.bucket, MaxKeys: 1 }));
+      return {
+        ok: true,
+        latencyMs: Math.round(performance.now() - start),
+        details: { bucket: this.bucket, keyCount: res.KeyCount ?? 0 }
+      };
+    } catch (e) {
+      return {
+        ok: false,
+        latencyMs: Math.round(performance.now() - start),
+        error: e.message
+      };
+    }
+  }
+};
+
+export {
+  S3Adapter
+};