@compforge/harness-toolbox 0.4.3 → 0.4.5

package/dist/kubernetes/compute.js

@@ -0,0 +1,211 @@
+import {
+  object,
+  parseComputeQuantity,
+  podCompute,
+  quantities,
+  requiredString,
+  sum,
+  summarizePods
+} from "../chunk-z15gwjvg.js";
+import {
+  KubernetesError
+} from "../chunk-rkt41za2.js";
+
+// src/kubernetes/compute.ts
+function requestBudget(options) {
+  if (!options.environment.trim() || [options.timeoutMs, options.maxPods, options.maxNodes, options.pageSize].some((value) => !Number.isSafeInteger(value) || value <= 0)) {
+    throw new KubernetesError("Compute requires environment and positive timeout/item/page budgets", { kind: "invalid_argument" });
+  }
+  const deadline = performance.now() + options.timeoutMs;
+  return () => {
+    options.signal?.throwIfAborted();
+    const remaining = Math.ceil(deadline - performance.now());
+    if (remaining <= 0)
+      throw new KubernetesError("Compute collection budget exhausted", { kind: "timeout" });
+    return { signal: options.signal, timeoutMs: remaining };
+  };
+}
+function issue(source, error) {
+  const kind = error instanceof KubernetesError ? error.kind : "operation_failed";
+  return {
+    source,
+    kind,
+    code: error instanceof KubernetesError ? error.code : undefined,
+    message: kind === "permission_denied" ? "Permission denied" : `Kubernetes compute read failed: ${kind}`
+  };
+}
+function finish(items, issues, observed) {
+  return { items, issues, status: !issues.length ? "complete" : observed ? "partial" : "unavailable" };
+}
+function gap(source, kind, message) {
+  return { source, kind, message };
+}
+async function readPages(access, query, maxItems, options, request, parse, identity) {
+  const source = `${query.apiVersion}/${query.resource}`;
+  const items = [], issues = [];
+  const tokens = new Set, identities = new Set;
+  let continuation, observed = false, read = 0;
+  try {
+    do {
+      const page = await access.list({ ...query, limit: Math.min(options.pageSize, maxItems - read), continue: continuation }, request());
+      if (!Array.isArray(page.items))
+        throw new KubernetesError("List lacks items", { kind: "invalid_response" });
+      observed = true;
+      for (const item of page.items.slice(0, maxItems - read)) {
+        try {
+          const parsed = parse(item), key = identity(parsed);
+          if (!identities.has(key)) {
+            items.push(parsed);
+            identities.add(key);
+          }
+        } catch (error) {
+          issues.push(issue(source, error));
+        }
+      }
+      read += page.items.length;
+      continuation = page.metadata?.continue || undefined;
+      if (read > maxItems || read >= maxItems && continuation) {
+        issues.push(gap(source, "limit_exceeded", `Collection limited to ${maxItems} items`));
+        break;
+      }
+      if (continuation && tokens.has(continuation)) {
+        issues.push(gap(source, "invalid_response", "Pagination did not advance"));
+        break;
+      }
+      if (continuation)
+        tokens.add(continuation);
+    } while (continuation);
+  } catch (error) {
+    options.signal?.throwIfAborted();
+    issues.push(issue(source, error));
+  }
+  return finish(items, issues, observed);
+}
+function nodeCompute(value) {
+  const meta = object(value.metadata), status = object(value.status), spec = object(value.spec);
+  const conditions = Array.isArray(status.conditions) ? status.conditions.map(object) : [];
+  return {
+    name: requiredString(meta.name, "node name"),
+    uid: requiredString(meta.uid, "node uid"),
+    ready: conditions.some((c) => c.type === "Ready" && c.status === "True"),
+    unschedulable: spec.unschedulable === true,
+    capacity: quantities(status.capacity, true),
+    allocatable: quantities(status.allocatable, true)
+  };
+}
+function usage(value) {
+  const timestamp = requiredString(value.timestamp, "metrics timestamp"), window = requiredString(value.window, "metrics window");
+  if (!Number.isFinite(Date.parse(timestamp)))
+    throw new KubernetesError("Invalid metrics timestamp", { kind: "invalid_response" });
+  return { ...quantities(value.usage, true), timestamp, window };
+}
+async function collectClusterCompute(access, options) {
+  const request = requestBudget(options);
+  const nodes = await readPages(access, { apiVersion: "v1", resource: "nodes" }, options.maxNodes, options, request, nodeCompute, (n) => n.uid);
+  const pods = await readPages(access, { apiVersion: "v1", resource: "pods" }, options.maxPods, options, request, podCompute, (p) => `${p.namespace}/${p.uid}`);
+  const metrics = await readPages(access, { apiVersion: "metrics.k8s.io/v1beta1", resource: "nodes" }, options.maxNodes, options, request, (item) => ({ ...usage(item), name: requiredString(item.metadata?.name, "metrics node name") }), (n) => n.name);
+  if (nodes.status !== "unavailable" && metrics.status !== "unavailable") {
+    const measured = new Set(metrics.items.map((item) => item.name));
+    for (const node of nodes.items)
+      if (!measured.has(node.name)) {
+        metrics.issues.push(gap(`nodes/${node.name}`, "resource_not_found", "Node has no metrics sample"));
+      }
+    if (metrics.issues.length)
+      metrics.status = "partial";
+  }
+  options.signal?.throwIfAborted();
+  return {
+    environment: options.environment,
+    observedAt: new Date().toISOString(),
+    scope: "cluster",
+    nodes,
+    pods,
+    usage: metrics,
+    summary: {
+      capacity: nodes.status !== "complete" && !nodes.items.length ? undefined : sum(nodes.items.map((n) => n.capacity)),
+      allocatable: nodes.status !== "complete" && !nodes.items.length ? undefined : sum(nodes.items.map((n) => n.allocatable)),
+      pods: pods.status !== "complete" && !pods.items.length ? undefined : summarizePods(pods.items),
+      usage: metrics.status === "unavailable" || !metrics.items.length && (metrics.status !== "complete" || nodes.status !== "complete" || nodes.items.length > 0) ? undefined : sum(metrics.items)
+    }
+  };
+}
+async function collectWorkloadCompute(access, instances, options) {
+  const request = requestBudget(options);
+  const selected = new Map;
+  for (const instance of instances) {
+    if (instance.environment !== options.environment) {
+      throw new KubernetesError("Compute instance belongs to a different environment", { kind: "invalid_argument" });
+    }
+    selected.set(JSON.stringify([instance.namespace, instance.pod, instance.uid]), instance);
+  }
+  const pods = [], metrics = [];
+  const podIssues = [], metricIssues = [];
+  if (selected.size > options.maxPods)
+    podIssues.push(gap("pods", "limit_exceeded", `Collection limited to ${options.maxPods} Pods`));
+  for (const instance of [...selected.values()].slice(0, options.maxPods)) {
+    const source = `pods/${instance.namespace}/${instance.pod}`;
+    let pod;
+    try {
+      pod = podCompute(await access.get({ apiVersion: "v1", resource: "pods", namespace: instance.namespace, name: instance.pod }, request()));
+      if (pod.uid !== instance.uid || pod.name !== instance.pod || pod.namespace !== instance.namespace) {
+        throw new KubernetesError("Pod identity changed after discovery", { kind: "invalid_response" });
+      }
+      pods.push(pod);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      podIssues.push(issue(source, error));
+      metricIssues.push(gap(source, "operation_failed", "Metrics not collected because Pod identity could not be verified"));
+      continue;
+    }
+    if (pod.phase === "Succeeded" || pod.phase === "Failed")
+      continue;
+    try {
+      const raw = await access.get({ apiVersion: "metrics.k8s.io/v1beta1", resource: "pods", namespace: pod.namespace, name: pod.name }, request());
+      if (raw.metadata?.name !== pod.name || raw.metadata?.namespace !== pod.namespace || !Array.isArray(raw.containers)) {
+        throw new KubernetesError("Pod metrics lacks identity or containers", { kind: "invalid_response" });
+      }
+      const names = raw.containers.map((c) => requiredString(object(c).name, "metrics container name"));
+      if (new Set(names).size !== names.length || pod.containers.some((name) => !names.includes(name))) {
+        throw new KubernetesError("Pod metrics does not cover its containers", { kind: "invalid_response" });
+      }
+      const values = raw.containers.map((c) => quantities(object(c).usage, true));
+      if (!values.length)
+        throw new KubernetesError("Empty Pod metrics", { kind: "invalid_response" });
+      const measured = {
+        ...usage({ ...raw, usage: { cpu: String(sum(values).cpu), memory: String(sum(values).memory) } }),
+        namespace: pod.namespace,
+        name: pod.name,
+        uid: pod.uid
+      };
+      if (raw.metadata.uid && raw.metadata.uid !== pod.uid || pod.createdAt && Date.parse(measured.timestamp) < Date.parse(pod.createdAt)) {
+        throw new KubernetesError("Pod metrics precedes current Pod incarnation", { kind: "invalid_response" });
+      }
+      metrics.push(measured);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      metricIssues.push(issue(`metrics/${source}`, error));
+    }
+  }
+  if (selected.size > options.maxPods)
+    metricIssues.push(gap("metrics/pods", "limit_exceeded", "Metrics limited to collected Pods"));
+  options.signal?.throwIfAborted();
+  const podRead = finish(pods, podIssues, pods.length > 0 || !selected.size);
+  const metricRead = finish(metrics, metricIssues, metrics.length > 0 || !podIssues.length && pods.every((p) => p.phase === "Succeeded" || p.phase === "Failed"));
+  return {
+    environment: options.environment,
+    observedAt: new Date().toISOString(),
+    scope: "instances",
+    workloads: instances.map(({ namespace, workload, pod, uid }) => ({ namespace, workload, pod, uid })),
+    pods: podRead,
+    usage: metricRead,
+    summary: {
+      pods: podRead.status === "unavailable" ? undefined : summarizePods(pods),
+      usage: metricRead.status === "unavailable" ? undefined : sum(metrics)
+    }
+  };
+}
+export {
+  parseComputeQuantity,
+  collectWorkloadCompute,
+  collectClusterCompute
+};

