@workglow/util 0.1.1 → 0.2.0

package/dist/node.js

@@ -86,12 +86,19 @@ class Container {
   services = new Map;
   factories = new Map;
   singletons = new Set;
+  resolving = [];
   register(token, factory, singleton = true) {
     this.factories.set(token, factory);
     if (singleton) {
       this.singletons.add(token);
     }
   }
+  registerIfAbsent(token, factory, singleton = true) {
+    if (this.factories.has(token) || this.services.has(token)) {
+      return;
+    }
+    this.register(token, factory, singleton);
+  }
   registerInstance(token, instance) {
     this.services.set(token, instance);
     this.singletons.add(token);
@@ -104,11 +111,20 @@ class Container {
     if (!factory) {
       throw new Error(`Service not registered: ${String(token)}`);
     }
-    const instance = factory();
-    if (this.singletons.has(token)) {
-      this.services.set(token, instance);
+    if (this.resolving.includes(token)) {
+      const cycle = [...this.resolving.slice(this.resolving.indexOf(token)), token];
+      throw new Error(`Circular dependency detected: ${cycle.join(" -> ")}`);
+    }
+    this.resolving.push(token);
+    try {
+      const instance = factory();
+      if (this.singletons.has(token)) {
+        this.services.set(token, instance);
+      }
+      return instance;
+    } finally {
+      this.resolving.pop();
     }
-    return instance;
   }
   has(token) {
     return this.services.has(token) || this.factories.has(token);
@@ -118,6 +134,36 @@ class Container {
     this.factories.delete(token);
     this.singletons.delete(token);
   }
+  async dispose() {
+    const errors = [];
+    try {
+      for (const service of this.services.values()) {
+        if (service == null)
+          continue;
+        try {
+          if (typeof service[Symbol.asyncDispose] === "function") {
+            await service[Symbol.asyncDispose]();
+          } else if (typeof service[Symbol.dispose] === "function") {
+            service[Symbol.dispose]();
+          } else if (typeof service.dispose === "function") {
+            await service.dispose();
+          }
+        } catch (err) {
+          errors.push(err);
+        }
+      }
+    } finally {
+      this.services.clear();
+      this.factories.clear();
+      this.singletons.clear();
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "One or more services failed to dispose");
+    }
+  }
+  async[Symbol.asyncDispose]() {
+    await this.dispose();
+  }
   createChildContainer() {
     const child = new Container;
     this.factories.forEach((factory, token) => {
@@ -149,6 +195,9 @@ class ServiceRegistry {
   register(token, factory, singleton = true) {
     this.container.register(token.id, factory, singleton);
   }
+  registerIfAbsent(token, factory, singleton = true) {
+    this.container.registerIfAbsent(token.id, factory, singleton);
+  }
   registerInstance(token, instance) {
     this.container.registerInstance(token.id, instance);
   }
@@ -158,14 +207,25 @@ class ServiceRegistry {
   has(token) {
     return this.container.has(token.id);
   }
+  async dispose() {
+    await this.container.dispose();
+  }
 }
 var globalServiceRegistry = new ServiceRegistry(globalContainer);
 
+// src/di/InputCompactorRegistry.ts
+var INPUT_COMPACTORS = createServiceToken("task.input.compactors");
+globalServiceRegistry.registerIfAbsent(INPUT_COMPACTORS, () => new Map, true);
+function getInputCompactors() {
+  return globalServiceRegistry.get(INPUT_COMPACTORS);
+}
+function registerInputCompactor(formatPrefix, compactor) {
+  const compactors = getInputCompactors();
+  compactors.set(formatPrefix, compactor);
+}
 // src/di/InputResolverRegistry.ts
 var INPUT_RESOLVERS = createServiceToken("task.input.resolvers");
-if (!globalServiceRegistry.has(INPUT_RESOLVERS)) {
-  globalServiceRegistry.register(INPUT_RESOLVERS, () => new Map, true);
-}
+globalServiceRegistry.registerIfAbsent(INPUT_RESOLVERS, () => new Map, true);
 function getInputResolvers() {
   return globalServiceRegistry.get(INPUT_RESOLVERS);
 }
@@ -176,17 +236,36 @@ function registerInputResolver(formatPrefix, resolver) {
 // src/events/EventEmitter.ts
 class EventEmitter {
   listeners = {};
+  maxListeners = 0;
+  warnedEvents = new Set;
+  setMaxListeners(n) {
+    if (!Number.isFinite(n) || n < 0) {
+      throw new RangeError(`"n" must be a non-negative finite number. Got ${n}.`);
+    }
+    this.maxListeners = Math.trunc(n);
+    this.warnedEvents.clear();
+    return this;
+  }
+  listenerCount(event) {
+    return this.listeners[event]?.length ?? 0;
+  }
+  eventNames() {
+    return Object.keys(this.listeners).filter((k) => (this.listeners[k]?.length ?? 0) > 0);
+  }
   removeAllListeners(event) {
     if (event) {
       delete this.listeners[event];
+      this.warnedEvents.delete(event);
     } else {
       this.listeners = {};
+      this.warnedEvents.clear();
     }
     return this;
   }
   on(event, listener) {
     const listeners = this.listeners[event] || (this.listeners[event] = []);
     listeners.push({ listener });
+    this.checkMaxListeners(event, listeners.length);
     return this;
   }
   off(event, listener) {
@@ -196,12 +275,16 @@ class EventEmitter {
     const index = listeners.findIndex((l) => l.listener === listener);
     if (index >= 0) {
       listeners.splice(index, 1);
+      if (this.maxListeners > 0 && listeners.length <= this.maxListeners) {
+        this.warnedEvents.delete(event);
+      }
     }
     return this;
   }
   once(event, listener) {
     const listeners = this.listeners[event] || (this.listeners[event] = []);
     listeners.push({ listener, once: true });
+    this.checkMaxListeners(event, listeners.length);
     return this;
   }
   waitOn(event) {
@@ -225,11 +308,22 @@ class EventEmitter {
         }
       }
       this.listeners[event] = listeners.filter((l) => !l.once);
-      if (errors.length > 0) {
+      if (this.maxListeners > 0 && (this.listeners[event]?.length ?? 0) <= this.maxListeners) {
+        this.warnedEvents.delete(event);
+      }
+      if (errors.length > 1) {
+        throw new AggregateError(errors, `${errors.length} listener(s) threw on "${String(event)}"`);
+      } else if (errors.length === 1) {
         throw errors[0];
       }
     }
   }
+  checkMaxListeners(event, count) {
+    if (this.maxListeners > 0 && count > this.maxListeners && !this.warnedEvents.has(event)) {
+      this.warnedEvents.add(event);
+      console.warn(`MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ` + `${count} listeners added for event "${String(event)}". ` + `Use setMaxListeners() to increase limit (current: ${this.maxListeners}).`);
+    }
+  }
   subscribe(event, listener) {
     this.on(event, listener);
     return () => this.off(event, listener);
@@ -402,9 +496,7 @@ function createDefaultLogger() {
   }
   return new NullLogger;
 }
-if (!globalServiceRegistry.has(LOGGER)) {
-  globalServiceRegistry.register(LOGGER, createDefaultLogger, true);
-}
+globalServiceRegistry.registerIfAbsent(LOGGER, createDefaultLogger, true);
 function getLogger() {
   return globalServiceRegistry.get(LOGGER);
 }
@@ -815,16 +907,19 @@ class WorkerManager {
     let init = this.lazyInitPromises.get(name);
     if (!init) {
       init = (async () => {
-        const f = this.lazyFactories.get(name);
-        this.lazyFactories.delete(name);
-        const worker = f();
-        this.attachWorkerInstance(name, worker);
+        try {
+          const f = this.lazyFactories.get(name);
+          this.lazyFactories.delete(name);
+          const worker = f();
+          this.attachWorkerInstance(name, worker);
+          await this.readyWorkers.get(name);
+        } finally {
+          this.lazyInitPromises.delete(name);
+        }
       })();
       this.lazyInitPromises.set(name, init);
     }
     await init;
-    await this.readyWorkers.get(name);
-    this.lazyInitPromises.delete(name);
   }
   getWorker(name) {
     const worker = this.workers.get(name);
@@ -837,7 +932,6 @@ class WorkerManager {
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
-    await this.readyWorkers.get(workerName);
     const knownFunctions = this.workerFunctions.get(workerName);
     if (knownFunctions && !knownFunctions.has(functionName)) {
       throw new Error(`Function "${functionName}" is not registered on worker "${workerName}".`);
@@ -886,7 +980,6 @@ class WorkerManager {
     const worker = this.workers.get(workerName);
     if (!worker)
       return;
-    await this.readyWorkers.get(workerName);
     const knownReactive = this.workerReactiveFunctions.get(workerName);
     if (knownReactive && !knownReactive.has(functionName))
       return;
@@ -901,6 +994,9 @@ class WorkerManager {
           resolve(data);
         } else if (type === "error") {
           cleanup();
+          getLogger().warn(`Worker ${workerName} reactive function ${functionName} error:`, {
+            error: data
+          });
           resolve(undefined);
         }
       };
@@ -913,12 +1009,35 @@ class WorkerManager {
       getLogger().info(`Worker ${workerName} reactive function ${functionName} called.`);
     });
   }
+  async terminateWorker(name) {
+    const worker = this.workers.get(name);
+    this.workers.delete(name);
+    this.readyWorkers.delete(name);
+    this.workerFunctions.delete(name);
+    this.workerStreamFunctions.delete(name);
+    this.workerReactiveFunctions.delete(name);
+    this.lazyFactories.delete(name);
+    this.lazyInitPromises.delete(name);
+    try {
+      if (worker && "terminate" in worker && typeof worker.terminate === "function") {
+        await worker.terminate();
+      }
+    } catch {}
+  }
+  async dispose() {
+    const names = [...this.workers.keys(), ...this.lazyFactories.keys()];
+    for (const name of names) {
+      await this.terminateWorker(name);
+    }
+  }
+  async[Symbol.asyncDispose]() {
+    await this.dispose();
+  }
   async* callWorkerStreamFunction(workerName, functionName, args, options) {
     await this.ensureWorkerReady(workerName);
     const worker = this.workers.get(workerName);
     if (!worker)
       throw new Error(`Worker ${workerName} not found.`);
-    await this.readyWorkers.get(workerName);
     const knownStream = this.workerStreamFunctions.get(workerName);
     const knownFns = this.workerFunctions.get(workerName);
     if (knownStream && knownFns && !knownStream.has(functionName) && !knownFns.has(functionName)) {
@@ -998,8 +1117,106 @@ class WorkerManager {
 }
 var WORKER_MANAGER = createServiceToken("worker.manager");
 globalServiceRegistry.register(WORKER_MANAGER, () => new WorkerManager, true);
+// 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/CredentialProviderOptions.ts
+var CREDENTIAL_PROVIDER_VALUES = [
+  "none",
+  "anthropic",
+  "openai",
+  "google",
+  "huggingface",
+  "custom"
+];
+var CREDENTIAL_PROVIDER_SCHEMA_ENUM = CREDENTIAL_PROVIDER_VALUES;
+var CREDENTIAL_PROVIDER_NONE = CREDENTIAL_PROVIDER_VALUES[0];
+var CREDENTIAL_PROVIDER_OPTIONS = [
+  { value: CREDENTIAL_PROVIDER_VALUES[0], label: "None" },
+  { value: CREDENTIAL_PROVIDER_VALUES[1], label: "Anthropic" },
+  { value: CREDENTIAL_PROVIDER_VALUES[2], label: "OpenAI" },
+  { value: CREDENTIAL_PROVIDER_VALUES[3], label: "Google" },
+  { value: CREDENTIAL_PROVIDER_VALUES[4], label: "Hugging Face" },
+  { value: CREDENTIAL_PROVIDER_VALUES[5], label: "Custom" }
+];
+// src/credentials/CredentialPutInputSchema.ts
+var CredentialPutInputSchema = {
+  type: "object",
+  properties: {
+    key: {
+      type: "string",
+      title: "Key",
+      description: 'Unique identifier (e.g. "openai-api-key")'
+    },
+    value: {
+      type: "string",
+      title: "Value",
+      description: "Secret value (API key, token, or password)",
+      format: "password"
+    },
+    label: {
+      type: "string",
+      title: "Label",
+      description: "Human-readable label (optional)"
+    },
+    provider: {
+      type: "string",
+      title: "Provider",
+      description: "Optional provider this credential is associated with",
+      enum: [...CREDENTIAL_PROVIDER_SCHEMA_ENUM]
+    }
+  },
+  required: ["key", "value"]
+};
 // src/credentials/ICredentialStore.ts
 var CREDENTIAL_STORE = createServiceToken("credential.store");
+
 // src/credentials/InMemoryCredentialStore.ts
 class InMemoryCredentialStore {
   store = new Map;
@@ -1054,6 +1271,25 @@ class InMemoryCredentialStore {
     this.store.clear();
   }
 }
+
+// src/credentials/CredentialStoreRegistry.ts
+globalServiceRegistry.registerIfAbsent(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;
+});
+registerInputCompactor("credential", (value) => {
+  return typeof value === "string" ? value : undefined;
+});
 // src/credentials/EnvCredentialStore.ts
 class EnvCredentialStore {
   keyToEnvVar;
@@ -1117,72 +1353,94 @@ class EnvCredentialStore {
     }
   }
 }
-// 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.");
+// src/credentials/OtpPassphraseCache.ts
+var DEFAULT_HARD_TTL_MS = 6 * 60 * 60 * 1000;
+
+class OtpPassphraseCache {
+  masked;
+  pad;
+  hardTimer;
+  idleTimer;
+  options;
+  constructor(options) {
+    this.options = options ?? {};
+  }
+  store(passphrase) {
+    this.clearInternal(false);
+    const encoder = new TextEncoder;
+    const raw = encoder.encode(passphrase);
+    const pad = crypto.getRandomValues(new Uint8Array(raw.length));
+    const masked = new Uint8Array(raw.length);
+    for (let i = 0;i < raw.length; i++) {
+      masked[i] = raw[i] ^ pad[i];
+    }
+    raw.fill(0);
+    this.masked = masked;
+    this.pad = pad;
+    this.startTimers();
+  }
+  retrieve() {
+    if (!this.masked || !this.pad)
+      return;
+    const raw = new Uint8Array(this.masked.length);
+    for (let i = 0;i < this.masked.length; i++) {
+      raw[i] = this.masked[i] ^ this.pad[i];
     }
+    const result = new TextDecoder().decode(raw);
+    raw.fill(0);
+    this.resetIdleTimer();
+    return result;
   }
-  async get(key) {
-    for (const store of this.stores) {
-      const value = await store.get(key);
-      if (value !== undefined)
-        return value;
-    }
-    return;
+  get hasValue() {
+    return this.masked !== undefined && this.pad !== undefined;
   }
-  async put(key, value, options) {
-    await this.stores[0].put(key, value, options);
+  clear() {
+    this.clearInternal(true);
   }
-  async delete(key) {
-    let deleted = false;
-    for (const store of this.stores) {
-      if (await store.delete(key)) {
-        deleted = true;
-      }
+  clearInternal(fireCallback) {
+    if (this.hardTimer !== undefined) {
+      clearTimeout(this.hardTimer);
+      this.hardTimer = undefined;
+    }
+    if (this.idleTimer !== undefined) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = undefined;
+    }
+    const hadValue = this.masked !== undefined;
+    if (this.masked) {
+      this.masked.fill(0);
+      this.masked = undefined;
+    }
+    if (this.pad) {
+      this.pad.fill(0);
+      this.pad = undefined;
+    }
+    if (fireCallback && hadValue && this.options.onExpiry) {
+      this.options.onExpiry();
     }
-    return deleted;
   }
-  async has(key) {
-    for (const store of this.stores) {
-      if (await store.has(key))
-        return true;
+  startTimers() {
+    const hardTtl = this.options.hardTtlMs ?? DEFAULT_HARD_TTL_MS;
+    this.hardTimer = setTimeout(() => this.clear(), hardTtl);
+    if (typeof this.hardTimer === "object" && "unref" in this.hardTimer) {
+      this.hardTimer.unref();
     }
-    return false;
+    this.resetIdleTimer();
   }
-  async keys() {
-    const seen = new Set;
-    for (const store of this.stores) {
-      for (const key of await store.keys()) {
-        seen.add(key);
+  resetIdleTimer() {
+    if (this.idleTimer !== undefined) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = undefined;
+    }
+    const idleTtl = this.options.idleTtlMs;
+    if (idleTtl !== undefined && this.masked !== undefined) {
+      this.idleTimer = setTimeout(() => this.clear(), idleTtl);
+      if (typeof this.idleTimer === "object" && "unref" in this.idleTimer) {
+        this.idleTimer.unref();
       }
     }
-    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) {
@@ -1382,9 +1640,7 @@ function createDefaultTelemetryProvider() {
   }
   return new NoopTelemetryProvider;
 }
-if (!globalServiceRegistry.has(TELEMETRY_PROVIDER)) {
-  globalServiceRegistry.register(TELEMETRY_PROVIDER, createDefaultTelemetryProvider, true);
-}
+globalServiceRegistry.registerIfAbsent(TELEMETRY_PROVIDER, createDefaultTelemetryProvider, true);
 function getTelemetryProvider() {
   return globalServiceRegistry.get(TELEMETRY_PROVIDER);
 }
@@ -1588,9 +1844,9 @@ class WorkerServerBase {
     setTimeout(() => {
       this.completedRequests.delete(id);
     }, 5000);
-    if (this.completedRequests.size > 1e4) {
+    if (this.completedRequests.size > 1000) {
       const iter = this.completedRequests.values();
-      for (let i = 0;i < 5000; i++) {
+      for (let i = 0;i < 500; i++) {
         const entry = iter.next();
         if (entry.done)
           break;
@@ -1645,6 +1901,7 @@ export {
   serialize,
   resolveCredential,
   registerInputResolver,
+  registerInputCompactor,
   parentPort,
   objectOfArraysAsArrayOfObjects,
   makeFingerprint,
@@ -1653,6 +1910,7 @@ export {
   getTelemetryProvider,
   getLogger,
   getInputResolvers,
+  getInputCompactors,
   getGlobalCredentialStore,
   forceArray,
   encrypt,
@@ -1671,20 +1929,26 @@ export {
   TELEMETRY_PROVIDER,
   SpanStatusCode,
   ServiceRegistry,
+  OtpPassphraseCache,
   OTelTelemetryProvider,
   NullLogger,
   NoopTelemetryProvider,
   LOGGER,
   InMemoryCredentialStore,
   INPUT_RESOLVERS,
+  INPUT_COMPACTORS,
   EventEmitter,
   EnvCredentialStore,
+  CredentialPutInputSchema,
   Container,
   ConsoleTelemetryProvider,
   ConsoleLogger,
   ChainedCredentialStore,
   CREDENTIAL_STORE,
+  CREDENTIAL_PROVIDER_SCHEMA_ENUM,
+  CREDENTIAL_PROVIDER_OPTIONS,
+  CREDENTIAL_PROVIDER_NONE,
   BaseError
 };
 
-//# debugId=95A7F4B72D9E347164756E2164756E21
+//# debugId=4E655B5EF37DCACC64756E2164756E21