@compforge/harness-toolbox 0.1.0

package/dist/chunk-8nm9f0hh.js

@@ -0,0 +1,92 @@
+import {
+  ConcurrencyPool
+} from "./chunk-v3hxvnrc.js";
+
+// src/kubernetes/log-capture-plan.ts
+function budgetUnavailable(request) {
+  return {
+    ok: false,
+    exitCode: null,
+    stdout: "",
+    stderr: "日志采集总字节预算已耗尽",
+    durationMs: 0,
+    timedOut: false,
+    command: ["kubernetes-api", "logs", request.pod, ...request.container ? ["-c", request.container] : []],
+    captureStatus: "unavailable",
+    reason: "total_byte_budget",
+    bytesRead: 0,
+    attempts: 0
+  };
+}
+
+class PodLogByteBudget {
+  #available;
+  #reserved = 0;
+  #waiters = new Set;
+  constructor(maxBytes) {
+    this.#available = maxBytes;
+  }
+  async reserve(maxBytes) {
+    while (this.#available <= 0 && this.#reserved > 0) {
+      await new Promise((resolve) => this.#waiters.add(resolve));
+    }
+    const reserved = Math.max(0, Math.min(maxBytes, this.#available));
+    this.#available -= reserved;
+    this.#reserved += reserved;
+    return reserved;
+  }
+  settle(reserved, bytesRead) {
+    this.#reserved -= reserved;
+    this.#available += reserved - bytesRead;
+    for (const resolve of this.#waiters)
+      resolve();
+    this.#waiters.clear();
+  }
+}
+async function runPodLogCapturePlan(access, plan, policy, pool = new ConcurrencyPool(policy.concurrency), signal, budget = new PodLogByteBudget(policy.maxTotalBytes)) {
+  if (!Number.isInteger(policy.concurrency) || policy.concurrency < 1) {
+    throw new Error("Pod Log capture concurrency 必须是正整数");
+  }
+  if (policy.maxBytesPerCapture < 1 || policy.maxTotalBytes < 1) {
+    throw new Error("Pod Log capture 字节预算必须为正数");
+  }
+  const results = new Array(plan.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < plan.length) {
+      const index = cursor++;
+      const item = plan[index];
+      await pool.run(async () => {
+        item.onStart?.();
+        const reservedBytes = await budget.reserve(Math.min(policy.maxBytesPerCapture, item.request.limitBytes ?? policy.maxBytesPerCapture));
+        if (signal?.aborted) {
+          budget.settle(reservedBytes, 0);
+          signal.throwIfAborted();
+        }
+        if (reservedBytes <= 0) {
+          results[index] = {
+            target: item.target,
+            request: item.request,
+            capture: budgetUnavailable(item.request)
+          };
+          return;
+        }
+        const request = { ...item.request, limitBytes: reservedBytes };
+        let capture;
+        try {
+          capture = await access.collectPodLogs(request);
+          results[index] = { target: item.target, request, capture };
+        } finally {
+          budget.settle(reservedBytes, capture?.bytesRead ?? reservedBytes);
+        }
+      }, signal);
+    }
+  };
+  const settled = await Promise.allSettled(Array.from({ length: Math.min(policy.concurrency, plan.length) }, () => worker()));
+  const failed = settled.find((result) => result.status === "rejected");
+  if (failed?.status === "rejected" && !signal?.aborted)
+    throw failed.reason;
+  return results.filter((result) => result !== undefined);
+}
+
+export { PodLogByteBudget, runPodLogCapturePlan };

package/dist/chunk-ajhdd4hp.js

@@ -0,0 +1,267 @@
+// 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-c6z919qb.js

@@ -0,0 +1,98 @@
+// src/redis/topology.ts
+function text(value) {
+  return Buffer.isBuffer(value) ? value.toString("utf8") : String(value ?? "");
+}
+function endpoint(value, fallbackHost) {
+  if (!Array.isArray(value) || value.length < 2)
+    throw new Error("Redis 拓扑 endpoint 格式无效");
+  const host = text(value[0]) || fallbackHost || "";
+  const port = Number(value[1]);
+  if (!host || !Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Redis 拓扑 endpoint 无效：${host || "(empty)"}:${text(value[1])}`);
+  }
+  return { host, port };
+}
+function sentinelRows(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((row) => {
+    if (!Array.isArray(row))
+      return [];
+    const record = {};
+    for (let index = 0;index + 1 < row.length; index += 2) {
+      record[text(row[index])] = text(row[index + 1]);
+    }
+    return [record];
+  });
+}
+async function discoverSentinel(access, config) {
+  const sentinels = config.sentinelHosts.length ? config.sentinelHosts : config.endpoints;
+  let lastError;
+  for (const sentinel of sentinels) {
+    try {
+      const client = await access.connection(sentinel, 0, {
+        username: config.sentinelUsername,
+        password: config.sentinelPassword
+      });
+      const master = endpoint(await client.command([
+        "SENTINEL",
+        "GET-MASTER-ADDR-BY-NAME",
+        config.sentinelMasterName
+      ]));
+      const replicas = sentinelRows(await client.command([
+        "SENTINEL",
+        "REPLICAS",
+        config.sentinelMasterName
+      ])).filter((row) => !row.flags?.includes("s_down") && !row.flags?.includes("o_down")).flatMap((row) => {
+        const port = Number(row.port);
+        return row.ip && Number.isInteger(port) && port > 0 && port <= 65535 ? [{ host: row.ip, port }] : [];
+      });
+      return { clusterType: "sentinel", masters: [master], replicas, slotRanges: [] };
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw lastError ?? new Error("没有可用的 Redis Sentinel endpoint");
+}
+async function discoverSeed(access, config) {
+  let lastError;
+  for (const seed of config.endpoints) {
+    try {
+      const client = await access.connection(seed, 0);
+      await client.ping();
+      const clusterInfo = await client.info("cluster");
+      if (config.clusterType !== "cluster" && Number(clusterInfo.cluster_enabled ?? 0) !== 1) {
+        return { clusterType: "single", masters: [seed], replicas: [], slotRanges: [] };
+      }
+      const reply = await client.command(["CLUSTER", "SLOTS"]);
+      if (!Array.isArray(reply))
+        throw new Error("CLUSTER SLOTS 返回格式无效");
+      const masters = new Map;
+      const replicas = new Map;
+      const slotRanges = reply.map((row) => {
+        if (!Array.isArray(row) || row.length < 3)
+          throw new Error("CLUSTER SLOTS row 格式无效");
+        const master = endpoint(row[2], seed.host);
+        masters.set(`${master.host}:${master.port}`, master);
+        const rowReplicas = row.slice(3).map((item) => endpoint(item, seed.host));
+        for (const replica of rowReplicas)
+          replicas.set(`${replica.host}:${replica.port}`, replica);
+        return { start: Number(row[0]), end: Number(row[1]), master, replicas: rowReplicas };
+      });
+      return {
+        clusterType: "cluster",
+        masters: [...masters.values()],
+        replicas: [...replicas.values()],
+        slotRanges
+      };
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw lastError ?? new Error("没有可用的 Redis endpoint");
+}
+function discoverRedisTopology(access, config) {
+  return config.clusterType === "sentinel" ? discoverSentinel(access, config) : discoverSeed(access, config);
+}
+
+export { discoverRedisTopology };

package/dist/chunk-hqx7j9xe.js

@@ -0,0 +1,14 @@
+// src/datasource.ts
+import { createHash } from "node:crypto";
+function dataSourceKey(protocol, configuration) {
+  const canonical = (value) => {
+    if (Array.isArray(value))
+      return value.map(canonical);
+    if (value && typeof value === "object")
+      return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)]));
+    return value;
+  };
+  return `${protocol}:${createHash("sha256").update(JSON.stringify(canonical(configuration))).digest("hex")}`;
+}
+
+export { dataSourceKey };

package/dist/chunk-hv2kx47y.js

@@ -0,0 +1,92 @@
+import {
+  buildKubectlArgs
+} from "./chunk-0rs1aacd.js";
+import {
+  sleep,
+  spawnProcess
+} from "./chunk-ztenxgjv.js";
+
+// src/kubernetes/port-forward.ts
+async function startPortForward(opts) {
+  const target = opts.target ?? (opts.service ? { kind: "service", name: opts.service } : undefined);
+  if (!target)
+    return { ok: false, reason: "port-forward 缺少 Service/Pod 目标" };
+  const argv = buildKubectlArgs(opts, [
+    "port-forward",
+    `${target.kind === "service" ? "svc" : "pod"}/${target.name}`,
+    `0:${opts.remotePort}`,
+    "--address",
+    "127.0.0.1"
+  ]);
+  let proc;
+  try {
+    proc = spawnProcess(argv);
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+  const timeoutMs = opts.timeoutMs ?? 15000;
+  const stderrPromise = new Response(proc.stderr).text();
+  const reader = proc.stdout.getReader();
+  const decoder = new TextDecoder;
+  const deadline = Date.now() + timeoutMs;
+  let out = "";
+  for (;; ) {
+    const remain = deadline - Date.now();
+    if (remain <= 0)
+      break;
+    const chunk = await Promise.race([
+      reader.read(),
+      sleep(remain).then(() => "timeout"),
+      proc.exited.then(() => "exited").catch((error) => ({ error }))
+    ]);
+    if (chunk === "timeout")
+      break;
+    if (typeof chunk === "object" && "error" in chunk) {
+      proc.kill();
+      return { ok: false, reason: chunk.error instanceof Error ? chunk.error.message : String(chunk.error) };
+    }
+    if (chunk === "exited" || chunk.done)
+      break;
+    out += decoder.decode(chunk.value);
+    const m = out.match(/Forwarding from 127\.0\.0\.1:(\d+)/);
+    if (m) {
+      return {
+        ok: true,
+        value: { target, localPort: Number(m[1]), command: argv, stop: () => proc.kill() }
+      };
+    }
+  }
+  proc.kill();
+  const stderr = await stderrPromise.catch(() => "");
+  const reason = stderr.trim().split(`
+`)[0] || `port-forward 未就绪（${timeoutMs}ms 超时）`;
+  return { ok: false, reason };
+}
+
+class PortForwardScope {
+  starter;
+  #forwards = [];
+  #stopOnExit = () => this.stop();
+  constructor(starter = startPortForward) {
+    this.starter = starter;
+  }
+  get active() {
+    return this.#forwards;
+  }
+  async start(opts) {
+    const result = await this.starter(opts);
+    if (result.value) {
+      if (this.#forwards.length === 0)
+        process.once("exit", this.#stopOnExit);
+      this.#forwards.push(result.value);
+    }
+    return result;
+  }
+  stop() {
+    process.off("exit", this.#stopOnExit);
+    for (const forward of this.#forwards.splice(0).reverse())
+      forward.stop();
+  }
+}
+
+export { startPortForward, PortForwardScope };

package/dist/chunk-j46x7j7c.js

@@ -0,0 +1,73 @@
+import {
+  parsePods
+} from "./chunk-6fnhzhdb.js";
+
+// src/kubernetes/service.ts
+function parseList(raw) {
+  const value = JSON.parse(raw);
+  return value.items ?? [];
+}
+function parseServices(raw, defaultNamespace) {
+  return parseList(raw).flatMap((item) => {
+    const name = item.metadata?.name;
+    if (!name)
+      return [];
+    const ports = (item.spec?.ports ?? []).flatMap((port) => Number.isInteger(port.port) ? [{ name: port.name, port: port.port, targetPort: port.targetPort }] : []);
+    return [{
+      kind: "service",
+      namespace: item.metadata?.namespace ?? defaultNamespace,
+      name,
+      clusterIP: item.spec?.clusterIP,
+      selector: item.spec?.selector ?? {},
+      ports
+    }];
+  });
+}
+function serviceIdentity(host, defaultNamespace) {
+  const labels = host.replace(/\.$/, "").split(".");
+  if (labels.length === 1)
+    return { name: labels[0], namespace: defaultNamespace };
+  if (labels.length === 2)
+    return { name: labels[0], namespace: labels[1] };
+  if (labels.length >= 3 && labels[2] === "svc") {
+    return { name: labels[0], namespace: labels[1] };
+  }
+  return;
+}
+function findService(services, endpoint, defaultNamespace) {
+  const identity = serviceIdentity(endpoint.host, defaultNamespace);
+  return services.find((service) => (identity ? service.name === identity.name && service.namespace === identity.namespace : service.clusterIP === endpoint.host) && service.ports.some((port) => port.port === endpoint.port));
+}
+function findServicesForPod(services, pod) {
+  return services.filter((service) => {
+    const selector = Object.entries(service.selector);
+    return service.namespace === pod.namespace && selector.length > 0 && selector.every(([name, value]) => pod.labels[name] === value);
+  });
+}
+function findPodsForService(services, pods, serviceName, namespace) {
+  const service = services.find((item) => item.name === serviceName && item.namespace === namespace);
+  if (!service)
+    return [];
+  const selector = Object.entries(service.selector);
+  if (!selector.length)
+    return [];
+  return pods.filter((pod) => pod.namespace === namespace && pod.phase === "Running" && selector.every(([name, value]) => pod.labels[name] === value)).sort((left, right) => left.name.localeCompare(right.name));
+}
+async function listServiceNetwork(executor, namespace) {
+  const [serviceResult, podResult] = await Promise.all([
+    executor.run(["get", "services", "-o", "json"], { timeoutMs: 20000 }),
+    executor.run(["get", "pods", "-o", "json"], { timeoutMs: 20000 })
+  ]);
+  if (!serviceResult.ok) {
+    throw new Error(`读取 Service 失败：${serviceResult.stderr.trim() || `exit=${serviceResult.exitCode}`}`);
+  }
+  if (!podResult.ok) {
+    throw new Error(`读取 Pod 网络信息失败：${podResult.stderr.trim() || `exit=${podResult.exitCode}`}`);
+  }
+  return {
+    services: parseServices(serviceResult.stdout, namespace),
+    pods: parsePods(podResult.stdout, namespace)
+  };
+}
+
+export { parseServices, serviceIdentity, findService, findServicesForPod, findPodsForService, listServiceNetwork };