package/dist/kubernetes/environment.js

@@ -1,17 +1,17 @@
 import {
   KubernetesClient
-} from "../chunk-8kts470p.js";
-import"../chunk-4ms037k2.js";
-import"../chunk-0s27bgga.js";
+} from "../chunk-g2bac2jd.js";
+import"../chunk-ae84rzq5.js";
 import"../chunk-2171tajs.js";
 import"../chunk-j46x7j7c.js";
 import"../chunk-6fnhzhdb.js";
-import"../chunk-ftkrjqkc.js";
-import"../chunk-shsabpc1.js";
+import"../chunk-x0yhfg29.js";
+import"../chunk-dpcge1xt.js";
+import"../chunk-r3rnsvwv.js";
 import {
   clientKey
 } from "../chunk-a9htb6cr.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 import"../chunk-631vce5z.js";
 import"../chunk-hmah9t8e.js";

package/dist/kubernetes/exec-transport.js

@@ -1,7 +1,7 @@
 import {
   KubernetesExecTransport
-} from "../chunk-shsabpc1.js";
-import"../chunk-20kv4wc3.js";
+} from "../chunk-r3rnsvwv.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 export {
   KubernetesExecTransport

package/dist/kubernetes/pod-log-datasource.js

@@ -8,7 +8,7 @@ import"../chunk-a9htb6cr.js";
 import {
   clientKey
 } from "../chunk-z5pm2emz.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 
 // src/kubernetes/pod-log-datasource.ts

