@compforge/harness-toolbox 0.4.8 → 0.5.1

package/dist/{chunk-t4hrnaj0.js → chunk-ex429qjt.js}

@@ -11,20 +11,20 @@ import {
   destroyMysqlConnection
 } from "./chunk-835fssgz.js";
 import {
-  acquireConnection,
-  awaitWithSignal
-} from "./chunk-gm4swndx.js";
-import {
-  ToolboxError
-} from "./chunk-rkt41za2.js";
+  isConnectionNetworkError
+} from "./chunk-18gcp0ck.js";
 import {
   ConcurrencyPool
 } from "./chunk-v3hxvnrc.js";
 import {
-  isConnectionNetworkError
-} from "./chunk-h8fwx0k7.js";
+  Transport
+} from "./chunk-sb5qzv37.js";
+import {
+  ToolboxError
+} from "./chunk-rkt41za2.js";
 
 // src/mysql/client.ts
+import { raceSignal } from "race-signal";
 function mysqlOperationError(error, phase) {
   if (!error || typeof error !== "object" || !("code" in error) || error.code !== "PROTOCOL_CONNECTION_LOST")
     return error;
@@ -36,15 +36,15 @@ function mysqlOperationError(error, phase) {
 }
 
 class MysqlDatabase {
-  transports;
   options;
   connect;
   #queries = new ConcurrencyPool(1);
   #connections = new Map;
-  constructor(transports, options, connect = connectMysql) {
-    this.transports = transports;
+  #transport;
+  constructor(transport, options, connect = connectMysql) {
     this.options = options;
     this.connect = connect;
+    this.#transport = transport instanceof Transport ? transport : new Transport(transport);
   }
   query(target, sql, values) {
     return this.#queries.run(() => this.#query(target, sql, values), this.options.signal);
@@ -125,14 +125,14 @@ class MysqlDatabase {
     });
   }
   #open(target) {
-    return acquireConnection(this.transports, {
+    return this.#transport.acquire({
       name: "MySQL connection",
       ...this.options,
       open: async (transport, attempt) => {
         if (transport.kind === "python")
           return { connection: { kind: "python", transport }, transport: transport.name };
         try {
-          const endpoint = await transport.connect(target);
+          const endpoint = await transport.connect(target, attempt);
           const connection = await this.connect({
             host: endpoint.host,
             port: endpoint.port,
@@ -175,7 +175,8 @@ class MysqlDatabase {
 }
 
 class MysqlClient {
-  source;
+  configuration;
+  transport;
   options;
   #controller = new AbortController;
   signal;
@@ -183,17 +184,18 @@ class MysqlClient {
   #disposal;
   #database;
   #target;
-  constructor(source, options) {
-    this.source = source;
+  constructor(configuration, transport, options) {
+    this.configuration = configuration;
+    this.transport = transport;
     this.options = options;
     this.signal = options.signal ? AbortSignal.any([options.signal, this.#controller.signal]) : this.#controller.signal;
   }
   initialize() {
     this.signal.throwIfAborted();
     return this.#initialization ??= (async () => {
-      this.#target = await awaitWithSignal(this.source.resolve(), this.signal);
+      this.#target = await raceSignal(typeof this.configuration === "function" ? this.configuration() : Promise.resolve(this.configuration), this.signal);
       this.signal.throwIfAborted();
-      this.#database = new MysqlDatabase(this.source.transports, { ...this.options, signal: this.signal });
+      this.#database = new MysqlDatabase(this.transport, { ...this.options, signal: this.signal });
       await this.#database.initialize(this.#target);
     })();
   }
@@ -215,8 +217,8 @@ class MysqlClient {
     })();
   }
 }
-async function openMysql(source, options) {
-  const client = new MysqlClient(source, options);
+async function openMysql(configuration, transport, options) {
+  const client = new MysqlClient(configuration, transport, options);
   try {
     await client.initialize();
   } catch (error) {

package/dist/{chunk-m391jmpw.js → chunk-hbhbragw.js}

@@ -1,21 +1,21 @@
+import {
+  KubernetesResourceTransport
+} from "./chunk-5w85c7cs.js";
+import {
+  KubernetesExecTransport
+} from "./chunk-xeft7af0.js";
 import {
   resolveWorkload
 } from "./chunk-ae84rzq5.js";
 import {
   ServicePortForwarder
-} from "./chunk-1ts7pswj.js";
-import {
-  KubernetesResourceTransport
-} from "./chunk-x0yhfg29.js";
+} from "./chunk-0d8vs5q8.js";
 import {
-  KubernetesExecTransport
-} from "./chunk-r3rnsvwv.js";
+  KubectlExecutor
+} from "./chunk-rq5fc007.js";
 import {
   KubernetesError
 } from "./chunk-rkt41za2.js";
-import {
-  KubectlExecutor
-} from "./chunk-rq5fc007.js";
 
 // src/kubernetes/client.ts
 class KubernetesClient {

package/dist/{chunk-fqrknvr8.js → chunk-kap6ka3n.js}

@@ -1,25 +1,29 @@
+import {
+  POD_RELAY_SCRIPT
+} from "./chunk-ssj93brx.js";
 import {
   startPortForward
-} from "./chunk-nftzckdy.js";
+} from "./chunk-mvkxs8d0.js";
 import {
   KubectlExecutor
 } from "./chunk-rq5fc007.js";
 import {
-  POD_RELAY_SCRIPT
-} from "./chunk-ssj93brx.js";
+  Transport
+} from "./chunk-sb5qzv37.js";
 
 // src/transport/pod-relay.ts
-class PodRelayTransport {
+import { raceSignal } from "race-signal";
+class PodRelayTransport extends Transport {
   options;
   kind = "tcp";
   name = "pod-relay";
-  #controller = new AbortController;
   #signal;
   #executor;
   #startForward;
   #targets = new Map;
   #pending = new Map;
   #forwards = [];
+  #exits = [];
   #startup;
   #execution;
   #input;
@@ -28,6 +32,7 @@ class PodRelayTransport {
   #disposal;
   #sequence = 0;
   constructor(options, dependencies) {
+    super([], options.signal);
     this.options = options;
     for (const key of ["startupTimeoutMs", "connectTimeoutMs", "maxConnections", "maxTargets", "maxCandidatePods"]) {
       if (!Number.isSafeInteger(options[key]) || options[key] <= 0)
@@ -35,10 +40,14 @@ class PodRelayTransport {
     }
     this.#executor = dependencies?.executor ?? new KubectlExecutor(options);
     this.#startForward = dependencies?.startForward ?? startPortForward;
-    this.#signal = options.signal ? AbortSignal.any([options.signal, this.#controller.signal]) : this.#controller.signal;
+    this.#signal = this.resourceSignal;
     this.#signal.addEventListener("abort", this.#onAbort, { once: true });
   }
+  paths() {
+    return [this];
+  }
   async initialize() {
+    this.signal.throwIfAborted();
     this.#check();
   }
   #check() {
@@ -175,7 +184,8 @@ class PodRelayTransport {
     this.#input.enqueue(new TextEncoder().encode(`${JSON.stringify(value)}
 `));
   }
-  connect(endpoint) {
+  connect(endpoint, attempt) {
+    this.signal.throwIfAborted();
     this.#check();
     if (!endpoint.host || !Number.isInteger(endpoint.port) || endpoint.port < 1 || endpoint.port > 65535) {
       return Promise.reject(new Error("Invalid relay endpoint"));
@@ -192,7 +202,7 @@ class PodRelayTransport {
       pending = this.#connect(endpoint, this.#startup);
       this.#targets.set(key, pending);
     }
-    return pending.then((local) => ({ ...local, servername: endpoint.servername ?? endpoint.host }));
+    return raceSignal(pending, attempt ? AbortSignal.any([this.signal, attempt.signal]) : this.signal);
   }
   async#connect(endpoint, startup) {
     const pod = await startup;
@@ -225,10 +235,13 @@ class PodRelayTransport {
       ...this.options,
       target: { kind: "pod", name: pod.target.pod },
       remotePort,
-      timeoutMs: this.options.startupTimeoutMs
+      timeoutMs: this.options.startupTimeoutMs,
+      signal: this.#signal
     });
     if (!forwarded.ok || !forwarded.value)
       throw new Error("Pod relay port-forward unavailable");
+    if (forwarded.value.exited)
+      this.#exits.push(forwarded.value.exited);
     try {
       this.#check();
     } catch (error) {
@@ -238,14 +251,16 @@ class PodRelayTransport {
     this.#forwards.push(forwarded.value);
     return { host: "127.0.0.1", port: forwarded.value.localPort };
   }
-  dispose() {
+  close() {
     return this.#disposal ??= (async () => {
-      this.#controller.abort(new Error("Pod relay disposed"));
       this.#fail(new Error("Pod relay disposed"));
       await Promise.allSettled(this.#targets.values());
-      await this.#execution;
+      const completed = await Promise.allSettled([this.#execution, ...this.#exits]);
       this.#signal.removeEventListener("abort", this.#onAbort);
       this.#targets.clear();
+      const errors = completed.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+      if (errors.length)
+        throw new AggregateError(errors, "Pod relay cleanup failed");
     })();
   }
 }

package/dist/{chunk-vymm4g9h.js → chunk-kxpecgy7.js}

@@ -1,17 +1,21 @@
 import {
-  acquireConnection,
-  awaitWithSignal
-} from "./chunk-gm4swndx.js";
+  isConnectionNetworkError
+} from "./chunk-18gcp0ck.js";
 import {
   TimeoutError,
   ToolboxError
 } from "./chunk-rkt41za2.js";
-import {
-  isConnectionNetworkError
-} from "./chunk-h8fwx0k7.js";
 
 // src/opensearch/client.ts
+import { raceSignal } from "race-signal";
 import { Client, Connection, errors } from "@opensearch-project/opensearch";
+import { isIP } from "node:net";
+function openSearchServername(host) {
+  if (!host)
+    return;
+  const unwrapped = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  return isIP(unwrapped) ? undefined : host;
+}
 function describeOpenSearchError(error) {
   const parts = [];
   const seen = new Set;
@@ -36,16 +40,30 @@ function isOpenSearchReadApi(search) {
 }
 
 class OpenSearchConnection extends Connection {
+  request(params, callback) {
+    let completed = false;
+    try {
+      return super.request(params, (error, response) => {
+        completed = true;
+        callback(error, response);
+      });
+    } catch (error) {
+      if (!completed)
+        this._openRequests--;
+      throw error;
+    }
+  }
   buildRequestObject(params) {
-    return { ...super.buildRequestObject(params), servername: this.ssl?.servername };
+    return { ...super.buildRequestObject(params), servername: openSearchServername(this.ssl?.servername) };
   }
 }
 function createClient(options) {
   return new Client({
     node: options.node,
     Connection: OpenSearchConnection,
+    headers: options.authority ? { host: options.authority } : undefined,
     auth: options.auth.username && options.auth.password ? { username: options.auth.username, password: options.auth.password } : undefined,
-    ssl: { rejectUnauthorized: false, servername: options.servername },
+    ssl: { rejectUnauthorized: false, servername: openSearchServername(options.servername) },
     requestTimeout: options.requestTimeoutMs ?? 60000,
     maxRetries: 0,
     agent: { keepAlive: !process.versions.bun }
@@ -55,26 +73,36 @@ function createClient(options) {
 class OpenSearchEngine {
   options;
   client;
+  #requests = new Set;
+  #closed = false;
   constructor(options, client) {
     this.options = options;
     this.client = client ?? createClient(options);
   }
+  #run(start) {
+    if (this.#closed)
+      throw new Error("OpenSearch engine is closed");
+    const request = start();
+    this.#requests.add(request);
+    request.then(() => this.#requests.delete(request), () => this.#requests.delete(request));
+    return request;
+  }
   async count(index, query) {
-    const response = await this.client.count({ index, body: { query } });
+    const response = await this.#run(() => this.client.count({ index, body: { query } }));
     return Number(response.body.count ?? 0);
   }
   async search(index, body) {
-    const response = await this.client.search({ index, body });
+    const response = await this.#run(() => this.client.search({ index, body }));
     return response.body;
   }
   async request(path, query) {
     if (!this.client.transport)
       throw new Error("OpenSearch client 不支持通用只读请求");
-    const response = await this.client.transport.request({
+    const response = await this.#run(() => this.client.transport.request({
       method: "GET",
       path,
       querystring: query
-    });
+    }));
     return response.body;
   }
   async ping(signal, timeoutMs = this.options.requestTimeoutMs ?? 60000) {
@@ -87,9 +115,10 @@ class OpenSearchEngine {
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(new TimeoutError(`OpenSearch probe timed out after ${timeoutMs}ms`)), timeoutMs);
     const active = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+    let request;
     try {
-      const request = this.client.ping({}, { requestTimeout: timeoutMs });
-      const result = await awaitWithSignal(request, active, () => request.abort?.());
+      request = this.#run(() => this.client.ping({}, { requestTimeout: timeoutMs }));
+      const result = await raceSignal(request, active);
       log(`OpenSearch probe ok target=${target} elapsed_ms=${Date.now() - started}`);
       return result;
     } catch (error) {
@@ -97,13 +126,18 @@ class OpenSearchEngine {
       throw error;
     } finally {
       clearTimeout(timer);
+      if (active.aborted)
+        request?.abort?.();
     }
   }
   async close() {
+    this.#closed = true;
+    for (const request of this.#requests)
+      request.abort?.();
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(new TimeoutError("OpenSearch close timed out after 2000ms")), 2000);
     try {
-      await awaitWithSignal(this.client.close(), controller.signal);
+      await raceSignal(this.client.close(), controller.signal);
     } catch (error) {
       this.options.onDiagnostic?.(`OpenSearch close failed ${describeOpenSearchError(error)}`);
       throw error;
@@ -123,27 +157,39 @@ function openSearchRetryReason(error) {
 }
 
 class OpenSearchClient {
-  source;
+  configuration;
+  transport;
   lifecycle;
   #controller = new AbortController;
   signal;
   #initialization;
   #disposal;
   #engine;
+  #node;
+  get node() {
+    return this.#node;
+  }
+  #cleanupErrors = [];
   #operations = new Set;
-  constructor(source, lifecycle = {}) {
-    this.source = source;
+  constructor(configuration, transport, lifecycle = {}) {
+    this.configuration = configuration;
+    this.transport = transport;
     this.lifecycle = lifecycle;
     this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
   }
   initialize() {
     this.signal.throwIfAborted();
     return this.#initialization ??= (async () => {
-      const target = await awaitWithSignal(this.source.resolve(), this.signal);
+      const target = await raceSignal(typeof this.configuration === "function" ? this.configuration() : Promise.resolve(this.configuration), this.signal);
       this.signal.throwIfAborted();
-      const original = new URL(target.node);
+      const explicit = target.node.includes("://");
+      const preferred = target.preferredScheme ?? "http";
+      const original = new URL(explicit ? target.node : `${preferred}://${target.node}`);
+      if (!explicit && !original.port)
+        original.port = "9200";
+      const schemes = explicit ? [original.protocol] : preferred === "https" ? ["https:", "http:"] : ["http:", "https:"];
       try {
-        this.#engine = await acquireConnection(this.source.transports, {
+        this.#engine = await this.transport.acquire({
           name: "OpenSearch connection",
           signal: this.signal,
           connectTimeoutMs: target.connectTimeoutMs ?? target.requestTimeoutMs ?? 1e4,
@@ -155,23 +201,40 @@ class OpenSearchClient {
             this.lifecycle.onDiagnostic?.(`OpenSearch route start transport=${transport.name} target=${original.protocol}//${original.host} timeout_ms=${attempt.remainingMs()}`);
             const endpoint = await transport.connect({
               host: original.hostname,
-              port: Number(original.port || (original.protocol === "https:" ? 443 : 80)),
-              servername: target.servername ?? original.hostname
-            });
+              port: Number(original.port || (original.protocol === "https:" ? 443 : 80))
+            }, attempt);
             attempt.signal.throwIfAborted();
             const url = new URL(original);
             url.hostname = endpoint.host;
             url.port = String(endpoint.port);
-            const engine = new OpenSearchEngine({ ...target, onDiagnostic: this.lifecycle.onDiagnostic, node: url.toString(), servername: endpoint.servername ?? target.servername ?? original.hostname });
-            try {
-              await engine.ping(attempt.signal, attempt.remainingMs());
-              return { connection: engine, transport: transport.name };
-            } catch (error) {
+            for (const [index, scheme] of schemes.entries()) {
+              url.protocol = scheme;
+              const engine = new OpenSearchEngine({
+                ...target,
+                onDiagnostic: this.lifecycle.onDiagnostic,
+                node: url.toString(),
+                authority: original.host,
+                servername: target.servername ?? original.hostname
+              });
               try {
-                await engine.close();
-              } catch {}
-              throw error;
+                await engine.ping(attempt.signal, attempt.remainingMs());
+                const selected = new URL(original);
+                selected.protocol = scheme;
+                this.#node = selected.toString().replace(/\/$/, "");
+                return { connection: engine, transport: transport.name };
+              } catch (error) {
+                try {
+                  await engine.close();
+                } catch (cleanup) {
+                  this.#cleanupErrors.push(cleanup);
+                  throw new AggregateError([error, cleanup], "OpenSearch initialization and cleanup failed", { cause: error });
+                }
+                attempt.signal.throwIfAborted();
+                if (index === schemes.length - 1 || openSearchRetryReason(error) === undefined)
+                  throw error;
+              }
             }
+            throw new Error("OpenSearch has no protocol candidate");
           },
           close: (engine) => engine.close(),
           retryReason: openSearchRetryReason
@@ -220,21 +283,27 @@ class OpenSearchClient {
     return this.#disposal ??= (async () => {
       this.#controller.abort(new Error("OpenSearch client disposed"));
       await this.#initialization?.catch(() => {});
-      await Promise.allSettled(this.#operations);
       await this.#engine?.close();
+      await Promise.allSettled(this.#operations);
+      if (this.#cleanupErrors.length)
+        throw new AggregateError(this.#cleanupErrors, "OpenSearch cleanup failed");
     })();
   }
 }
-async function openOpenSearch(source, lifecycle = {}) {
-  const client = new OpenSearchClient(source, lifecycle);
+async function openOpenSearch(configuration, transport, lifecycle = {}) {
+  const client = new OpenSearchClient(configuration, transport, lifecycle);
   try {
     await client.initialize();
   } catch (error) {
-    await client.dispose();
+    try {
+      await client.dispose();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "OpenSearch initialization and cleanup failed", { cause: error });
+    }
     throw error;
   }
   lifecycle.onDispose?.(() => client.dispose());
   return client;
 }
 
-export { describeOpenSearchError, isOpenSearchReadApi, OpenSearchEngine, OpenSearchClient, openOpenSearch };
+export { openSearchServername, describeOpenSearchError, isOpenSearchReadApi, OpenSearchEngine, OpenSearchClient, openOpenSearch };

package/dist/{chunk-nftzckdy.js → chunk-mvkxs8d0.js}

@@ -69,7 +69,14 @@ async function startPortForward(opts) {
   opts.signal?.addEventListener("abort", abort, { once: true });
   if (opts.signal?.aborted)
     abort();
-  proc.exited.then(() => opts.signal?.removeEventListener("abort", abort), () => opts.signal?.removeEventListener("abort", abort));
+  let alive = true;
+  proc.exited.then(() => {
+    alive = false;
+    opts.signal?.removeEventListener("abort", abort);
+  }, () => {
+    alive = false;
+    opts.signal?.removeEventListener("abort", abort);
+  });
   const decoder = new TextDecoder;
   const deadline = Date.now() + timeoutMs;
   let out = "";
@@ -105,7 +112,7 @@ async function startPortForward(opts) {
       log(`port-forward listening local=127.0.0.1:${m[1]} elapsed_ms=${Date.now() - started}`);
       return {
         ok: true,
-        value: { target, localPort: Number(m[1]), command: argv, stop }
+        value: { target, localPort: Number(m[1]), command: argv, stop, exited: proc.exited, isAlive: () => alive && !stopped }
       };
     }
   }
@@ -141,6 +148,14 @@ class PortForwardScope {
     for (const forward of this.#forwards.splice(0).reverse())
       forward.stop();
   }
+  async dispose() {
+    const forwards = [...this.#forwards];
+    this.stop();
+    const settled = await Promise.allSettled(forwards.map((forward) => forward.exited));
+    const errors = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (errors.length)
+      throw new AggregateError(errors, "Port-forward cleanup failed");
+  }
 }
 
 export { startPortForward, PortForwardScope };