@ultrst-armada/kloks 1.4.2 → 1.4.4

package/packages/backend/dist/{chunk-FO6WYLW4.js → chunk-KI3LHMUN.js}

@@ -1,22 +1,33 @@
 import {
-  createService,
-  createServiceDefinition
-} from "./chunk-7KNGX522.js";
+  getSrklAccounts,
+  srklListBackblazeBuckets
+} from "./chunk-VDROUXFT.js";
 import {
   StorageAdapterFactory
 } from "./chunk-J2J24JVC.js";
 import {
+  b2ListBuckets
+} from "./chunk-4QEMALXF.js";
+import {
+  createWorkspace,
+  deleteWorkspace,
+  findUserWorkspace,
   formatCanonicalWorkspaceFolderName,
-  sanitizeWorkspaceName
-} from "./chunk-FZKBTF34.js";
+  getWorkspaces,
+  queryUnifiedDb,
+  sanitizeWorkspaceName,
+  updateWorkspace
+} from "./chunk-JXUSBKJ2.js";
 import {
   RateLimiter,
-  SessionManager
-} from "./chunk-25Y7AVTP.js";
+  SessionManager,
+  loginSystemUser,
+  resolveUserFromToken
+} from "./chunk-ZDH4XI7W.js";
 import {
-  ExecutableBackendFacade,
-  WorkerExecutionBoundary
-} from "./chunk-QGHDJGYS.js";
+  createService,
+  createServiceDefinition
+} from "./chunk-TY32TUNI.js";
 
 // src/krnl-services.ts
 var AuthServiceDefinition = createServiceDefinition({
@@ -35,6 +46,16 @@ var AuthServiceDefinition = createServiceDefinition({
         return sm.createSession(input.userId, input.role ?? "user");
       }
     },
+    login: {
+      id: "AuthService.login",
+      name: "login",
+      handler: async (input) => loginSystemUser(input.email, input.password, Boolean(input.isAdmin), (sql, params) => queryUnifiedDb(sql, params, input.env))
+    },
+    resolveUser: {
+      id: "AuthService.resolveUser",
+      name: "resolveUser",
+      handler: async (input) => resolveUserFromToken(input.tokenOrUserId, (sql, params) => queryUnifiedDb(sql, params, input.env))
+    },
     checkRateLimit: {
       id: "AuthService.checkRateLimit",
       name: "checkRateLimit",
@@ -65,6 +86,11 @@ var StorageServiceDefinition = createServiceDefinition({
   name: "StorageService",
   version: "1.0.0",
   operations: {
+    listBackblazeBuckets: {
+      id: "StorageService.listBackblazeBuckets",
+      name: "listBackblazeBuckets",
+      handler: async (input) => b2ListBuckets(input.keyId, input.applicationKey)
+    },
     resolveAdapterType: {
       id: "StorageService.resolveAdapterType",
       name: "resolveAdapterType",
@@ -101,6 +127,31 @@ var WorkspaceServiceDefinition = createServiceDefinition({
   name: "WorkspaceService",
   version: "1.0.0",
   operations: {
+    listWorkspaces: {
+      id: "WorkspaceService.listWorkspaces",
+      name: "listWorkspaces",
+      handler: async (input) => getWorkspaces(input.userId, input.env)
+    },
+    findWorkspace: {
+      id: "WorkspaceService.findWorkspace",
+      name: "findWorkspace",
+      handler: async (input) => findUserWorkspace(input.workspaceId, input.env)
+    },
+    createWorkspace: {
+      id: "WorkspaceService.createWorkspace",
+      name: "createWorkspace",
+      handler: async (input) => createWorkspace(input.userId, input.workspace, input.env)
+    },
+    updateWorkspace: {
+      id: "WorkspaceService.updateWorkspace",
+      name: "updateWorkspace",
+      handler: async (input) => updateWorkspace(input.userId, input.params, input.env)
+    },
+    deleteWorkspace: {
+      id: "WorkspaceService.deleteWorkspace",
+      name: "deleteWorkspace",
+      handler: async (input) => deleteWorkspace(input.userId, input.workspaceId, input.env)
+    },
     validateWorkspaceConfig: {
       id: "WorkspaceService.validateWorkspaceConfig",
       name: "validateWorkspaceConfig",
@@ -165,39 +216,6 @@ var ControlPlaneServiceFacade = {
     return controlPlaneServiceInstance.call(op, input);
   }
 };
-var ExecutionServiceDefinition = createServiceDefinition({
-  id: "kloks.backend.execution",
-  name: "ExecutionService",
-  version: "1.0.0",
-  operations: {
-    createWorkerBoundary: {
-      id: "ExecutionService.createWorkerBoundary",
-      name: "createWorkerBoundary",
-      handler: async (input) => {
-        const facade = new ExecutableBackendFacade(input.name);
-        const worker = new WorkerExecutionBoundary(`${input.name}Worker`, facade);
-        return {
-          facadeName: facade.name,
-          workerReady: Boolean(worker)
-        };
-      }
-    }
-  }
-});
-var executionServiceInstance = createService(ExecutionServiceDefinition);
-var ExecutionServiceFacade = {
-  id: ExecutionServiceDefinition.id,
-  name: ExecutionServiceDefinition.name,
-  version: ExecutionServiceDefinition.version,
-  runtime: "server",
-  deployment: "local",
-  definition: ExecutionServiceDefinition,
-  createInstance: () => createService(ExecutionServiceDefinition),
-  execute: async (op, input) => {
-    await executionServiceInstance.start();
-    return executionServiceInstance.call(op, input);
-  }
-};
 var DatabaseServiceDefinition = createServiceDefinition({
   id: "kloks.backend.database",
   name: "DatabaseService",
@@ -259,6 +277,61 @@ var GeminiServiceFacade = {
     return geminiServiceInstance.call(op, input);
   }
 };
+var krnlAuthServiceDefinition = AuthServiceDefinition;
+var krnlAuthServiceFacade = AuthServiceFacade;
+var krnlStorageServiceDefinition = StorageServiceDefinition;
+var krnlStorageServiceFacade = StorageServiceFacade;
+var krnlWorkspaceServiceDefinition = WorkspaceServiceDefinition;
+var krnlWorkspaceServiceFacade = WorkspaceServiceFacade;
+var krnlControlPlaneServiceDefinition = ControlPlaneServiceDefinition;
+var krnlControlPlaneServiceFacade = ControlPlaneServiceFacade;
+var krnlDatabaseServiceDefinition = DatabaseServiceDefinition;
+var krnlDatabaseServiceFacade = DatabaseServiceFacade;
+var krnlGeminiServiceDefinition = GeminiServiceDefinition;
+var krnlGeminiServiceFacade = GeminiServiceFacade;
+var SrklServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.srkl",
+  name: "SrklService",
+  version: "1.0.0",
+  operations: {
+    getAccounts: {
+      id: "SrklService.getAccounts",
+      name: "getAccounts",
+      handler: async (input) => getSrklAccounts(input.userId, input.service, (sql, params) => queryUnifiedDb(sql, params, input.env))
+    },
+    listBackblazeBuckets: {
+      id: "SrklService.listBackblazeBuckets",
+      name: "listBackblazeBuckets",
+      handler: async (input) => {
+        let keyId = input.keyId;
+        let applicationKey = input.applicationKey;
+        if ((!keyId || !applicationKey) && input.accountId && input.userId) {
+          const accounts = await getSrklAccounts(input.userId, "backblaze", (sql, params) => queryUnifiedDb(sql, params, input.env));
+          const account = accounts.accounts.find((item) => item.id === input.accountId);
+          keyId = account?.credentials?.keyId || account?.credentials?.b2KeyId;
+          applicationKey = account?.credentials?.applicationKey || account?.credentials?.b2ApplicationKey;
+        }
+        return srklListBackblazeBuckets(keyId, applicationKey, void 0, void 0, input.userId, (sql, params) => queryUnifiedDb(sql, params, input.env));
+      }
+    }
+  }
+});
+var srklServiceInstance = createService(SrklServiceDefinition);
+var SrklServiceFacade = {
+  id: SrklServiceDefinition.id,
+  name: SrklServiceDefinition.name,
+  version: SrklServiceDefinition.version,
+  runtime: "server",
+  deployment: "remote",
+  definition: SrklServiceDefinition,
+  createInstance: () => createService(SrklServiceDefinition),
+  execute: async (op, input) => {
+    await srklServiceInstance.start();
+    return srklServiceInstance.call(op, input);
+  }
+};
+var krnlSrklServiceDefinition = SrklServiceDefinition;
+var krnlSrklServiceFacade = SrklServiceFacade;
 
 export {
   AuthServiceDefinition,
@@ -269,10 +342,24 @@ export {
   WorkspaceServiceFacade,
   ControlPlaneServiceDefinition,
   ControlPlaneServiceFacade,
-  ExecutionServiceDefinition,
-  ExecutionServiceFacade,
   DatabaseServiceDefinition,
   DatabaseServiceFacade,
   GeminiServiceDefinition,
-  GeminiServiceFacade
+  GeminiServiceFacade,
+  krnlAuthServiceDefinition,
+  krnlAuthServiceFacade,
+  krnlStorageServiceDefinition,
+  krnlStorageServiceFacade,
+  krnlWorkspaceServiceDefinition,
+  krnlWorkspaceServiceFacade,
+  krnlControlPlaneServiceDefinition,
+  krnlControlPlaneServiceFacade,
+  krnlDatabaseServiceDefinition,
+  krnlDatabaseServiceFacade,
+  krnlGeminiServiceDefinition,
+  krnlGeminiServiceFacade,
+  SrklServiceDefinition,
+  SrklServiceFacade,
+  krnlSrklServiceDefinition,
+  krnlSrklServiceFacade
 };

package/packages/backend/dist/{chunk-4ZFXEFOE.js → chunk-MPYASJ5A.js}

@@ -1,7 +1,7 @@
 import {
   RateLimiter,
   SessionManager
-} from "./chunk-25Y7AVTP.js";
+} from "./chunk-ZDH4XI7W.js";
 
 // src/auth/PasswordHasher.ts
 var bcrypt = null;
@@ -172,94 +172,9 @@ var AdminGuard = class _AdminGuard extends SkipoBase2 {
   }
 };
 
-// src/auth/UnifiedAuthCore.ts
-import bcrypt2 from "bcryptjs";
-async function loginSystemUser(email, rawPass, isAdmin, queryDb) {
-  const normEmail = (email || "").trim().toLowerCase();
-  const password = (rawPass || "").trim();
-  if (!normEmail || !password) {
-    return { success: false, status: 400, error: "Email and password are required" };
-  }
-  try {
-    if (isAdmin) {
-      const credRes = await queryDb(`SELECT * FROM "ultrst-credentials" WHERE id = 'system' LIMIT 1`, []);
-      if (credRes.rows.length > 0) {
-        const cred = credRes.rows[0];
-        const matchEmail = (cred.admin_email || "").toLowerCase() === normEmail;
-        const matchPass = cred.admin_password === password || cred.admin_password && bcrypt2.compareSync(password, cred.admin_password);
-        if (matchEmail && matchPass) {
-          return {
-            success: true,
-            status: 200,
-            token: `adm_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-            user: { id: "admin_sys", email: cred.admin_email, username: "System Admin", name: "System Admin", role: "admin", status: "ACTIVE" }
-          };
-        }
-      }
-    }
-    const uRes = await queryDb(`SELECT * FROM "ultrst-users" WHERE LOWER(email) = $1 LIMIT 1`, [normEmail]);
-    if (uRes.rows.length === 0) {
-      return { success: false, status: 401, error: "Invalid email or password" };
-    }
-    const user = uRes.rows[0];
-    const hash = user.password_hash || "";
-    let isMatch = false;
-    if (hash.startsWith("$2a$") || hash.startsWith("$2b$")) {
-      isMatch = bcrypt2.compareSync(password, hash);
-    } else {
-      isMatch = hash === password;
-    }
-    if (!isMatch) {
-      return { success: false, status: 401, error: "Invalid email or password" };
-    }
-    if (isAdmin && user.role !== "admin") {
-      return { success: false, status: 403, error: "Insufficient administrative privileges" };
-    }
-    return {
-      success: true,
-      status: 200,
-      token: `usr_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-      user: {
-        id: user.id,
-        email: user.email,
-        username: user.username || user.name || user.email.split("@")[0],
-        name: user.name || user.username || "Ecosystem User",
-        role: user.role || "user",
-        status: user.status || "ACTIVE",
-        appProfiles: typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {}
-      }
-    };
-  } catch (err) {
-    return { success: false, status: 500, error: err.message };
-  }
-}
-async function resolveUserFromToken(tokenOrUserId, queryDb) {
-  if (!tokenOrUserId) return null;
-  let targetId = tokenOrUserId;
-  if (targetId.startsWith("Bearer ")) targetId = targetId.slice(7).trim();
-  if (targetId.startsWith("sess::")) {
-    const parts = targetId.split("::");
-    if (parts[1]) targetId = parts[1];
-  }
-  const res = await queryDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR LOWER(email) = LOWER($1) LIMIT 1`, [targetId]);
-  if (res.rows.length === 0) return null;
-  const u = res.rows[0];
-  return {
-    id: u.id,
-    email: u.email,
-    username: u.username || u.name || u.email.split("@")[0],
-    name: u.name || u.username || "Ecosystem User",
-    role: u.role || "user",
-    status: u.status || "ACTIVE",
-    appProfiles: typeof u.app_profiles === "string" ? JSON.parse(u.app_profiles) : u.app_profiles || {}
-  };
-}
-
 export {
   PasswordHasher,
   BaseAccountProvider,
   LocalAccountProvider,
-  AdminGuard,
-  loginSystemUser,
-  resolveUserFromToken
+  AdminGuard
 };

package/packages/backend/dist/{chunk-KX3OTBQ3.js → chunk-OZDYAEH4.js}

@@ -1,7 +1,3 @@
-import {
-  b2ListBuckets
-} from "./chunk-4QEMALXF.js";
-
 // src/srkl/SrklClient.ts
 var CANONICAL_SRKL_URL = "https://srkl-engine.vercel.app";
 var SrklClient = class {
@@ -144,113 +140,6 @@ function createSrklClient(options = {}) {
   return new SrklClient(options);
 }
 
-// src/srkl/SrklDiscoveryService.ts
-var cachedSrklUrl = null;
-async function getPrimarySrklDeploymentUrl(queryDb) {
-  if (cachedSrklUrl && Date.now() < cachedSrklUrl.expiresAt) return cachedSrklUrl.url;
-  if (queryDb) {
-    try {
-      const res = await queryDb(
-        `SELECT url FROM "ultrst-srkl-deployments" WHERE is_active = true ORDER BY is_primary DESC, priority DESC, created_at ASC LIMIT 1`,
-        []
-      );
-      if (res.rows.length > 0 && res.rows[0].url) {
-        const url = res.rows[0].url.trim().replace(/\/+$/, "");
-        cachedSrklUrl = { url, expiresAt: Date.now() + 10 * 60 * 1e3 };
-        return url;
-      }
-    } catch {
-    }
-  }
-  const fallback = "https://srkl-engine.vercel.app";
-  cachedSrklUrl = { url: fallback, expiresAt: Date.now() + 10 * 60 * 1e3 };
-  return fallback;
-}
-async function getSrklAccounts(userId, service2, queryDb) {
-  const srklUrl = await getPrimarySrklDeploymentUrl(queryDb);
-  const accounts = [];
-  const seenKeys = /* @__PURE__ */ new Set();
-  if (queryDb && userId) {
-    try {
-      const uRes = await queryDb(`SELECT app_profiles FROM "ultrst-users" WHERE id = $1 LIMIT 1`, [userId]);
-      if (uRes.rows.length > 0) {
-        const p = typeof uRes.rows[0].app_profiles === "string" ? JSON.parse(uRes.rows[0].app_profiles) : uRes.rows[0].app_profiles || {};
-        const pool = [
-          ...p.srkl?.storage_connections || [],
-          ...p.depm?.storage_connections || [],
-          ...p.qwnsr?.storage_connections || [],
-          ...p.loky?.storage_connections || []
-        ];
-        for (const conn of pool) {
-          if (service2 && !conn.provider?.toLowerCase().includes(service2.toLowerCase())) continue;
-          const kId = (conn.b2KeyId || conn.keyId || conn.accessKeyId || "").trim();
-          const key = kId ? `key:${kId}` : `id:${conn.id}`;
-          if (!seenKeys.has(key)) {
-            seenKeys.add(key);
-            accounts.push({
-              id: conn.id,
-              name: conn.label || conn.id,
-              provider: conn.provider,
-              serviceId: conn.provider,
-              credentials: {
-                keyId: conn.b2KeyId || conn.keyId,
-                applicationKey: conn.b2ApplicationKey || conn.appKey,
-                bucketName: conn.b2BucketName || conn.bucketName,
-                region: conn.b2Region || conn.region,
-                endpoint: conn.b2Endpoint || conn.endpoint
-              }
-            });
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  try {
-    const res = await fetch(`${srklUrl}/api/ecosystem/services`, {
-      headers: { "x-user-id": userId, Accept: "application/json" },
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (res.ok) {
-      const data = await res.json();
-      const list = Array.isArray(data.services) ? data.services : [];
-      for (const item of list) {
-        const sId = String(item.serviceId || item.id || "").toLowerCase();
-        if (service2 && !sId.includes(service2.toLowerCase())) continue;
-        const kId = (item.credentials?.keyId || item.credentials?.b2KeyId || "").trim();
-        const key = kId ? `key:${kId}` : `id:${item.id}`;
-        if (!seenKeys.has(key)) {
-          seenKeys.add(key);
-          accounts.push(item);
-        }
-      }
-    }
-  } catch {
-  }
-  return { success: true, deploymentUrl: srklUrl, count: accounts.length, accounts };
-}
-async function srklListBackblazeBuckets(keyId, applicationKey, _bucketId, _bucketName, userId, queryDb) {
-  let resolvedKeyId = (keyId || "").trim();
-  let resolvedAppKey = (applicationKey || "").trim();
-  if ((!resolvedKeyId || !resolvedAppKey) && userId && queryDb) {
-    const accountsRes = await getSrklAccounts(userId, "backblaze", queryDb);
-    const matched = accountsRes.accounts.find((a) => (a.credentials?.keyId || a.credentials?.b2KeyId) === resolvedKeyId) || accountsRes.accounts[0];
-    if (matched) {
-      resolvedKeyId = matched.credentials?.keyId || matched.credentials?.b2KeyId || resolvedKeyId;
-      resolvedAppKey = matched.credentials?.applicationKey || matched.credentials?.b2ApplicationKey || resolvedAppKey;
-    }
-  }
-  if (!resolvedKeyId || !resolvedAppKey) {
-    return { success: false, buckets: [], error: "Backblaze B2 Key ID and Application Key are required" };
-  }
-  try {
-    const buckets = await b2ListBuckets(resolvedKeyId, resolvedAppKey);
-    return { success: true, buckets };
-  } catch (err) {
-    return { success: false, buckets: [], error: err.message };
-  }
-}
-
 // src/srkl/useSrklServices.ts
 import { useState, useEffect, useCallback, useMemo, useRef } from "react";
 function useSrklServices(options) {
@@ -627,9 +516,6 @@ export {
   CANONICAL_SRKL_URL,
   SrklClient,
   createSrklClient,
-  getPrimarySrklDeploymentUrl,
-  getSrklAccounts,
-  srklListBackblazeBuckets,
   useSrklServices,
   hexToBytes,
   decryptVaultBufferInBrowser,