package/dist/kubernetes/resource-transport.js

@@ -1,9 +1,9 @@
 import {
   KubernetesResourceTransport
-} from "../chunk-4ms037k2.js";
-import"../chunk-ftkrjqkc.js";
+} from "../chunk-x0yhfg29.js";
+import"../chunk-dpcge1xt.js";
 import"../chunk-a9htb6cr.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 export {
   KubernetesResourceTransport

package/dist/kubernetes/resources.js

@@ -1,7 +1,7 @@
 import {
   resourcePath
-} from "../chunk-ftkrjqkc.js";
-import"../chunk-20kv4wc3.js";
+} from "../chunk-dpcge1xt.js";
+import"../chunk-rkt41za2.js";
 export {
   resourcePath
 };

package/dist/kubernetes/workload.js

@@ -1,7 +1,7 @@
 import {
   resolveWorkload
-} from "../chunk-0s27bgga.js";
-import"../chunk-20kv4wc3.js";
+} from "../chunk-ae84rzq5.js";
+import"../chunk-rkt41za2.js";
 export {
   resolveWorkload
 };

package/dist/mysql/client.d.ts

@@ -1,13 +1,16 @@
 import type { Client } from "../client";
-import { type Connection, type ConnectionOptions } from "mysql2/promise";
+import type { Connection, ConnectionOptions } from "mysql2/promise";
 import type { Database, DatabaseTarget, DatabaseRow, DatabaseQueryLimits, DatabaseQueryResult, SqlStatement } from "./types";
 import type { ConnectionSource, ClientLifecycle } from "../datasource";
 import { type Transport } from "../transport";
 export interface MysqlDatabaseOptions extends ClientLifecycle {
+    /** Per-route mapping and handshake budget. */
     connectTimeoutMs: number;
+    /** Total acquisition budget; defaults to connectTimeoutMs times the route count. */
+    acquireTimeoutMs?: number;
     queryTimeoutMs: number;
 }
