@ultrst-armada/kloks 1.7.0 → 1.7.1

package/.krusbl-release-attestation.json

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

package/package.json

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

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

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

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

@@ -121,9 +121,10 @@ var SrklClient = class {
     const creds = account.credentials || {};
     const sId = (account.serviceId || "").toLowerCase();
     const isB2 = sId.includes("backblaze") || sId === "b2";
+    const isGoogle = sId.includes("google_drive") || sId.includes("googledrive") || sId === "google";
     return {
       id: `conn-srkl-${account.id}`,
-      provider: isB2 ? "backblaze_b2" : "aws_s3",
+      provider: isB2 ? "backblaze_b2" : isGoogle ? "google_drive" : "aws_s3",
       label: `SRKL: ${account.name || (isB2 ? "Backblaze" : "S3")}`,
       role: "redundant_clone",
       enabled: true,
@@ -137,7 +138,13 @@ var SrklClient = class {
       s3SecretAccessKey: creds.secretAccessKey || creds.applicationKey || creds.s3SecretAccessKey,
       s3BucketName: creds.bucketName || creds.s3BucketName,
       s3Region: creds.region || creds.s3Region,
-      s3Endpoint: creds.endpoint || creds.s3Endpoint
+      s3Endpoint: creds.endpoint || creds.s3Endpoint,
+      googleEmail: creds.email || account.credentials?.email || account.name,
+      googleRootFolderId: creds.rootFolderId,
+      googleRootFolderName: creds.rootFolderName,
+      googleAccessToken: creds.accessToken,
+      googleAccessTokenExpiresAt: creds.accessTokenExpiresAt,
+      googleRefreshToken: creds.refreshToken
     };
   }
 };

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

@@ -1,13 +1,9 @@
 import {
   createWorkspace,
   deleteWorkspace,
-  deleteWorkspaceFile,
   findUserWorkspace,
   getWorkspaces,
-  listWorkspaceFiles,
-  readWorkspaceFile,
-  updateWorkspace,
-  writeWorkspaceFile
+  updateWorkspace
 } from "./chunk-6K75XXFD.js";
 import {
   b2DownloadFile,
@@ -135,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";
@@ -245,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 });
   }
@@ -331,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;
@@ -505,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);
@@ -516,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 {
@@ -531,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);
@@ -553,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) => {
@@ -567,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,
@@ -581,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,
@@ -595,5 +575,7 @@ export {
   getWorkspaceFolderKey,
   syncWorkspace,
   WorkingWorkspaceService,
-  workingWorkspaceService
+  workingWorkspaceService,
+  RemoteWorkspaceService,
+  remoteWorkspaceService
 };

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

@@ -1,13 +1,13 @@
 import {
   workspaceGraphService
-} from "./chunk-KSZ67VZJ.js";
+} from "./chunk-F6IDQLC2.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
-} from "./chunk-N4Z57FVR.js";
+} from "./chunk-XHADDA75.js";
 import {
   StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
+} from "./chunk-R45CEV46.js";
 import {
   b2ListBuckets
 } from "./chunk-4QEMALXF.js";

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

@@ -1,6 +1,6 @@
 import {
   StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
+} from "./chunk-R45CEV46.js";
 import {
   findUserWorkspace
 } from "./chunk-6K75XXFD.js";

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
+};