@compforge/harness-toolbox 0.4.1 → 0.4.3

package/dist/redis/topology.js

@@ -1,6 +1,6 @@
 import {
   discoverRedisTopology
-} from "../chunk-c6z919qb.js";
+} from "../chunk-5tbzf9wd.js";
 export {
   discoverRedisTopology
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compforge/harness-toolbox",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Shared infrastructure clients, transports and bounded data capture",
   "type": "module",
   "scripts": {
@@ -99,7 +99,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@compforge/harness-common": "0.5.3",
+    "@compforge/harness-common": "0.5.4",
     "@aws-sdk/client-s3": "3.1133.0",
     "@kubernetes/client-node": "1.4.0",
     "@opensearch-project/opensearch": "3.6.0",

package/dist/chunk-ajhdd4hp.js

@@ -1,267 +0,0 @@
-// src/redis/client.ts
-import { createClient } from "@redis/client";
-function stringValue(value) {
-  if (Buffer.isBuffer(value))
-    return value.toString("utf8");
-  return String(value ?? "");
-}
-function scalar(value) {
-  if (/^-?(?:\d+|\d+\.\d+)$/.test(value))
-    return Number(value);
-  return value;
-}
-function parseRedisInfo(raw) {
-  const result = {};
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line || line.startsWith("#"))
-      continue;
-    const separator = line.indexOf(":");
-    if (separator < 1)
-      continue;
-    const name = line.slice(0, separator);
-    const value = line.slice(separator + 1);
-    if (/^db\d+$/.test(name)) {
-      result[name] = Object.fromEntries(value.split(",").map((item) => {
-        const index = item.indexOf("=");
-        return [item.slice(0, index), scalar(item.slice(index + 1))];
-      }));
-    } else {
-      result[name] = scalar(value);
-    }
-  }
-  return result;
-}
-
-class RedisConnection {
-  endpoint;
-  client;
-  timeoutMs;
-  lastError;
-  constructor(endpoint, client, timeoutMs, lastError) {
-    this.endpoint = endpoint;
-    this.client = client;
-    this.timeoutMs = timeoutMs;
-    this.lastError = lastError;
-  }
-  static async connect(endpoint, mapped, config, clientFactory = createClient) {
-    const baseSocket = {
-      host: mapped.host,
-      port: mapped.port,
-      connectTimeout: config.timeoutMs,
-      reconnectStrategy: (retries) => retries >= 2 ? false : 100 * 2 ** retries
-    };
-    const socket = config.useSsl ? {
-      ...baseSocket,
-      tls: true,
-      servername: mapped.servername ?? endpoint.host
-    } : {
-      ...baseSocket,
-      tls: false
-    };
-    const client = clientFactory({
-      socket,
-      database: config.database,
-      username: config.username,
-      password: config.password,
-      commandOptions: { timeout: config.timeoutMs }
-    });
-    let lastError;
-    client.on("error", (err) => {
-      lastError = err instanceof Error ? err : new Error(String(err));
-    });
-    try {
-      await client.connect();
-    } catch (error) {
-      if (client.isOpen)
-        client.destroy();
-      throw error;
-    }
-    return new RedisConnection(endpoint, client, config.timeoutMs, () => lastError);
-  }
-  get isReady() {
-    return this.client.isReady;
-  }
-  async#execute(operationName, operation) {
-    try {
-      return await this.#executeOnce(operationName, operation);
-    } catch (err) {
-      if (this.client.isOpen && !this.client.isReady)
-        return this.#executeOnce(operationName, operation);
-      throw err;
-    }
-  }
-  async#executeOnce(operationName, operation) {
-    if (!this.client.isOpen) {
-      const reason = this.lastError()?.message;
-      throw new Error(`Redis connection is closed${reason ? `: ${reason}` : ""}`);
-    }
-    let timer;
-    const deadline = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        reject(new Error(`Redis ${operationName} timed out after ${this.timeoutMs}ms (${this.endpoint.host}:${this.endpoint.port})`));
-        this.close();
-      }, this.timeoutMs);
-    });
-    try {
-      return await Promise.race([Promise.resolve().then(operation), deadline]);
-    } finally {
-      if (timer)
-        clearTimeout(timer);
-    }
-  }
-  ping() {
-    return this.#execute("PING", () => this.client.ping());
-  }
-  async info(section) {
-    const raw = await this.#execute(section ? `INFO ${section}` : "INFO", () => section ? this.client.sendCommand(["INFO", section]) : this.client.sendCommand(["INFO"]));
-    return parseRedisInfo(stringValue(raw));
-  }
-  async dbSize() {
-    return Number(await this.#execute("DBSIZE", () => this.client.sendCommand(["DBSIZE"])));
-  }
-  command(args) {
-    return this.#execute(args[0]?.toUpperCase() ?? "command", () => this.client.sendCommand(args));
-  }
-  async pipeline(commands) {
-    const commandNames = new Set(commands.map((command) => command[0]?.toUpperCase()).filter(Boolean));
-    const operationName = commandNames.size === 1 ? `${[...commandNames][0]} pipeline` : "pipeline";
-    return await this.#execute(operationName, () => {
-      const pipeline = this.client.multi();
-      for (const command of commands)
-        pipeline.addCommand(command);
-      return pipeline.execAsPipeline();
-    });
-  }
-  async scan(cursor, count) {
-    const reply = await this.command(["SCAN", cursor, "COUNT", String(count)]);
-    if (!Array.isArray(reply) || !Array.isArray(reply[1]))
-      throw new Error("Redis SCAN 返回格式无效");
-    return { cursor: stringValue(reply[0]), keys: reply[1].map(stringValue) };
-  }
-  close() {
-    if (this.client.isOpen)
-      this.client.destroy();
-  }
-}
-
-class RedisAccess {
-  transport;
-  baseConfig;
-  connectionFactory;
-  #connections = new Map;
-  #closing;
-  constructor(transport, baseConfig, connectionFactory = RedisConnection.connect) {
-    this.transport = transport;
-    this.baseConfig = baseConfig;
-    this.connectionFactory = connectionFactory;
-  }
-  async connection(endpoint, database, credentials = this.baseConfig) {
-    if (this.#closing)
-      throw new Error("Redis access is closed");
-    const key = [
-      endpoint.host,
-      endpoint.port,
-      database,
-      credentials.username ?? "",
-      credentials.password ?? ""
-    ].join("\x00");
-    let pending = this.#connections.get(key);
-    if (pending) {
-      const connection = await pending;
-      if (this.#closing)
-        throw new Error("Redis access is closed");
-      if (connection.isReady)
-        return connection;
-      if (this.#connections.get(key) === pending) {
-        this.#connections.delete(key);
-        connection.close();
-      } else {
-        return this.connection(endpoint, database, credentials);
-      }
-    }
-    pending = this.transport.connect(endpoint).then((mapped) => this.connectionFactory(endpoint, mapped, {
-      ...this.baseConfig,
-      ...credentials,
-      database
-    }));
-    this.#connections.set(key, pending);
-    pending.catch(() => {
-      if (this.#connections.get(key) === pending)
-        this.#connections.delete(key);
-    });
-    return await pending;
-  }
-  close() {
-    return this.#closing ??= (async () => {
-      const settled = await Promise.allSettled(this.#connections.values());
-      this.#connections.clear();
-      const errors = [];
-      for (const result of settled)
-        if (result.status === "fulfilled") {
-          try {
-            result.value.close();
-          } catch (error) {
-            errors.push(error);
-          }
-        }
-      if (errors.length)
-        throw new AggregateError(errors, "Redis connection cleanup failed");
-    })();
-  }
-}
-
-class RedisClient {
-  source;
-  #controller = new AbortController;
-  signal;
-  #initialization;
-  #disposal;
-  #access;
-  #target;
-  constructor(source, lifecycle = {}) {
-    this.source = source;
-    this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
-  }
-  initialize() {
-    this.signal.throwIfAborted();
-    return this.#initialization ??= (async () => {
-      this.#target = await this.source.resolve();
-      this.signal.throwIfAborted();
-      const transport = this.source.transports[0];
-      if (!transport || transport.kind !== "tcp")
-        throw new Error("Redis requires a TCP transport");
-      this.#access = new RedisAccess(transport, this.#target);
-    })();
-  }
-  get access() {
-    this.signal.throwIfAborted();
-    if (!this.#access)
-      throw new Error("Redis client is not initialized");
-    return this.#access;
-  }
-  get target() {
-    if (!this.#target)
-      throw new Error("Redis client is not initialized");
-    return this.#target;
-  }
-  dispose() {
-    return this.#disposal ??= (async () => {
-      this.#controller.abort(new Error("Redis client disposed"));
-      await this.#initialization?.catch(() => {});
-      await this.#access?.close();
-    })();
-  }
-}
-async function openRedis(source, lifecycle = {}) {
-  const client = new RedisClient(source, lifecycle);
-  try {
-    await client.initialize();
-  } catch (error) {
-    await client.dispose();
-    throw error;
-  }
-  lifecycle.onDispose?.(() => client.dispose());
-  return client;
-}
-
-export { parseRedisInfo, RedisConnection, RedisAccess, RedisClient, openRedis };

