@phosphorco/bb-thread-metrics 0.0.0-stage → 0.2.0

package/dist/bb.js

@@ -0,0 +1,208 @@
+// src/bb.ts
+import { z } from "zod";
+import { RECENT_LIMITS, recentSnapshotInputSchema, validateRecentSnapshot, LIMITS, METHODS, describeInputSchema, describeEnvelopeSchema, capabilitiesSchema, readInputSchema, detailInputSchema, parseBounded, negotiateVersion, validateReadResult, validateDetailResult, classifyOwnerError } from "./index.js";
+function sdkSchema(schema, maxBytes) {
+  return { "~standard": { version: 1, vendor: "bb-thread-metrics", jsonSchema: { input: () => z.toJSONSchema(schema, { io: "input", unrepresentable: "any" }), output: () => z.toJSONSchema(schema, { io: "output", unrepresentable: "any" }) }, validate(value) {
+    try {
+      return { value: maxBytes === undefined ? schema.parse(value) : parseBounded(schema, value, maxBytes) };
+    } catch (e) {
+      return { issues: e instanceof z.ZodError ? e.issues.map((i) => ({ message: i.message, path: i.path })) : [{ message: "Payload byte limit" }] };
+    }
+  } } };
+}
+function registerThreadMetricsOwner(bb, port) {
+  const capabilities = capabilitiesSchema.parse(port.capabilities);
+  if (Boolean(capabilities.recentSnapshotV1) !== Boolean(port.recentSnapshot))
+    throw new Error("Recent snapshot capability/handler mismatch");
+  if (capabilities.detail !== Boolean(port.detail))
+    throw new Error("Detail capability/handler mismatch");
+  const describe = () => ({ protocol: "bb-thread-metrics", versions: [1], capabilities });
+  const contract = {
+    threadMetricsDescribe: { input: sdkSchema(describeInputSchema, LIMITS.inputBytes), output: sdkSchema(z.unknown()) },
+    threadMetricsReadV1: { input: sdkSchema(readInputSchema, LIMITS.inputBytes), output: sdkSchema(z.unknown()) }
+  };
+  const handlers = {
+    threadMetricsDescribe: (raw) => {
+      parseBounded(describeInputSchema, raw, LIMITS.inputBytes);
+      return describe();
+    },
+    threadMetricsReadV1: async (raw) => {
+      const input = parseBounded(readInputSchema, raw, LIMITS.inputBytes);
+      if (input.series && !capabilities.series)
+        throw new Error("Series not supported");
+      return validateReadResult(input, await port.read(input));
+    }
+  };
+  bb.rpc.register(contract, handlers, { experimental_discoverable: true });
+  if (port.recentSnapshot)
+    bb.rpc.register({ threadMetricsRecentSnapshotV1: { input: sdkSchema(recentSnapshotInputSchema, RECENT_LIMITS.inputBytes), output: sdkSchema(z.unknown()) } }, { threadMetricsRecentSnapshotV1: async (raw) => {
+      const input = parseBounded(recentSnapshotInputSchema, raw, RECENT_LIMITS.inputBytes);
+      return validateRecentSnapshot(input, await port.recentSnapshot(input));
+    } }, { experimental_discoverable: true });
+  if (port.detail)
+    bb.rpc.register({ threadMetricsDetailV1: { input: sdkSchema(detailInputSchema, LIMITS.inputBytes), output: sdkSchema(z.unknown()) } }, { threadMetricsDetailV1: async (raw) => {
+      const input = parseBounded(detailInputSchema, raw, LIMITS.inputBytes);
+      return validateDetailResult(input, await port.detail(input));
+    } }, { experimental_discoverable: true });
+}
+function createThreadMetricsClient(sdk, pluginId) {
+  if (!pluginId || pluginId.length > 200)
+    throw new Error("Invalid target plugin id");
+  async function call(method, input, signal) {
+    return sdk.plugins.callRpc({ pluginId, method, input, outputSchema: z.unknown(), ...signal ? { signal } : {} });
+  }
+  return {
+    pluginId,
+    async describe(signal) {
+      const raw = await call(METHODS.describe, {}, signal);
+      return negotiateVersion(parseBounded(describeEnvelopeSchema, raw, LIMITS.describeBytes));
+    },
+    async recentSnapshot(raw = {}, signal) {
+      const input = parseBounded(recentSnapshotInputSchema, raw, RECENT_LIMITS.inputBytes);
+      return validateRecentSnapshot(input, await call(METHODS.recentSnapshot, input, signal));
+    },
+    async read(raw, signal) {
+      const input = parseBounded(readInputSchema, raw, LIMITS.inputBytes);
+      return validateReadResult(input, await call(METHODS.read, input, signal));
+    },
+    async detail(raw, signal) {
+      const input = parseBounded(detailInputSchema, raw, LIMITS.inputBytes);
+      return validateDetailResult(input, await call(METHODS.detail, input, signal));
+    }
+  };
+}
+async function discoverThreadMetricsOwners(options) {
+  const bounded = (v, max) => {
+    const n = v ?? max;
+    if (!Number.isInteger(n) || n < 1 || n > max)
+      throw new Error("Invalid discovery budget");
+    return n;
+  };
+  const count = bounded(options.maxCandidates, LIMITS.candidates), concurrency = bounded(options.concurrency, LIMITS.concurrency), callMs = bounded(options.callMs, LIMITS.callMs), deadlineMs = bounded(options.deadlineMs, LIMITS.discoveryMs);
+  const pass = new AbortController, rows = new Map, active = new Map;
+  let done = false, ending = false, listedReady = false, omittedCount = 0, eligibleCount = 0, started = 0;
+  const timers = new Set;
+  let finish;
+  const result = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const publish = (row) => {
+    if (done)
+      return;
+    rows.set(row.pluginId, row);
+    try {
+      options.onRow?.(row);
+    } catch {}
+  };
+  const end = (complete, listError) => {
+    if (done || ending)
+      return;
+    ending = true;
+    for (const [pluginId] of active)
+      if (!rows.has(pluginId))
+        publish({ pluginId, state: "error", error: options.signal?.aborted ? "aborted" : "timeout" });
+    done = true;
+    pass.abort();
+    for (const c of active.values())
+      c.abort();
+    for (const t of timers)
+      clearTimeout(t);
+    timers.clear();
+    options.signal?.removeEventListener("abort", abort);
+    finish({ rows: [...rows.values()], omittedCount: omittedCount + Math.max(0, eligibleCount - started), complete, ...listError ? { listError } : {} });
+  };
+  const abort = () => end(false, "aborted");
+  options.signal?.addEventListener("abort", abort, { once: true });
+  if (options.signal?.aborted) {
+    abort();
+    return result;
+  }
+  const deadline = setTimeout(() => end(false, listedReady ? undefined : "timeout"), deadlineMs);
+  timers.add(deadline);
+  (async () => {
+    let listed;
+    try {
+      listed = await options.sdk.plugins.list({ signal: pass.signal });
+    } catch (e) {
+      end(false, classifyOwnerError(e));
+      return;
+    }
+    if (done)
+      return;
+    listedReady = true;
+    const unique = new Map;
+    for (const p of listed.plugins.slice(0, LIMITS.listedPlugins))
+      if (p.id.length <= 200 && (p.status === "running" || p.status === "degraded"))
+        unique.set(p.id, p);
+    const candidates = [...unique.values()].slice(0, count);
+    omittedCount = unique.size - candidates.length + Math.max(0, listed.plugins.length - LIMITS.listedPlugins);
+    eligibleCount = candidates.length;
+    let index = 0;
+    async function worker() {
+      while (!done && index < candidates.length) {
+        const p = candidates[index++];
+        started++;
+        const control = new AbortController;
+        active.set(p.id, control);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+          timedOut = true;
+          control.abort();
+          publish({ pluginId: p.id, state: "error", error: "timeout" });
+        }, callMs);
+        timers.add(timer);
+        try {
+          const negotiated = await createThreadMetricsClient(options.sdk, p.id).describe(control.signal);
+          if (!timedOut && !done)
+            publish(negotiated.kind === "ready" ? { pluginId: p.id, state: "ready", version: 1, capabilities: negotiated.capabilities } : { pluginId: p.id, state: "incompatible" });
+        } catch (e) {
+          if (!timedOut && !done)
+            publish({ pluginId: p.id, state: "error", error: classifyOwnerError(e) });
+        } finally {
+          clearTimeout(timer);
+          timers.delete(timer);
+          active.delete(p.id);
+        }
+      }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, candidates.length) }, () => worker()));
+    if (!done)
+      end(omittedCount === 0);
+  })().catch(() => end(false, "failed"));
+  return result;
+}
+function createThreadMetricsDiscovery(sdk) {
+  let running = false, outstanding = 0;
+  async function track(fn) {
+    outstanding++;
+    try {
+      return await fn();
+    } finally {
+      outstanding--;
+    }
+  }
+  const admitted = { plugins: {
+    list: (args) => track(() => sdk.plugins.list(args)),
+    callRpc: (args) => track(() => sdk.plugins.callRpc(args))
+  } };
+  return {
+    get outstandingReads() {
+      return outstanding;
+    },
+    async discover(options = {}) {
+      if (running || outstanding > 0)
+        return { rows: [], omittedCount: 0, complete: false, listError: "busy" };
+      running = true;
+      try {
+        return await discoverThreadMetricsOwners({ ...options, sdk: admitted });
+      } finally {
+        running = false;
+      }
+    }
+  };
+}
+export {
+  registerThreadMetricsOwner,
+  createThreadMetricsDiscovery,
+  createThreadMetricsClient
+};