-type ConnectionFactory = (options: ConnectionOptions) => Promise<Connection>;
+type ConnectionFactory = (options: ConnectionOptions, signal?: AbortSignal) => Promise<Connection>;
 /**
  * @spec SQL is executed once; only native connection establishment may advance to another transport.
  * @why mysql2 reports a socket closed during handshake as PROTOCOL_CONNECTION_LOST, before any SQL is sent.

package/dist/mysql/client.js

@@ -2,11 +2,12 @@ import {
   MysqlClient,
   MysqlDatabase,
   openMysql
-} from "../chunk-h73h2b7y.js";
+} from "../chunk-t4hrnaj0.js";
 import"../chunk-m91t44jh.js";
-import"../chunk-age65q4n.js";
-import"../chunk-136egyff.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-db4an9td.js";
+import"../chunk-835fssgz.js";
+import"../chunk-gm4swndx.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 import"../chunk-h8fwx0k7.js";
 import"../chunk-wv4jwhvj.js";

package/dist/mysql/connection.d.ts

@@ -1,3 +1,6 @@
+import { type ConnectionOptions } from "mysql2";
 import type { Connection } from "mysql2/promise";
+/** Keep the native handle available so cancellation can destroy an unfinished handshake. */
+export declare function connectMysql(options: ConnectionOptions, signal?: AbortSignal): Promise<Connection>;
 /** @why Disposal must release the socket even when the peer never finishes its TCP half-close. */
 export declare function destroyMysqlConnection(connection: Connection): void;

package/dist/mysql/connection.js

@@ -1,6 +1,8 @@
 import {
+  connectMysql,
   destroyMysqlConnection
-} from "../chunk-136egyff.js";
+} from "../chunk-835fssgz.js";
 export {
-  destroyMysqlConnection
+  destroyMysqlConnection,
+  connectMysql
 };

package/dist/mysql/index.js

@@ -1,3 +1,4 @@
+import"../chunk-pfar9cm3.js";
 import {
   withReadScope
 } from "../chunk-4sqvppz7.js";
@@ -5,9 +6,9 @@ import {
   MysqlClient,
   MysqlDatabase,
   openMysql
-} from "../chunk-h73h2b7y.js";
+} from "../chunk-t4hrnaj0.js";
 import"../chunk-m91t44jh.js";
-import"../chunk-age65q4n.js";
+import"../chunk-db4an9td.js";
 import {
   parseMysqlEnvTarget
 } from "../chunk-qq77x9ek.js";
@@ -16,9 +17,9 @@ import {
   limitedStatement,
   queryLimited
 } from "../chunk-1gyshqd9.js";
-import"../chunk-136egyff.js";
-import"../chunk-pfar9cm3.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-835fssgz.js";
+import"../chunk-gm4swndx.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 import"../chunk-h8fwx0k7.js";
 import"../chunk-wv4jwhvj.js";

package/dist/mysql/readonly.js

