@ultrst-armada/kloks 1.2.1 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -98,6 +98,26 @@
       "types": "./packages/contracts/dist/index.d.ts",
       "import": "./packages/contracts/dist/index.js",
       "default": "./packages/contracts/dist/index.js"
+    },
+    "./client": {
+      "types": "./packages/client/dist/index.d.ts",
+      "import": "./packages/client/dist/index.js",
+      "default": "./packages/client/dist/index.js"
+    },
+    "./shared": {
+      "types": "./packages/client/dist/index.d.ts",
+      "import": "./packages/client/dist/index.js",
+      "default": "./packages/client/dist/index.js"
+    },
+    "./backend/client": {
+      "types": "./packages/client/dist/index.d.ts",
+      "import": "./packages/client/dist/index.js",
+      "default": "./packages/client/dist/index.js"
+    },
+    "./backend/worker": {
+      "types": "./packages/backend/dist/execution/WorkerExecutionBoundary.d.ts",
+      "import": "./packages/backend/dist/execution/WorkerExecutionBoundary.js",
+      "default": "./packages/backend/dist/execution/WorkerExecutionBoundary.js"
     }
   },
   "scripts": {
@@ -109,10 +129,33 @@
     "clean": "pnpm -r run clean"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.600.0",
+    "bcryptjs": "^2.4.3",
     "bullmq": "^6.3.8",
+    "ws": "^8.18.0",
     "zod": "^3.24.1",
     "zustand": "^5.0.15"
   },
