@workglow/util 0.0.103 → 0.0.104

package/dist/node.js

@@ -1,3 +1,86 @@
+// src/utilities/Misc.ts
+function forceArray(input) {
+  if (Array.isArray(input))
+    return input;
+  return [input];
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function collectPropertyValues(input) {
+  const output = {};
+  (input || []).forEach((item) => {
+    Object.keys(item).forEach((key) => {
+      const value = item[key];
+      if (output[key]) {
+        output[key].push(value);
+      } else {
+        output[key] = [value];
+      }
+    });
+  });
+  return output;
+}
+function toSQLiteTimestamp(date) {
+  if (!date)
+    return null;
+  const pad = (number) => number < 10 ? "0" + number : number;
+  const year = date.getUTCFullYear();
+  const month = pad(date.getUTCMonth() + 1);
+  const day = pad(date.getUTCDate());
+  const hours = pad(date.getUTCHours());
+  const minutes = pad(date.getUTCMinutes());
+  const seconds = pad(date.getUTCSeconds());
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!keysB.includes(key)) {
+      return false;
+    }
+    if (!deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortObject(obj) {
+  return Object.keys(obj).sort().reduce((result, key) => {
+    result[key] = obj[key];
+    return result;
+  }, {});
+}
+function serialize(obj) {
+  const sortedObj = sortObject(obj);
+  return JSON.stringify(sortedObj);
+}
+
+// src/crypto/Crypto.ts
+async function sha256(data) {
+  const encoder = new TextEncoder;
+  const hashBuffer = await crypto.subtle.digest("SHA-256", encoder.encode(data));
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function makeFingerprint(input) {
+  const serializedObj = serialize(input);
+  const hash = await sha256(serializedObj);
+  return hash;
+}
+function uuid4() {
+  return crypto.randomUUID();
+}
 // src/di/Container.ts
 class Container {
   services = new Map;
@@ -1251,73 +1334,6 @@ function closeStack(text, stack) {
   }
   return result;
 }
-// src/utilities/Misc.ts
-function forceArray(input) {
-  if (Array.isArray(input))
-    return input;
-  return [input];
-}
-async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function collectPropertyValues(input) {
-  const output = {};
-  (input || []).forEach((item) => {
-    Object.keys(item).forEach((key) => {
-      const value = item[key];
-      if (output[key]) {
-        output[key].push(value);
-      } else {
-        output[key] = [value];
-      }
-    });
-  });
-  return output;
-}
-function toSQLiteTimestamp(date) {
-  if (!date)
-    return null;
-  const pad = (number) => number < 10 ? "0" + number : number;
-  const year = date.getUTCFullYear();
-  const month = pad(date.getUTCMonth() + 1);
-  const day = pad(date.getUTCDate());
-  const hours = pad(date.getUTCHours());
-  const minutes = pad(date.getUTCMinutes());
-  const seconds = pad(date.getUTCSeconds());
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-}
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
-    return false;
-  }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-  for (const key of keysA) {
-    if (!keysB.includes(key)) {
-      return false;
-    }
-    if (!deepEqual(a[key], b[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-function sortObject(obj) {
-  return Object.keys(obj).sort().reduce((result, key) => {
-    result[key] = obj[key];
-    return result;
-  }, {});
-}
-function serialize(obj) {
-  const sortedObj = sortObject(obj);
-  return JSON.stringify(sortedObj);
-}
 // src/utilities/objectOfArraysAsArrayOfObjects.ts
 function objectOfArraysAsArrayOfObjects(data) {
   const keys = Object.keys(data);
@@ -2239,6 +2255,248 @@ class WorkerServer {
 }
 var WORKER_SERVER = createServiceToken("worker.server");
 globalServiceRegistry.register(WORKER_SERVER, () => new WorkerServer, true);
+// src/credentials/ICredentialStore.ts
+var CREDENTIAL_STORE = createServiceToken("credential.store");
+// src/credentials/InMemoryCredentialStore.ts
+class InMemoryCredentialStore {
+  store = new Map;
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return;
+    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
+      this.store.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  async put(key, value, options) {
+    const now = new Date;
+    const existing = this.store.get(key);
+    const metadata = {
+      label: options?.label ?? existing?.metadata.label,
+      provider: options?.provider ?? existing?.metadata.provider,
+      createdAt: existing?.metadata.createdAt ?? now,
+      updatedAt: now,
+      expiresAt: options?.expiresAt ?? existing?.metadata.expiresAt
+    };
+    this.store.set(key, { key, value, metadata });
+  }
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  async has(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return false;
+    if (entry.metadata.expiresAt && entry.metadata.expiresAt <= new Date) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async keys() {
+    const now = new Date;
+    const result = [];
+    for (const [key, entry] of this.store) {
+      if (entry.metadata.expiresAt && entry.metadata.expiresAt <= now) {
+        this.store.delete(key);
+        continue;
+      }
+      result.push(key);
+    }
+    return result;
+  }
+  async deleteAll() {
+    this.store.clear();
+  }
+}
+// src/credentials/EnvCredentialStore.ts
+class EnvCredentialStore {
+  keyToEnvVar;
+  prefix;
+  constructor(mapping = {}, prefix) {
+    this.keyToEnvVar = new Map(Object.entries(mapping));
+    this.prefix = prefix;
+  }
+  resolveEnvVar(key) {
+    const explicit = this.keyToEnvVar.get(key);
+    if (explicit)
+      return explicit;
+    if (this.prefix) {
+      return `${this.prefix}_${key.toUpperCase().replace(/-/g, "_")}`;
+    }
+    return key.toUpperCase().replace(/-/g, "_");
+  }
+  getEnv(envVar) {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[envVar];
+    }
+    return;
+  }
+  async get(key) {
+    const envVar = this.resolveEnvVar(key);
+    return this.getEnv(envVar);
+  }
+  async put(key, value, _options) {
+    const envVar = this.resolveEnvVar(key);
+    if (typeof process !== "undefined" && process.env) {
+      process.env[envVar] = value;
+    }
+    if (!this.keyToEnvVar.has(key)) {
+      this.keyToEnvVar.set(key, envVar);
+    }
+  }
+  async delete(key) {
+    const envVar = this.resolveEnvVar(key);
+    if (typeof process !== "undefined" && process.env && envVar in process.env) {
+      delete process.env[envVar];
+      return true;
+    }
+    return false;
+  }
+  async has(key) {
+    const envVar = this.resolveEnvVar(key);
+    return this.getEnv(envVar) !== undefined;
+  }
+  async keys() {
+    const result = [];
+    for (const [credKey] of this.keyToEnvVar) {
+      if (await this.has(credKey)) {
+        result.push(credKey);
+      }
+    }
+    return result;
+  }
+  async deleteAll() {
+    for (const [credKey] of this.keyToEnvVar) {
+      await this.delete(credKey);
+    }
+  }
+}
+// src/credentials/ChainedCredentialStore.ts
+class ChainedCredentialStore {
+  stores;
+  constructor(stores) {
+    this.stores = stores;
+    if (stores.length === 0) {
+      throw new Error("ChainedCredentialStore requires at least one store.");
+    }
+  }
+  async get(key) {
+    for (const store of this.stores) {
+      const value = await store.get(key);
+      if (value !== undefined)
+        return value;
+    }
+    return;
+  }
+  async put(key, value, options) {
+    await this.stores[0].put(key, value, options);
+  }
+  async delete(key) {
+    let deleted = false;
+    for (const store of this.stores) {
+      if (await store.delete(key)) {
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+  async has(key) {
+    for (const store of this.stores) {
+      if (await store.has(key))
+        return true;
+    }
+    return false;
+  }
+  async keys() {
+    const seen = new Set;
+    for (const store of this.stores) {
+      for (const key of await store.keys()) {
+        seen.add(key);
+      }
+    }
+    return [...seen];
+  }
+  async deleteAll() {
+    await Promise.all(this.stores.map((s) => s.deleteAll()));
+  }
+}
+// src/credentials/CredentialStoreRegistry.ts
+if (!globalServiceRegistry.has(CREDENTIAL_STORE)) {
+  globalServiceRegistry.register(CREDENTIAL_STORE, () => new InMemoryCredentialStore, true);
+}
+function getGlobalCredentialStore() {
+  return globalServiceRegistry.get(CREDENTIAL_STORE);
+}
+function setGlobalCredentialStore(store) {
+  globalServiceRegistry.registerInstance(CREDENTIAL_STORE, store);
+}
+async function resolveCredential(key, registry) {
+  const store = registry && registry.has(CREDENTIAL_STORE) ? registry.get(CREDENTIAL_STORE) : getGlobalCredentialStore();
+  return store.get(key);
+}
+registerInputResolver("credential", async (id, _format, registry) => {
+  return await resolveCredential(id, registry) ?? id;
+});
+// src/crypto/WebCrypto.ts
+var SALT_LENGTH = 16;
+async function deriveKey(passphrase, salt) {
+  const enc = new TextEncoder;
+  const keyMaterial = await crypto.subtle.importKey("raw", enc.encode(passphrase), "PBKDF2", false, [
+    "deriveKey"
+  ]);
+  return crypto.subtle.deriveKey({ name: "PBKDF2", salt, iterations: 1e5, hash: "SHA-256" }, keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+async function encrypt(plaintext, passphrase, keyCache) {
+  const enc = new TextEncoder;
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+  const saltB64 = bufToBase64(salt);
+  let key = keyCache.get(saltB64);
+  if (!key) {
+    key = await deriveKey(passphrase, salt);
+    keyCache.set(saltB64, key);
+  }
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const rawCiphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, enc.encode(plaintext));
+  const ciphertextBytes = new Uint8Array(rawCiphertext);
+  const combined = new Uint8Array(SALT_LENGTH + ciphertextBytes.length);
+  combined.set(salt, 0);
+  combined.set(ciphertextBytes, SALT_LENGTH);
+  return {
+    encrypted: bufToBase64(combined),
+    iv: bufToBase64(iv)
+  };
+}
+async function decrypt(encrypted, iv, passphrase, keyCache) {
+  const encryptedBuf = base64ToBuf(encrypted);
+  const salt = encryptedBuf.subarray(0, SALT_LENGTH);
+  const ciphertextBytes = encryptedBuf.subarray(SALT_LENGTH);
+  const saltB64 = bufToBase64(salt);
+  let key = keyCache.get(saltB64);
+  if (!key) {
+    key = await deriveKey(passphrase, salt);
+    keyCache.set(saltB64, key);
+  }
+  const plainBuf = await crypto.subtle.decrypt({ name: "AES-GCM", iv: base64ToBuf(iv) }, key, ciphertextBytes);
+  return new TextDecoder().decode(plainBuf);
+}
+function bufToBase64(buf) {
+  let binary = "";
+  for (let i = 0;i < buf.length; i++) {
+    binary += String.fromCharCode(buf[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBuf(b64) {
+  const binary = atob(b64);
+  const buf = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    buf[i] = binary.charCodeAt(i);
+  }
+  return buf;
+}
 // src/compress/compress.node.ts
 import { promisify } from "util";
 import zlib from "zlib";
@@ -2258,19 +2516,6 @@ async function decompress(input, algorithm = "gzip") {
   const resultBuffer = await decompressAsyncTyped(sourceBuffer);
   return resultBuffer.toString();
 }
-// src/crypto/Crypto.node.ts
-import { createHash } from "node:crypto";
-async function sha256(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-async function makeFingerprint(input) {
-  const serializedObj = serialize(input);
-  const hash = await sha256(serializedObj);
-  return hash;
-}
-function uuid4() {
-  return crypto.randomUUID();
-}
 // src/mcp/McpClientUtil.node.ts
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -2417,7 +2662,9 @@ export {
   sleep,
   sha256,
   setLogger,
+  setGlobalCredentialStore,
   serialize,
+  resolveCredential,
   registerInputResolver,
   parsePartialJson,
   parseDataUri,
@@ -2439,8 +2686,12 @@ export {
   globalContainer,
   getLogger,
   getInputResolvers,
+  getGlobalCredentialStore,
   forceArray,
+  encrypt,
+  deriveKey,
   deepEqual,
+  decrypt,
   decompress,
   createTypedArrayFrom,
   createServiceToken,
@@ -2450,6 +2701,8 @@ export {
   compress,
   compileSchema,
   collectPropertyValues,
+  bufToBase64,
+  base64ToBuf,
   areSemanticallyCompatible,
   areObjectSchemasSemanticallyCompatible,
   WorkerServer,
@@ -2465,16 +2718,20 @@ export {
   NodeDoesntExistError,
   NodeAlreadyExistsError,
   LOGGER,
+  InMemoryCredentialStore,
   INPUT_RESOLVERS,
   Graph,
   FromSchemaDefaultOptions,
   EventEmitter,
+  EnvCredentialStore,
   DirectedGraph,
   DirectedAcyclicGraph,
   CycleError,
   Container,
   ConsoleLogger,
+  ChainedCredentialStore,
+  CREDENTIAL_STORE,
   BaseError
 };
 
-//# debugId=B4EF66B1A6B9B24664756E2164756E21
+//# debugId=AA942AD3DE6A9D8664756E2164756E21