@autter/runtime-node 1.3.4 → 1.5.0

package/dist/chunk-ZS4WQJQR.js

@@ -0,0 +1,202 @@
+import {
+  COMPAT_MANIFEST,
+  SDK_IDENTITY,
+  compatRequest,
+  evaluateCompat,
+  fetchIngesterCompat,
+  versionAtLeast
+} from "./chunk-L7HWKMCZ.js";
+
+// src/doctor.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+var SDK_PACKAGES = ["@autter/runtime-node", "@autter/runtime-next", "@autter/runtime-browser"];
+var DEFAULT_ENDPOINT = "https://otlp.autter.dev";
+function resolveEndpoint(flag, env = process.env) {
+  return (flag || env.AUTTER_ENDPOINT || env.AUTTER_RUNTIME_ENDPOINT || env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_ENDPOINT).replace(/\/$/, "");
+}
+function installedSdks(cwd) {
+  const found = /* @__PURE__ */ new Map();
+  for (let dir = cwd; ; dir = dirname(dir)) {
+    for (const name of SDK_PACKAGES) {
+      if (found.has(name)) continue;
+      const file = join(dir, "node_modules", ...name.split("/"), "package.json");
+      if (!existsSync(file)) continue;
+      try {
+        const version = JSON.parse(readFileSync(file, "utf8")).version;
+        if (typeof version === "string") found.set(name, version);
+      } catch {
+      }
+    }
+    if (dirname(dir) === dir) break;
+  }
+  if (!found.has(SDK_IDENTITY.name)) found.set(SDK_IDENTITY.name, SDK_IDENTITY.version);
+  return [...found].map(([name, version]) => ({ name, version }));
+}
+function featuresInUse(sdks) {
+  return COMPAT_MANIFEST.features.filter(
+    (feature) => sdks.some((sdk) => {
+      const min = feature.sdks[sdk.name];
+      return min !== void 0 && versionAtLeast(sdk.version, min) === true;
+    })
+  ).map((feature) => feature.id);
+}
+async function checkKey(endpoint, key, timeoutMs) {
+  const res = await compatRequest("POST", `${endpoint}/v1/traces`, {
+    body: JSON.stringify({ resourceSpans: [] }),
+    headers: { authorization: `Bearer ${key}` },
+    unref: false,
+    timeoutMs
+  });
+  if (!res) return "unknown";
+  if (res.status >= 200 && res.status < 300) return "accepted";
+  if (res.status === 401) return "rejected";
+  if (res.status === 403) return "client_key";
+  if (res.status === 503) return "storage_unavailable";
+  return "unknown";
+}
+async function runDoctor(options = {}) {
+  const endpoint = resolveEndpoint(options.endpoint);
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const sdks = installedSdks(options.cwd ?? process.cwd());
+  const features = options.features?.length ? options.features : featuresInUse(sdks);
+  const routes = [
+    ...new Set(
+      features.map((id) => COMPAT_MANIFEST.features.find((f) => f.id === id)?.route).filter((route) => Boolean(route))
+    )
+  ];
+  const { info, error } = await fetchIngesterCompat(endpoint, { probeRoutes: routes, unref: false, timeoutMs });
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (issue) => {
+    const key2 = `${issue.feature}:${issue.kind}:${issue.component}`;
+    if (!seen.has(key2)) {
+      seen.add(key2);
+      issues.push(issue);
+    }
+  };
+  evaluateCompat({ features, ingester: info }).forEach(add);
+  for (const sdk of sdks) {
+    if (options.features?.length) {
+      evaluateCompat({ features: options.features, ingester: null, sdk }).forEach(add);
+    }
+  }
+  const key = options.key ? await checkKey(endpoint, options.key, timeoutMs) : void 0;
+  const featureRows = features.flatMap((id) => {
+    const feature = COMPAT_MANIFEST.features.find((f) => f.id === id);
+    if (!feature) return [];
+    const bad = issues.some((issue) => issue.feature === id);
+    const known = info?.version != null || feature.route !== void 0 && info?.routes?.[feature.route] !== void 0;
+    return [{ id, title: feature.title, status: bad ? "incompatible" : known ? "ok" : "unknown" }];
+  });
+  const exitCode = !info ? 2 : issues.length || key === "rejected" || key === "client_key" || key === "storage_unavailable" ? 1 : 0;
+  return {
+    endpoint,
+    sdks,
+    ingester: info,
+    ...error && !info ? { ingesterError: error } : {},
+    ...key ? { key } : {},
+    features: featureRows,
+    issues,
+    exitCode
+  };
+}
+function formatDoctorReport(report) {
+  const lines = [];
+  lines.push(`Autter Runtime doctor`);
+  lines.push(`  endpoint   ${report.endpoint}`);
+  for (const sdk of report.sdks) lines.push(`  sdk        ${sdk.name}@${sdk.version}`);
+  if (!report.ingester) {
+    lines.push(`  ingester   unreachable or unidentified (${report.ingesterError ?? "unknown error"})`);
+  } else if (report.ingester.version) {
+    lines.push(`  ingester   @autter/otlp-ingester@${report.ingester.version}`);
+    const schema = report.ingester.schema;
+    if (schema) {
+      lines.push(
+        `  schema     ${schema.status}${schema.applied.length ? ` (level ${schema.applied[schema.applied.length - 1]})` : ""}`
+      );
+    }
+  } else {
+    lines.push(`  ingester   1.4.0 or older (no /v1/compat endpoint; upgrade for a full report)`);
+  }
+  if (report.key) {
+    const text = {
+      accepted: "accepted",
+      rejected: "REJECTED (401): check AUTTER_RUNTIME_KEY",
+      client_key: "is a client/browser key; server SDKs need a server key",
+      storage_unavailable: "accepted, but the ingester's ClickHouse is unavailable (503)",
+      unknown: "could not be verified"
+    }[report.key];
+    lines.push(`  key        ${text}`);
+  }
+  if (report.features.length) {
+    lines.push("", "Features");
+    for (const feature of report.features) {
+      const mark = feature.status === "ok" ? "ok  " : feature.status === "incompatible" ? "FAIL" : "??  ";
+      lines.push(`  ${mark} ${feature.title} (${feature.id})`);
+    }
+  }
+  if (report.issues.length) {
+    lines.push("", "Problems");
+    for (const issue of report.issues) lines.push(`  - ${issue.message}`);
+  }
+  lines.push(
+    "",
+    report.exitCode === 0 ? "Compatible." : report.exitCode === 1 ? "Incompatible: see the problems above." : "Could not check the ingester. Pass --endpoint <url> (or set AUTTER_ENDPOINT)."
+  );
+  return lines.join("\n");
+}
+var DOCTOR_USAGE = `Usage: npx @autter/runtime-node doctor [options]
+
+Checks that your Autter SDKs, ingester and ClickHouse schema versions match.
+
+Options:
+  --endpoint <url>    Ingester base URL (default: $AUTTER_ENDPOINT, $OTEL_EXPORTER_OTLP_ENDPOINT, or ${DEFAULT_ENDPOINT})
+  --key <key>         Also verify an ingest key (default: $AUTTER_RUNTIME_KEY)
+  --features <a,b>    Only check these features (${COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
+  --json              Machine-readable output
+  --timeout <ms>      Per-request timeout (default 5000)
+
+Exit codes: 0 compatible, 1 mismatch or rejected key, 2 ingester unreachable.`;
+function parseDoctorArgs(argv, env = process.env) {
+  const options = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const [flag, inline] = arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, void 0];
+    const value = () => inline ?? argv[++i];
+    switch (flag) {
+      case "-h":
+      case "--help":
+        return { help: true };
+      case "--endpoint":
+        options.endpoint = value();
+        break;
+      case "--key":
+        options.key = value();
+        break;
+      case "--features":
+        options.features = (value() ?? "").split(",").map((f) => f.trim()).filter(Boolean);
+        break;
+      case "--json":
+        options.json = true;
+        break;
+      case "--timeout": {
+        const ms = Number(value());
+        if (!Number.isFinite(ms) || ms <= 0) return { error: "--timeout needs a positive number of ms" };
+        options.timeoutMs = ms;
+        break;
+      }
+      default:
+        return { error: `unknown option ${arg}` };
+    }
+  }
+  if (!options.key && env.AUTTER_RUNTIME_KEY) options.key = env.AUTTER_RUNTIME_KEY;
+  return options;
+}
+
+export {
+  runDoctor,
+  formatDoctorReport,
+  DOCTOR_USAGE,
+  parseDoctorArgs
+};