package/dist/chunk-ba883sdp.js

@@ -1,60 +0,0 @@
-import {
-  BoundedFileClient,
-  fileClientOptions
-} from "./chunk-mzdz6wwc.js";
-import {
-  FileError
-} from "./chunk-20kv4wc3.js";
-
-// src/file/local.ts
-import { constants } from "node:fs";
-import { open } from "node:fs/promises";
-import { resolve } from "node:path";
-import { clientKey, FileDataSource } from "@compforge/harness-common";
-class LocalFileClient extends BoundedFileClient {
-  async capture(signal, limits, receive) {
-    try {
-      const file = await open(this.path, constants.O_RDONLY | constants.O_NONBLOCK);
-      try {
-        signal.throwIfAborted();
-        if (!(await file.stat()).isFile()) {
-          throw new FileError(`Not a regular file: ${this.path}`, { kind: "unsupported_operation" });
-        }
-        const stream = file.createReadStream({ autoClose: false, signal, highWaterMark: Math.min(limits.maxBytes + 1, 64 * 1024) });
-        for await (const bytes of stream)
-          receive(bytes);
-      } finally {
-        await file.close();
-      }
-    } catch (cause) {
-      signal.throwIfAborted();
-      if (cause instanceof FileError)
-        throw cause;
-      const code = cause?.code;
-      throw new FileError(`Cannot read local file: ${this.path}`, {
-        kind: code === "ENOENT" || code === "ENOTDIR" ? "resource_not_found" : code === "EACCES" || code === "EPERM" ? "permission_denied" : "operation_failed",
-        code,
-        cause
-      });
-    }
-  }
-}
-
-class LocalFileDataSource extends FileDataSource {
-  path;
-  clientKey;
-  #options;
-  constructor(path, options) {
-    super();
-    if (!path || path.includes("\x00"))
-      throw new FileError("File path must be nonempty and contain no NUL", { kind: "invalid_argument" });
-    this.path = resolve(path);
-    this.#options = fileClientOptions(options);
-    this.clientKey = clientKey("local-file", { path: this.path, options: this.#options });
-  }
-  createClient(_clients, signal) {
-    return new LocalFileClient(this.path, this.#options, signal);
-  }
-}
-
-export { LocalFileClient, LocalFileDataSource };

package/dist/chunk-mxyvpy79.js

@@ -1,62 +0,0 @@
-import {
-  BoundedFileClient,
-  fileClientOptions
-} from "./chunk-mzdz6wwc.js";
-import {
-  FileError
-} from "./chunk-20kv4wc3.js";
-
-// src/file/pod.ts
-import { posix } from "node:path";
-import { clientKey, FileDataSource } from "@compforge/harness-common";
-class PodFileClient extends BoundedFileClient {
-  target;
-  acquire;
-  #kubernetes;
-  constructor(path, target, options, signal, acquire) {
-    super(path, options, signal);
-    this.target = target;
-    this.acquire = acquire;
-  }
-  async initializeAccess() {
-    this.#kubernetes = await this.acquire();
-  }
-  async capture(signal, limits, receive) {
-    const result = await this.#kubernetes.exec(this.target.namespace, this.target, ["head", "-c", String(limits.maxBytes + 1), this.path], { signal, timeoutMs: limits.timeoutMs, collectStdout: false, onStdoutBytes: receive });
-    signal.throwIfAborted();
-    if (!result.ok)
-      throw new FileError(`Cannot read Pod file: ${this.target.namespace}/${this.target.pod}/${this.target.container} ${this.path}`, { kind: result.timedOut ? "timeout" : "operation_failed", code: result.exitCode ?? undefined });
-  }
-}
-
-class PodFileDataSource extends FileDataSource {
-  kubernetes;
-  path;
-  target;
-  clientKey;
-  #options;
-  constructor(kubernetes, target, path, options) {
-    super();
-    this.kubernetes = kubernetes;
-    if (!posix.isAbsolute(path) || path.includes("\x00")) {
-      throw new FileError("Pod file path must be absolute and contain no NUL", { kind: "invalid_argument" });
-    }
-    if ([target.namespace, target.pod, target.container].some((value) => !value.trim())) {
-      throw new FileError("Pod file namespace, Pod and Container are required", { kind: "invalid_argument" });
-    }
-    this.path = path;
-    this.target = Object.freeze({ namespace: target.namespace, pod: target.pod, container: target.container });
-    this.#options = fileClientOptions(options);
-    this.clientKey = clientKey("pod-file", {
-      access: kubernetes.clientKey,
-      target: this.target,
-      path: this.path,
-      options: this.#options
-    });
-  }
-  createClient(clients, signal) {
-    return new PodFileClient(this.path, this.target, this.#options, signal, () => clients.get(this.kubernetes));
-  }
-}
-
-export { PodFileClient, PodFileDataSource };

package/dist/chunk-mzdz6wwc.js

@@ -1,91 +0,0 @@
-import {
-  FileError,
-  ToolboxError
-} from "./chunk-20kv4wc3.js";
-import {
-  ConcurrencyPool
-} from "./chunk-v3hxvnrc.js";
-
-// src/file/client.ts
-function fileClientOptions(options) {
-  if (!Number.isSafeInteger(options.concurrency) || options.concurrency < 1) {
-    throw new FileError("File concurrency must be a positive integer", { kind: "invalid_argument" });
-  }
-  return Object.freeze({ concurrency: options.concurrency });
-}
-
-class BoundedFileClient {
-  path;
-  #controller = new AbortController;
-  #signal;
-  #pool;
-  #operations = new Set;
-  #ready = false;
-  #disposal;
-  constructor(path, options, signal) {
-    this.path = path;
-    this.#pool = new ConcurrencyPool(fileClientOptions(options).concurrency);
-    this.#signal = AbortSignal.any([signal, this.#controller.signal]);
-  }
-  async initialize() {
-    this.#signal.throwIfAborted();
-    await this.initializeAccess();
-    this.#signal.throwIfAborted();
-    this.#ready = true;
-  }
-  async initializeAccess() {}
-  async read(options) {
-    this.#signal.throwIfAborted();
-    if (!this.#ready)
-      throw new FileError(`File client is not initialized: ${this.path}`, { kind: "operation_failed" });
-    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0 || options.maxBytes === Number.MAX_SAFE_INTEGER || !Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > 2147483647) {
-      throw new FileError(`Invalid file read limits: ${this.path}`, { kind: "invalid_argument" });
-    }
-    const { maxBytes, timeoutMs } = options;
-    const controller = new AbortController;
-    const signal = AbortSignal.any([this.#signal, controller.signal, ...options.signal ? [options.signal] : []]);
-    const timer = setTimeout(() => controller.abort(new FileError(`File read timed out: ${this.path}`, { kind: "timeout" })), timeoutMs);
-    const operation = this.#pool.run(async () => {
-      const chunks = [];
-      let size = 0;
-      await this.capture(signal, { maxBytes, timeoutMs }, (bytes) => {
-        if (signal.aborted)
-          return;
-        if (bytes.byteLength > maxBytes - size) {
-          controller.abort(new FileError(`File exceeds ${maxBytes} bytes: ${this.path}`, { kind: "limit_exceeded" }));
-          return;
-        }
-        chunks.push(Uint8Array.from(bytes));
-        size += bytes.byteLength;
-      });
-      signal.throwIfAborted();
-      const result = new Uint8Array(size);
-      let offset = 0;
-      for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.byteLength;
-      }
-      return result;
-    }, signal);
-    this.#operations.add(operation);
-    try {
-      return await operation;
-    } catch (cause) {
-      signal.throwIfAborted();
-      if (cause instanceof ToolboxError)
-        throw cause;
-      throw new FileError(`Cannot read file: ${this.path}`, { kind: "operation_failed", cause });
-    } finally {
-      clearTimeout(timer);
-      this.#operations.delete(operation);
-    }
-  }
-  dispose() {
-    return this.#disposal ??= (async () => {
-      this.#controller.abort(new Error(`File client disposed: ${this.path}`));
-      await Promise.allSettled(this.#operations);
-    })();
-  }
-}
-
-export { fileClientOptions, BoundedFileClient };