@ultrst-armada/kloks 1.7.1 → 1.9.0

package/packages/services/dist/index.js

@@ -1651,6 +1651,251 @@ var StorageService = class {
 };
 var storageService = new StorageService();
 
+// src/client-services/monacoIdeService.ts
+var activeMonacoService;
+var MonacoIdeServiceDefinition = createServiceDefinition({
+  id: "kloks.service.monacoIde",
+  name: "MonacoIdeService",
+  version: "1.0.0",
+  state: { initial: { sessions: {} } },
+  operations: {
+    createSession: {
+      id: "MonacoIdeService.createSession",
+      name: "createSession",
+      handler: async (input, ctx) => {
+        const sessionId = input.sessionId || `monaco-${Date.now().toString(36)}`;
+        const now = Date.now();
+        const session = {
+          sessionId,
+          document: { uri: input.uri, language: input.language, value: input.value, version: 1, diagnostics: [] },
+          options: input.options || {},
+          createdAt: now,
+          updatedAt: now
+        };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [sessionId]: session } });
+        return session;
+      }
+    },
+    updateDocument: {
+      id: "MonacoIdeService.updateDocument",
+      name: "updateDocument",
+      handler: async (input, ctx) => {
+        const current = activeMonacoService.getState().sessions[input.sessionId];
+        if (!current) throw new Error(`Unknown Monaco session: ${input.sessionId}`);
+        const document = {
+          ...current.document,
+          value: input.value,
+          language: input.language || current.document.language,
+          version: current.document.version + 1
+        };
+        const session = { ...current, document, updatedAt: Date.now() };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [session.sessionId]: session } });
+        return session;
+      }
+    },
+    setDiagnostics: {
+      id: "MonacoIdeService.setDiagnostics",
+      name: "setDiagnostics",
+      handler: async (input, ctx) => {
+        const current = activeMonacoService.getState().sessions[input.sessionId];
+        if (!current) throw new Error(`Unknown Monaco session: ${input.sessionId}`);
+        const session = {
+          ...current,
+          document: { ...current.document, diagnostics: input.diagnostics },
+          updatedAt: Date.now()
+        };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [session.sessionId]: session } });
+        return session;
+      }
+    },
+    setOptions: {
+      id: "MonacoIdeService.setOptions",
+      name: "setOptions",
+      handler: async (input, ctx) => {
+        const current = activeMonacoService.getState().sessions[input.sessionId];
+        if (!current) throw new Error(`Unknown Monaco session: ${input.sessionId}`);
+        const session = { ...current, options: { ...current.options, ...input.options }, updatedAt: Date.now() };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [session.sessionId]: session } });
+        return session;
+      }
+    },
+    getSession: {
+      id: "MonacoIdeService.getSession",
+      name: "getSession",
+      handler: async (input, ctx) => activeMonacoService.getState().sessions[input.sessionId] || null
+    },
+    disposeSession: {
+      id: "MonacoIdeService.disposeSession",
+      name: "disposeSession",
+      handler: async (input, ctx) => {
+        const sessions = { ...activeMonacoService.getState().sessions };
+        delete sessions[input.sessionId];
+        activeMonacoService.setState({ sessions });
+        return { disposed: true, sessionId: input.sessionId };
+      }
+    }
+  }
+});
+function createMonacoIdeService() {
+  activeMonacoService = createService(MonacoIdeServiceDefinition);
+  return activeMonacoService;
+}
+var defaultMonacoIdeService = createMonacoIdeService();
+var MonacoIdeServiceFacade = {
+  id: MonacoIdeServiceDefinition.id,
+  name: MonacoIdeServiceDefinition.name,
+  version: MonacoIdeServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: MonacoIdeServiceDefinition,
+  service: defaultMonacoIdeService,
+  createInstance: createMonacoIdeService,
+  execute: async (operation, input) => {
+    await defaultMonacoIdeService.start();
+    return defaultMonacoIdeService.call(operation, input);
+  }
+};
+
+// src/client-services/uiAuthoringService.ts
+import { buildServiceUISchema, suggestUIComponent } from "@ultrst-armada/kloks/contracts";
+var activeUIAuthoringService;
+var UIAuthoringServiceDefinition = createServiceDefinition({
+  id: "kloks.service.uiAuthoring",
+  name: "UIAuthoringService",
+  version: "1.0.0",
+  state: { initial: { sessions: {} } },
+  operations: {
+    createSession: {
+      id: "UIAuthoringService.createSession",
+      name: "createSession",
+      handler: async (input, ctx) => {
+        const sessionId = input.sessionId || `ui-authoring-${Date.now().toString(36)}`;
+        const session = {
+          sessionId,
+          context: input.context,
+          nodes: [],
+          bindings: [],
+          operations: input.operations || [],
+          metadata: input.metadata || {}
+        };
+        activeUIAuthoringService.setState({ sessions: { ...activeUIAuthoringService.getState().sessions, [sessionId]: session } });
+        return session;
+      }
+    },
+    replaceSession: {
+      id: "UIAuthoringService.replaceSession",
+      name: "replaceSession",
+      handler: async (input, ctx) => {
+        if (input.sessionId !== input.session.sessionId) throw new Error("Session id mismatch.");
+        return updateSession(activeUIAuthoringService, input.sessionId, () => input.session);
+      }
+    },
+    addNode: {
+      id: "UIAuthoringService.addNode",
+      name: "addNode",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        nodes: [...session.nodes.filter((node) => node.id !== input.node.id), input.node]
+      }))
+    },
+    updateNode: {
+      id: "UIAuthoringService.updateNode",
+      name: "updateNode",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        nodes: session.nodes.map((node) => node.id === input.nodeId ? { ...node, ...input.patch } : node)
+      }))
+    },
+    removeNode: {
+      id: "UIAuthoringService.removeNode",
+      name: "removeNode",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        nodes: session.nodes.filter((node) => node.id !== input.nodeId && node.parentId !== input.nodeId)
+      }))
+    },
+    setBinding: {
+      id: "UIAuthoringService.setBinding",
+      name: "setBinding",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        bindings: [...session.bindings.filter((binding) => binding.componentId !== input.binding.componentId || binding.property !== input.binding.property), input.binding]
+      }))
+    },
+    setOperations: {
+      id: "UIAuthoringService.setOperations",
+      name: "setOperations",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({ ...session, operations: input.operations }))
+    },
+    validate: {
+      id: "UIAuthoringService.validate",
+      name: "validate",
+      handler: async (input, ctx) => validateSession(getSession(activeUIAuthoringService, input.sessionId))
+    },
+    serialize: {
+      id: "UIAuthoringService.serialize",
+      name: "serialize",
+      handler: async (input, ctx) => JSON.stringify(getSession(activeUIAuthoringService, input.sessionId), null, 2)
+    },
+    generateServiceUI: {
+      id: "UIAuthoringService.generateServiceUI",
+      name: "generateServiceUI",
+      handler: async (input, ctx) => buildServiceUISchema(getSession(activeUIAuthoringService, input.sessionId))
+    },
+    suggestComponent: {
+      id: "UIAuthoringService.suggestComponent",
+      name: "suggestComponent",
+      handler: async (input) => suggestUIComponent(input.fieldType)
+    },
+    getSession: {
+      id: "UIAuthoringService.getSession",
+      name: "getSession",
+      handler: async (input, ctx) => activeUIAuthoringService.getState().sessions[input.sessionId] || null
+    }
+  }
+});
+function getSession(service, sessionId) {
+  const session = service.getState().sessions[sessionId];
+  if (!session) throw new Error(`Unknown UI authoring session: ${sessionId}`);
+  return session;
+}
+function updateSession(service, sessionId, update) {
+  const session = update(getSession(service, sessionId));
+  service.setState({ sessions: { ...service.getState().sessions, [sessionId]: session } });
+  return session;
+}
+function validateSession(session) {
+  const errors = [];
+  const warnings = [];
+  if (!session.nodes.some((node) => node.kind === "page")) errors.push("At least one page is required.");
+  if (session.nodes.some((node) => node.kind === "component" && !node.assetRef)) errors.push("Every component node requires a FLOKS asset reference.");
+  if (session.context === "service" && !session.metadata.serviceId) errors.push("Service authoring requires metadata.serviceId.");
+  for (const binding of session.bindings) {
+    if (!session.nodes.some((node) => node.id === binding.componentId)) errors.push(`Binding references missing component: ${binding.componentId}`);
+  }
+  if (!session.operations.length) warnings.push("No service operations have been attached to this authoring session.");
+  return { valid: errors.length === 0, errors, warnings };
+}
+function createUIAuthoringService() {
+  activeUIAuthoringService = createService(UIAuthoringServiceDefinition);
+  return activeUIAuthoringService;
+}
+var defaultUIAuthoringService = createUIAuthoringService();
+var UIAuthoringServiceFacade = {
+  id: UIAuthoringServiceDefinition.id,
+  name: UIAuthoringServiceDefinition.name,
+  version: UIAuthoringServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: UIAuthoringServiceDefinition,
+  service: defaultUIAuthoringService,
+  createInstance: createUIAuthoringService,
+  execute: async (operation, input) => {
+    await defaultUIAuthoringService.start();
+    return defaultUIAuthoringService.call(operation, input);
+  }
+};
+
 // src/client-services/index.ts
 var AuthClientServiceDefinition = createServiceDefinition({
   id: "kloks.service.auth",
@@ -1973,6 +2218,8 @@ export {
   AuthServiceUISchema,
   CLEAN_DATABASE_CLUSTER,
   DEFAULT_CONNECTIONS,
+  MonacoIdeServiceDefinition,
+  MonacoIdeServiceFacade,
   STORAGE_KEY_CONNECTIONS,
   ServiceADefinition,
   ServiceAFacade,
@@ -1990,10 +2237,14 @@ export {
   SystemDbClientServiceFacade,
   SystemDbService,
   SystemDbServiceUISchema,
+  UIAuthoringServiceDefinition,
+  UIAuthoringServiceFacade,
   authService,
   clearSession,
+  createMonacoIdeService,
   createServiceB,
   createServiceC,
+  createUIAuthoringService,
   createWorkspace,
   deleteWorkspace,
   exposeServiceD,

package/packages/state-graph/dist/index.js

@@ -7,6 +7,21 @@ import {
   instantiateSubgraph
 } from "./chunk-S22PMERU.js";
 import "./chunk-RHRXPY2U.js";
+import {
+  AttractionEngine,
+  GhostInferenceEngine,
+  GhostLayoutResolver,
+  GhostTracePathBuilder,
+  calculateSocketCoordinates,
+  getBeamPoints,
+  useMagneticTraces
+} from "./chunk-JXDJZSFW.js";
+import {
+  ConnectionRuleStore,
+  HandleTypeRegistry,
+  WireTypeRegistry,
+  initializeDefaultGraphRules
+} from "./chunk-TZOL3RN7.js";
 import {
   LifecycleCycleError,
   LifecycleGraph,
@@ -30,21 +45,6 @@ import {
   CustomViewWindow,
   DEFAULT_GRAPH_SETTINGS
 } from "./chunk-KG6QYS26.js";
-import {
-  AttractionEngine,
-  GhostInferenceEngine,
-  GhostLayoutResolver,
-  GhostTracePathBuilder,
-  calculateSocketCoordinates,
-  getBeamPoints,
-  useMagneticTraces
-} from "./chunk-JXDJZSFW.js";
-import {
-  ConnectionRuleStore,
-  HandleTypeRegistry,
-  WireTypeRegistry,
-  initializeDefaultGraphRules
-} from "./chunk-TZOL3RN7.js";
 import {
   AutoSolidify,
   SpatialEngine,

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

@@ -1,140 +0,0 @@
-// src/auth/SessionManager.ts
-var SessionManager = class {
-  ttl;
-  constructor(ttlMs = 864e5) {
-    this.ttl = ttlMs;
-  }
-  generateToken(userId) {
-    return `sess::${userId}::${Date.now()}::${Math.random().toString(36).substring(2, 9)}`;
-  }
-  createSession(userId, role) {
-    return {
-      token: this.generateToken(userId),
-      userId,
-      role,
-      expiresAt: Date.now() + this.ttl
-    };
-  }
-  isValid(session) {
-    return Date.now() < session.expiresAt;
-  }
-};
-
-// src/auth/RateLimiter.ts
-var RateLimiter = class {
-  attempts = /* @__PURE__ */ new Map();
-  windowMs;
-  maxUser;
-  maxAdmin;
-  constructor(windowMs = 9e5, maxUser = 5, maxAdmin = 3) {
-    this.windowMs = windowMs;
-    this.maxUser = maxUser;
-    this.maxAdmin = maxAdmin;
-  }
-  check(identifier, isAdminAttempt = false) {
-    const now = Date.now();
-    let record = this.attempts.get(identifier);
-    if (!record || now - record.windowStart > this.windowMs) {
-      record = { count: 0, windowStart: now };
-      this.attempts.set(identifier, record);
-    }
-    record.count++;
-    const limit = isAdminAttempt ? this.maxAdmin : this.maxUser;
-    if (record.count > limit) {
-      throw new Error("Too many requests. Please try again later.");
-    }
-  }
-  reset(identifier) {
-    this.attempts.delete(identifier);
-  }
-};
-
-// src/auth/UnifiedAuthCore.ts
-import bcrypt 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 && bcrypt.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 = bcrypt.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 {
-  SessionManager,
-  RateLimiter,
-  loginSystemUser,
-  resolveUserFromToken
-};