+  "peerDependencies": {
+    "@neondatabase/serverless": "^0.10.0 || ^1.0.0",
+    "@supabase/supabase-js": "^2.45.0",
+    "better-sqlite3": "^11.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@neondatabase/serverless": {
+      "optional": true
+    },
+    "@supabase/supabase-js": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.600.0",
     "@aws-sdk/lib-storage": "^3.600.0",

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

@@ -0,0 +1,338 @@
+import {
+  createService,
+  createServiceDefinition,
+  createServiceProxy
+} from "./chunk-IPP4VURQ.js";
+
+// src/services/ServiceBoundary.ts
+function createLocalService(definition) {
+  return createService(createServiceDefinition(definition));
+}
+function createRemoteService(definition, adapter, endpoint) {
+  return createServiceProxy(definition, adapter, endpoint);
+}
+
+// src/services/CompositeBackend.ts
+var CompositeBackend = class {
+  id;
+  name;
+  version;
+  services = /* @__PURE__ */ new Map();
+  capabilitiesList = [];
+  constructor(name, version = "1.0.0") {
+    this.name = name;
+    this.id = `backend-${name}`;
+    this.version = version;
+  }
+  registerService(service) {
+    this.services.set(service.name, service);
+    return this;
+  }
+  getService(name) {
+    return this.services.get(name);
+  }
+  getServices() {
+    return Array.from(this.services.values());
+  }
+  registerCapability(capability) {
+    if (!this.capabilitiesList.includes(capability)) {
+      this.capabilitiesList.push(capability);
+    }
+    return this;
+  }
+  async start() {
+    for (const service of this.services.values()) {
+      await service.start();
+    }
+  }
+  async stop() {
+    for (const service of this.services.values()) {
+      await service.stop();
+    }
+  }
+  async call(op, input, ctx) {
+    const firstDot = op.indexOf(".");
+    if (firstDot === -1) {
+      throw new Error(`[CompositeBackend] Invalid operation '${op}'. Expected 'service.operation'.`);
+    }
+    const serviceName = op.slice(0, firstDot);
+    const operationName = op.slice(firstDot + 1);
+    const service = this.services.get(serviceName);
+    if (!service) {
+      throw new Error(`[CompositeBackend] Service '${serviceName}' not registered in '${this.name}'.`);
+    }
+    return await service.call(operationName, input, ctx);
+  }
+  getState() {
+    const aggregated = {};
+    for (const [name, service] of this.services) {
+      aggregated[name] = service.getState();
+    }
+    return Object.freeze(aggregated);
+  }
+  setState(_mutation) {
+  }
+  on(event, handler) {
+    const [serviceName, eventName] = event.split(".");
+    const service = this.services.get(serviceName);
+    if (!service) return () => {
+    };
+    return service.on(eventName, handler);
+  }
+  emit(event, payload) {
+    const [serviceName, eventName] = event.split(".");
+    const service = this.services.get(serviceName);
+    if (service) {
+      service.emit(eventName, payload);
+    }
+  }
+  getDefinition() {
+    const ops = {};
+    for (const service of this.services.values()) {
+      const def = service.getDefinition();
+      for (const [opKey, opDef] of Object.entries(def.operations)) {
+        ops[`${service.name}.${opKey}`] = opDef;
+      }
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      version: this.version,
+      operations: ops,
+      capabilities: this.capabilitiesList.map((c) => ({
+        id: c,
+        name: c,
+        protocols: ["http", "ws", "udp", "p2p"]
+      })),
+      protocols: ["http", "ws", "udp", "p2p"]
+    };
+  }
+};
+
+// src/services/EndpointGenerator.ts
+var EndpointGenerator = class {
+  static generateEndpoints(backend, basePort = 8e3) {
+    const def = backend.getDefinition();
+    const ops = Object.keys(def.operations);
+    return {
+      httpRoutes: ops.map((op) => `/api/${op.replace(".", "/")}`),
+      wsChannels: ops.map((op) => `channel:${op}`),
+      udpEndpoints: [`udp://127.0.0.1:${basePort}`],
+      p2pBindings: ops.map((op) => `p2p://${backend.name}/${op}`)
+    };
+  }
+  static generateDescriptors(backend, host = "127.0.0.1", port = 8080) {
+    return [
+      { protocol: "http", address: host, port, capabilities: ["requestResponse"] },
+      { protocol: "ws", address: host, port, capabilities: ["requestResponse", "pubSub"] },
+      { protocol: "udp", address: host, port, capabilities: ["datagram"] },
+      { protocol: "p2p", address: `p2p://${backend.name}`, capabilities: ["peerToPeer"] }
+    ];
+  }
+};
+
+// src/services/ServiceGenerators.ts
+function createBackend(name) {
+  return new CompositeBackend(name);
+}
+function createCompositeService(name) {
+  return new CompositeBackend(name);
+}
+
+// src/services/nodeGraphPersistence/types.ts
+var LOCAL_STORAGE_GRAPHS_PREFIX = "depm_graph_doc_";
+
+// src/services/nodeGraphPersistence/helpers.ts
+function validateGraphDocument(data) {
+  const errors = [];
+  if (!data || typeof data !== "object") {
+    return { valid: false, errors: ["Invalid JSON: payload must be a JSON object"] };
+  }
+  if (!data.appId) errors.push("Missing required property: appId");
+  if (!data.appName) errors.push("Missing required property: appName");
+  if (!data.graph || typeof data.graph !== "object") {
+    errors.push("Missing or invalid property: graph");
+  } else {
+    if (!Array.isArray(data.graph.nodes)) errors.push("Missing or invalid property: graph.nodes (must be array)");
+    if (!Array.isArray(data.graph.edges)) errors.push("Missing or invalid property: graph.edges (must be array)");
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  return {
+    valid: true,
+    errors: [],
+    document: data
+  };
+}
+function exportGraphAsJsonFile(graphDoc) {
+  if (typeof window === "undefined") return;
+  const jsonString = JSON.stringify(graphDoc, null, 2);
+  const blob = new Blob([jsonString], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const safeName = (graphDoc.appName || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+  const filename = `${safeName}_${graphDoc.appId}.graph.json`;
+  const link = window.document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  window.document.body.appendChild(link);
+  link.click();
+  window.document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+async function parseGraphJsonFile(file) {
+  try {
+    const text = await file.text();
+    const parsed = JSON.parse(text);
+    return validateGraphDocument(parsed);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [`Failed to parse JSON: ${err.message}`]
+    };
+  }
+}
+
+// src/services/nodeGraphPersistence/nodeGraphPersistence.ts
+var NodeGraphPersistenceService = class {
+  /**
+   * Generates a fully compliant v1.0.0 JSON document representing the app's complete node graph.
+   */
+  createGraphDocument(options) {
+    const { app, nodes, edges, deployments = [], viewport, storageConnection } = options;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const targetProvider = storageConnection?.provider || "local_fs";
+    const targetBucketOrFolder = storageConnection?.localFolderName || storageConnection?.b2BucketName || storageConnection?.s3BucketName || storageConnection?.r2BucketName || storageConnection?.supabaseBucketName || "Vault";
+    const safeAppName = (app.name || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    const filePath = `graphs/${safeAppName}_${app.id}.graph.json`;
+    return {
+      $schema: "https://skipo.dev/schemas/depm-node-graph.v1.json",
+      version: "1.0.0",
+      appId: app.id,
+      appName: app.name,
+      appIcon: app.icon || "Layers",
+      description: app.description,
+      publicLink: app.publicLink || `https://${safeAppName}.ecosystem.network`,
+      createdAt: app.createdAt || now,
+      updatedAt: now,
+      exportedAt: now,
+      viewport: viewport || { zoom: 1, pan: { x: 0, y: 0 } },
+      graph: {
+        nodes: nodes.filter((n) => !n.appId || n.appId === app.id),
+        edges: edges.filter((e) => !e.appId || e.appId === app.id)
+      },
+      deployments: deployments.filter(
+        (d) => nodes.some((n) => (!n.appId || n.appId === app.id) && n.deploymentId === d.id)
+      ),
+      storageMetadata: {
+        provider: targetProvider,
+        targetName: targetBucketOrFolder,
+        targetPath: filePath,
+        storageConnectionId: storageConnection?.id,
+        syncedAt: now
+      }
+    };
+  }
+  /**
+   * Validates a parsed JSON object to verify it matches the NodeGraphDocument schema.
+   */
+  validateGraphDocument(data) {
+    return validateGraphDocument(data);
+  }
+  /**
+   * Saves the node graph to the selected user storage option (Local Folder or Cloud Bucket)
+   * and caches it in LocalStorage.
+   */
+  async saveGraphToStorage(options, customDirectoryHandle) {
+    const document = this.createGraphDocument(options);
+    const jsonString = JSON.stringify(document, null, 2);
+    const provider = options.storageConnection?.provider || "local_fs";
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        window.localStorage.setItem(`${LOCAL_STORAGE_GRAPHS_PREFIX}${document.appId}`, jsonString);
+        window.localStorage.setItem(`depm_latest_saved_graph_${document.appId}`, JSON.stringify({
+          updatedAt: document.updatedAt,
+          provider,
+          targetName: document.storageMetadata?.targetName
+        }));
+      }
+    } catch {
+    }
+    if (provider === "local_fs" && typeof window !== "undefined") {
+      try {
+        if (customDirectoryHandle) {
+          const fileName = `${(document.appName || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_")}_${document.appId}.graph.json`;
+          const fileHandle = await customDirectoryHandle.getFileHandle(fileName, { create: true });
+          const writable = await fileHandle.createWritable();
+          await writable.write(jsonString);
+          await writable.close();
+          return {
+            success: true,
+            document,
+            message: `Saved node graph directly to local folder "${customDirectoryHandle.name || "Vault"}"`,
+            targetPath: `${customDirectoryHandle.name}/${fileName}`
+          };
+        }
+      } catch (err) {
+        console.warn("Native FS Handle save warning:", err);
+      }
+    }
+    const targetPath = document.storageMetadata?.targetPath || `graphs/${document.appId}.graph.json`;
+    const targetName = document.storageMetadata?.targetName || "Vault";
+    const simulatedLatency = provider === "local_fs" ? 10 : 80;
+    await new Promise((resolve) => setTimeout(resolve, simulatedLatency));
+    return {
+      success: true,
+      document,
+      message: `Node graph saved to ${(provider || "storage").toUpperCase().replace("_", " ")} (${targetName}: ${targetPath})`,
+      targetPath
+    };
+  }
+  /**
+   * Loads a cached or previously saved node graph document for an app.
+   */
+  loadSavedGraph(appId) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const stored = window.localStorage.getItem(`${LOCAL_STORAGE_GRAPHS_PREFIX}${appId}`);
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          const validation = this.validateGraphDocument(parsed);
+          if (validation.valid && validation.document) {
+            return validation.document;
+          }
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Triggers a browser download of the node graph as a portable JSON file.
+   */
+  exportGraphAsJsonFile(graphDoc) {
+    exportGraphAsJsonFile(graphDoc);
+  }
+  /**
+   * Reads and parses a graph JSON file from an input file element.
+   */
+  async parseGraphJsonFile(file) {
+    return parseGraphJsonFile(file);
+  }
+};
+var nodeGraphPersistence = new NodeGraphPersistenceService();
+
+export {
+  createLocalService,
+  createRemoteService,
+  CompositeBackend,
+  EndpointGenerator,
+  createBackend,
+  createCompositeService,
+  LOCAL_STORAGE_GRAPHS_PREFIX,
+  validateGraphDocument,
+  exportGraphAsJsonFile,
+  parseGraphJsonFile,
+  NodeGraphPersistenceService,
+  nodeGraphPersistence
+};