@@ -1,8 +1,8 @@
 import {
   queryReadonlySession,
   validateQueryLimits
-} from "../chunk-age65q4n.js";
-import"../chunk-136egyff.js";
+} from "../chunk-db4an9td.js";
+import"../chunk-835fssgz.js";
 export {
   validateQueryLimits,
   queryReadonlySession

package/dist/opensearch/client.d.ts

@@ -9,8 +9,10 @@ export interface OpenSearchOptions {
     node: string;
     auth: OpenSearchAuth;
     requestTimeoutMs?: number;
-    /** Deadline for the initialization probe; query deadlines remain independent. */
+    /** Per-route mapping and probe budget; query deadlines remain independent. */
     connectTimeoutMs?: number;
+    /** Total acquisition budget; defaults to the per-route budget times the route count. */
+    acquireTimeoutMs?: number;
     /** Original TLS identity when a transport maps the socket to localhost. */
     servername?: string;
 }

package/dist/opensearch/client.js

@@ -3,8 +3,9 @@ import {
   OpenSearchEngine,
   isOpenSearchReadApi,
   openOpenSearch
-} from "../chunk-8mb6natq.js";
-import"../chunk-20kv4wc3.js";
+} from "../chunk-sbt20n84.js";
+import"../chunk-gm4swndx.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-h8fwx0k7.js";
 import"../chunk-wv4jwhvj.js";
 import"../chunk-631vce5z.js";

package/dist/opensearch/index.js

@@ -10,8 +10,9 @@ import {
   OpenSearchEngine,
   isOpenSearchReadApi,
   openOpenSearch
-} from "../chunk-8mb6natq.js";
-import"../chunk-20kv4wc3.js";
+} from "../chunk-sbt20n84.js";
+import"../chunk-gm4swndx.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-h8fwx0k7.js";
 import"../chunk-wv4jwhvj.js";
 import"../chunk-631vce5z.js";

package/dist/redis/client.js

@@ -4,9 +4,10 @@ import {
   RedisConnection,
   openRedis,
   parseRedisInfo
-} from "../chunk-yp6tcw22.js";
+} from "../chunk-f98qrpx1.js";
+import"../chunk-gm4swndx.js";
 import"../chunk-5tbzf9wd.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-h8fwx0k7.js";
 import"../chunk-wv4jwhvj.js";
 import"../chunk-631vce5z.js";

package/dist/redis/index.js

@@ -1,18 +1,19 @@
-import {
-  collectRedisKeyStats,
-  redisGroupedSampleSizes
-} from "../chunk-jr9y0ghr.js";
 import {
   RedisAccess,
   RedisClient,
   RedisConnection,
   openRedis,
   parseRedisInfo
-} from "../chunk-yp6tcw22.js";
+} from "../chunk-f98qrpx1.js";
+import"../chunk-gm4swndx.js";
+import {
+  collectRedisKeyStats,
+  redisGroupedSampleSizes
+} from "../chunk-jr9y0ghr.js";
 import {
   discoverRedisTopology
 } from "../chunk-5tbzf9wd.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-h8fwx0k7.js";
 import"../chunk-wv4jwhvj.js";
 import"../chunk-631vce5z.js";

package/dist/s3/datasource.js

@@ -2,7 +2,7 @@ import {
   S3DataSource
 } from "../chunk-35cjec9z.js";
 import"../chunk-z5pm2emz.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-zp1s833x.js";
 import"../chunk-v3hxvnrc.js";
 import"../chunk-x4ntb898.js";

package/dist/s3/index.js

@@ -2,7 +2,7 @@ import {
   S3DataSource
 } from "../chunk-35cjec9z.js";
 import"../chunk-z5pm2emz.js";
-import"../chunk-20kv4wc3.js";
+import"../chunk-rkt41za2.js";
 import {
   S3Client
 } from "../chunk-zp1s833x.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compforge/harness-toolbox",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Shared infrastructure clients, transports and bounded data capture",
   "type": "module",
   "scripts": {
@@ -116,6 +116,9 @@
     "@types/node": "^22",
     "@types/ws": "^8.18.1"
   },
+  "overrides": {
+    "@compforge/harness-common": "file:../common"
+  },
   "publishConfig": {
     "access": "public"
   },

package/dist/chunk-136egyff.js

@@ -1,11 +0,0 @@
-// src/mysql/connection.ts
-function destroyMysqlConnection(connection) {
-  const native = connection.connection;
-  try {
-    connection.destroy();
-  } finally {
-    native.stream.destroy();
-  }
-}
-
-export { destroyMysqlConnection };