package/dist/cli.cjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+"use strict";
+
+
+
+
+var _chunkL6SRL65Jcjs = require('./chunk-L6SRL65J.cjs');
+require('./chunk-GI47WGRR.cjs');
+
+// src/cli.ts
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (command !== "doctor") {
+    console.log(_chunkL6SRL65Jcjs.DOCTOR_USAGE);
+    return command === void 0 || command === "--help" || command === "-h" ? 0 : 64;
+  }
+  const parsed = _chunkL6SRL65Jcjs.parseDoctorArgs.call(void 0, rest);
+  if ("help" in parsed) {
+    console.log(_chunkL6SRL65Jcjs.DOCTOR_USAGE);
+    return 0;
+  }
+  if ("error" in parsed) {
+    console.error(`${parsed.error}
+
+${_chunkL6SRL65Jcjs.DOCTOR_USAGE}`);
+    return 64;
+  }
+  const report = await _chunkL6SRL65Jcjs.runDoctor.call(void 0, parsed);
+  console.log(parsed.json ? JSON.stringify(report, null, 2) : _chunkL6SRL65Jcjs.formatDoctorReport.call(void 0, report));
+  return report.exitCode;
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.error("autter doctor failed:", err instanceof Error ? err.message : err);
+    process.exitCode = 2;
+  }
+);

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import {
+  DOCTOR_USAGE,
+  formatDoctorReport,
+  parseDoctorArgs,
+  runDoctor
+} from "./chunk-ZS4WQJQR.js";
+import "./chunk-L7HWKMCZ.js";
+
+// src/cli.ts
+async function main(argv) {
+  const [command, ...rest] = argv;
+  if (command !== "doctor") {
+    console.log(DOCTOR_USAGE);
+    return command === void 0 || command === "--help" || command === "-h" ? 0 : 64;
+  }
+  const parsed = parseDoctorArgs(rest);
+  if ("help" in parsed) {
+    console.log(DOCTOR_USAGE);
+    return 0;
+  }
+  if ("error" in parsed) {
+    console.error(`${parsed.error}
+
+${DOCTOR_USAGE}`);
+    return 64;
+  }
+  const report = await runDoctor(parsed);
+  console.log(parsed.json ? JSON.stringify(report, null, 2) : formatDoctorReport(report));
+  return report.exitCode;
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.error("autter doctor failed:", err instanceof Error ? err.message : err);
+    process.exitCode = 2;
+  }
+);