@ory/argus 0.14.0 → 1.0.1

package/dist/local/jaeger-main.d.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone entry point for managing the dev-launcher Jaeger container.
- *
- * Used by root package.json scripts:
- *   pnpm jaeger:up   → node packages/core/dist/local/jaeger-main.js up
- *   pnpm jaeger:down → node packages/core/dist/local/jaeger-main.js down
- *
- * The container started here (`ory-jaeger-dev`) is independent of the
- * Compose-managed Jaeger that ships with `pnpm local:up` (`ory-jaeger`),
- * so they cannot collide.
- */
-export {};

package/dist/local/jaeger-main.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * Standalone entry point for managing the dev-launcher Jaeger container.
- *
- * Used by root package.json scripts:
- *   pnpm jaeger:up   → node packages/core/dist/local/jaeger-main.js up
- *   pnpm jaeger:down → node packages/core/dist/local/jaeger-main.js down
- *
- * The container started here (`ory-jaeger-dev`) is independent of the
- * Compose-managed Jaeger that ships with `pnpm local:up` (`ory-jaeger`),
- * so they cannot collide.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const jaeger_js_1 = require("./jaeger.js");
-async function main() {
-    const subcommand = process.argv[2];
-    switch (subcommand) {
-        case "up": {
-            const result = await (0, jaeger_js_1.ensureDevJaeger)();
-            switch (result.status) {
-                case "already-running":
-                    console.log(`Jaeger is already reachable at ${result.endpoint} (UI: ${result.uiUrl}).`);
-                    break;
-                case "started":
-                    console.log(`Jaeger started in Docker. OTLP endpoint: ${result.endpoint}, UI: ${result.uiUrl}.`);
-                    console.log("Use 'pnpm jaeger:down' to stop it.");
-                    break;
-                case "skipped:no-docker":
-                    console.error(`Could not start Jaeger: ${result.detail}`);
-                    process.exit(1);
-                case "skipped:probe-failed":
-                    console.error(`Jaeger did not become healthy: ${result.detail}`);
-                    process.exit(1);
-                case "error":
-                    console.error(`Jaeger failed to start: ${result.detail}`);
-                    process.exit(1);
-            }
-            break;
-        }
-        case "down": {
-            const result = (0, jaeger_js_1.stopDevJaeger)();
-            switch (result.status) {
-                case "stopped":
-                    console.log("Stopped the dev Jaeger container.");
-                    break;
-                case "not-running":
-                    console.log("No dev Jaeger container is running.");
-                    break;
-                case "skipped:no-docker":
-                    console.error(`Cannot stop Jaeger: ${result.detail}`);
-                    process.exit(1);
-                case "error":
-                    console.error(`Failed to stop Jaeger: ${result.detail}`);
-                    process.exit(1);
-            }
-            break;
-        }
-        case "help":
-        case "--help":
-        case "-h":
-        case undefined:
-            console.log(`
-ory-jaeger — Manage the standalone Jaeger container used by dev launchers
-
-Usage:
-  pnpm jaeger:up      Start a local Jaeger all-in-one container (UI on :16686, OTLP HTTP on :4318)
-  pnpm jaeger:down    Stop and remove the dev Jaeger container
-
-Dev launchers (pnpm dev:<harness>) call 'jaeger up' automatically when no
-OTEL_EXPORTER_OTLP_ENDPOINT is set in the parent shell. Run these manually
-if you want to inspect traces without launching a harness.
-
-Requires Docker.
-`);
-            break;
-        default:
-            console.error(`Unknown subcommand: ${subcommand}`);
-            process.exit(1);
-    }
-}
-main().catch((err) => {
-    console.error(err.message ?? err);
-    process.exit(1);
-});

package/dist/local/jaeger.d.ts

@@ -1,50 +0,0 @@
-/**
- * Standalone Jaeger lifecycle for the dev launcher.
- *
- * Runs Jaeger all-in-one as a single Docker container (no Compose project)
- * so `pnpm dev:<harness>` can ship traces to a local Jaeger UI without
- * spinning up the rest of the local Ory stack.
- *
- * The container is named distinctly from the `local up` Jaeger container
- * (`ory-jaeger`) so the two cannot collide. If `local up` is already running
- * its Jaeger, the OTLP port is bound and `ensureDevJaeger` short-circuits via
- * the reachability probe.
- */
-export declare const DEV_JAEGER_CONTAINER = "jaeger";
-export declare const DEV_JAEGER_IMAGE = "jaegertracing/all-in-one:1";
-export interface EnsureDevJaegerResult {
-    /** OTLP HTTP endpoint to use, or undefined when Jaeger is unavailable. */
-    endpoint?: string;
-    /** UI URL when Jaeger is available. */
-    uiUrl?: string;
-    /** Human-readable status — "running", "started", "skipped:no-docker", "skipped:port-in-use", "error". */
-    status: "already-running" | "started" | "skipped:no-docker" | "skipped:probe-failed" | "error";
-    /** Detail / error message for logging. */
-    detail?: string;
-}
-export interface StopDevJaegerResult {
-    status: "stopped" | "not-running" | "skipped:no-docker" | "error";
-    detail?: string;
-}
-/**
- * Ensure a local Jaeger is reachable on the OTLP HTTP port.
- *
- * Order of operations:
- *   1. Probe `localhost:4318` — return `already-running` when something
- *      already serves it (the `local up` Jaeger, a previous dev-launcher
- *      Jaeger, or any other OTLP collector the user has running).
- *   2. If Docker is unavailable, return `skipped:no-docker`.
- *   3. If our standalone container exists but is stopped, remove it so the
- *      `--rm` flag stays meaningful, then re-run.
- *   4. `docker run` Jaeger all-in-one and wait for the OTLP port to come up.
- */
-export declare function ensureDevJaeger(opts?: {
-    startupTimeoutMs?: number;
-}): Promise<EnsureDevJaegerResult>;
-/**
- * Stop the standalone dev Jaeger container.
- *
- * Idempotent: returns `not-running` when nothing matching is up. Does not
- * touch the `local up` Jaeger (different container name).
- */
-export declare function stopDevJaeger(): StopDevJaegerResult;

package/dist/local/jaeger.js

@@ -1,162 +0,0 @@
-"use strict";
-/**
- * Standalone Jaeger lifecycle for the dev launcher.
- *
- * Runs Jaeger all-in-one as a single Docker container (no Compose project)
- * so `pnpm dev:<harness>` can ship traces to a local Jaeger UI without
- * spinning up the rest of the local Ory stack.
- *
- * The container is named distinctly from the `local up` Jaeger container
- * (`ory-jaeger`) so the two cannot collide. If `local up` is already running
- * its Jaeger, the OTLP port is bound and `ensureDevJaeger` short-circuits via
- * the reachability probe.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEV_JAEGER_IMAGE = exports.DEV_JAEGER_CONTAINER = void 0;
-exports.ensureDevJaeger = ensureDevJaeger;
-exports.stopDevJaeger = stopDevJaeger;
-const node_child_process_1 = require("node:child_process");
-const configs_js_1 = require("./configs.js");
-exports.DEV_JAEGER_CONTAINER = "jaeger";
-exports.DEV_JAEGER_IMAGE = "jaegertracing/all-in-one:1";
-function dockerAvailable() {
-    const result = (0, node_child_process_1.spawnSync)("docker", ["info"], { stdio: "ignore" });
-    return result.status === 0;
-}
-async function isOtlpReachable(timeoutMs = 800) {
-    try {
-        const ctrl = new AbortController();
-        const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-        try {
-            const res = await fetch(`${configs_js_1.JAEGER_OTLP_HTTP_URL}/v1/traces`, {
-                method: "GET",
-                signal: ctrl.signal,
-            });
-            return res.status >= 200 && res.status < 600;
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    catch {
-        return false;
-    }
-}
-function inspectContainer(name) {
-    const result = (0, node_child_process_1.spawnSync)("docker", ["inspect", "--format", "{{.State.Running}}", name], { stdio: ["ignore", "pipe", "ignore"] });
-    if (result.status !== 0) {
-        return { exists: false, running: false };
-    }
-    const out = (result.stdout?.toString() ?? "").trim();
-    return { exists: true, running: out === "true" };
-}
-function startContainer() {
-    // Use --rm so the container is wiped on stop — no stale state between runs.
-    const args = [
-        "run",
-        "-d",
-        "--rm",
-        "--name",
-        exports.DEV_JAEGER_CONTAINER,
-        "-p",
-        `${configs_js_1.JAEGER_UI_PORT}:${configs_js_1.JAEGER_UI_PORT}`,
-        "-p",
-        `${configs_js_1.JAEGER_OTLP_HTTP_PORT}:${configs_js_1.JAEGER_OTLP_HTTP_PORT}`,
-        "-e",
-        "COLLECTOR_OTLP_ENABLED=true",
-        "-e",
-        "LOG_LEVEL=warn",
-        exports.DEV_JAEGER_IMAGE,
-    ];
-    const result = (0, node_child_process_1.spawnSync)("docker", args, { stdio: ["ignore", "ignore", "pipe"] });
-    if (result.status === 0)
-        return { ok: true };
-    const stderr = (result.stderr?.toString() ?? "").trim();
-    return { ok: false, detail: stderr || `docker run exited ${result.status}` };
-}
-async function waitUntilReachable(timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (await isOtlpReachable(500))
-            return true;
-        await new Promise((r) => setTimeout(r, 250));
-    }
-    return false;
-}
-/**
- * Ensure a local Jaeger is reachable on the OTLP HTTP port.
- *
- * Order of operations:
- *   1. Probe `localhost:4318` — return `already-running` when something
- *      already serves it (the `local up` Jaeger, a previous dev-launcher
- *      Jaeger, or any other OTLP collector the user has running).
- *   2. If Docker is unavailable, return `skipped:no-docker`.
- *   3. If our standalone container exists but is stopped, remove it so the
- *      `--rm` flag stays meaningful, then re-run.
- *   4. `docker run` Jaeger all-in-one and wait for the OTLP port to come up.
- */
-async function ensureDevJaeger(opts = {}) {
-    if (await isOtlpReachable()) {
-        return {
-            status: "already-running",
-            endpoint: configs_js_1.JAEGER_OTLP_HTTP_URL,
-            uiUrl: configs_js_1.JAEGER_UI_URL,
-        };
-    }
-    if (!dockerAvailable()) {
-        return {
-            status: "skipped:no-docker",
-            detail: "Docker is not running. Start Docker Desktop to auto-launch Jaeger.",
-        };
-    }
-    const state = inspectContainer(exports.DEV_JAEGER_CONTAINER);
-    if (state.exists && !state.running) {
-        // Stale --rm container could only exist if Docker died mid-run; clean it up.
-        (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", exports.DEV_JAEGER_CONTAINER], { stdio: "ignore" });
-    }
-    const start = startContainer();
-    if (!start.ok) {
-        return { status: "error", detail: start.detail };
-    }
-    const ready = await waitUntilReachable(opts.startupTimeoutMs ?? 15_000);
-    if (!ready) {
-        return {
-            status: "skipped:probe-failed",
-            detail: "Jaeger container started but OTLP port did not respond in time.",
-        };
-    }
-    return {
-        status: "started",
-        endpoint: configs_js_1.JAEGER_OTLP_HTTP_URL,
-        uiUrl: configs_js_1.JAEGER_UI_URL,
-    };
-}
-/**
- * Stop the standalone dev Jaeger container.
- *
- * Idempotent: returns `not-running` when nothing matching is up. Does not
- * touch the `local up` Jaeger (different container name).
- */
-function stopDevJaeger() {
-    if (!dockerAvailable()) {
-        return {
-            status: "skipped:no-docker",
-            detail: "Docker is not running.",
-        };
-    }
-    const state = inspectContainer(exports.DEV_JAEGER_CONTAINER);
-    if (!state.exists) {
-        return { status: "not-running" };
-    }
-    const result = (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", exports.DEV_JAEGER_CONTAINER], {
-        stdio: ["ignore", "ignore", "pipe"],
-    });
-    if (result.status === 0) {
-        return { status: "stopped" };
-    }
-    const stderr = (result.stderr?.toString() ?? "").trim();
-    return {
-        status: "error",
-        detail: stderr || `docker rm exited ${result.status}`,
-    };
-}

package/dist/otel/exporter.d.ts

@@ -1,17 +0,0 @@
-/**
- * Span exporter contract.
- *
- * Implementations ship completed TraceSpan records to an external trace
- * sink (OTLP collector, vendor backend, in-process pipeline, etc.).
- *
- * Exporters must never throw. Transport failures, malformed responses,
- * and shutdown races are all swallowed and logged through whatever
- * channel the implementation chooses.
- */
-import type { TraceSpan } from "../tracer.js";
-export interface SpanExporter {
-    /** Best-effort export of one or more spans. Must never throw. */
-    export(spans: ReadonlyArray<TraceSpan>): Promise<void>;
-    /** Flush any pending state and release resources. Must never throw. */
-    shutdown(): Promise<void>;
-}

package/dist/otel/exporter.js

@@ -1,12 +0,0 @@
-"use strict";
-/**
- * Span exporter contract.
- *
- * Implementations ship completed TraceSpan records to an external trace
- * sink (OTLP collector, vendor backend, in-process pipeline, etc.).
- *
- * Exporters must never throw. Transport failures, malformed responses,
- * and shutdown races are all swallowed and logged through whatever
- * channel the implementation chooses.
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/otel/index.d.ts

@@ -1,2 +0,0 @@
-export type { SpanExporter } from "./exporter.js";
-export { OtlpExporter, otlpExporterFromEnv, parseKeyValueList, toReadableSpan, type OtlpExporterOptions, type OtlpProtocol, } from "./otlp.js";

package/dist/otel/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toReadableSpan = exports.parseKeyValueList = exports.otlpExporterFromEnv = exports.OtlpExporter = void 0;
-var otlp_js_1 = require("./otlp.js");
-Object.defineProperty(exports, "OtlpExporter", { enumerable: true, get: function () { return otlp_js_1.OtlpExporter; } });
-Object.defineProperty(exports, "otlpExporterFromEnv", { enumerable: true, get: function () { return otlp_js_1.otlpExporterFromEnv; } });
-Object.defineProperty(exports, "parseKeyValueList", { enumerable: true, get: function () { return otlp_js_1.parseKeyValueList; } });
-Object.defineProperty(exports, "toReadableSpan", { enumerable: true, get: function () { return otlp_js_1.toReadableSpan; } });

package/dist/otel/otlp.d.ts

@@ -1,103 +0,0 @@
-/**
- * OTLP exporter — SDK-backed.
- *
- * Bridges our internal `TraceSpan` records into the official OpenTelemetry
- * SDK exporters from `@opentelemetry/exporter-trace-otlp-http` and
- * `@opentelemetry/exporter-trace-otlp-proto`. Each completed `TraceSpan`
- * is converted to a `ReadableSpan` shape and handed to the SDK exporter,
- * which serializes (JSON or protobuf) and POSTs to an OTLP HTTP endpoint.
- *
- * Standard OTel env vars consumed by `otlpExporterFromEnv()`. Each one has
- * an `ORY_OTLP_*`-prefixed alias that is consulted as a fallback when the
- * standard name is unset. Some harnesses (notably Claude Code) sanitize the
- * env passed to hook subprocesses and drop every `OTEL_*` var, so the dev
- * launcher mirrors each setting under the Ory prefix to survive the strip.
- *
- *   Standard name                          Ory-prefixed fallback
- *   ─────────────────────────────────────  ─────────────────────────────────
- *   OTEL_EXPORTER_OTLP_ENDPOINT            ORY_OTLP_ENDPOINT
- *   OTEL_EXPORTER_OTLP_TRACES_ENDPOINT     ORY_OTLP_TRACES_ENDPOINT
- *   OTEL_EXPORTER_OTLP_HEADERS             ORY_OTLP_HEADERS
- *   OTEL_EXPORTER_OTLP_TRACES_HEADERS      ORY_OTLP_TRACES_HEADERS
- *   OTEL_EXPORTER_OTLP_PROTOCOL            ORY_OTLP_PROTOCOL
- *   OTEL_EXPORTER_OTLP_TRACES_PROTOCOL     ORY_OTLP_TRACES_PROTOCOL
- *   OTEL_SERVICE_NAME                      ORY_OTLP_SERVICE_NAME
- *   OTEL_RESOURCE_ATTRIBUTES               ORY_OTLP_RESOURCE_ATTRIBUTES
- *
- * Failures are swallowed (callers receive a resolved Promise) so trace
- * export can never break the agent session. Transport errors surface
- * through the `onError` callback.
- */
-import { type AttributeValue } from "@opentelemetry/api";
-import { type Resource } from "@opentelemetry/resources";
-import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
-import type { SpanExporter as SdkSpanExporter } from "@opentelemetry/sdk-trace-base";
-import type { SpanExporter } from "./exporter.js";
-import type { TraceSpan } from "../tracer.js";
-export type OtlpProtocol = "http/json" | "http/protobuf";
-export interface OtlpExporterOptions {
-    /** Full traces endpoint (e.g. `http://localhost:4318/v1/traces`). */
-    endpoint: string;
-    /** Wire protocol. Default: `http/protobuf` (the OTel spec default). */
-    protocol?: OtlpProtocol;
-    /** Additional HTTP headers to send with each request. */
-    headers?: Record<string, string>;
-    /** Resource attributes merged into every export. */
-    resource?: Record<string, AttributeValue>;
-    /** Per-request timeout in milliseconds. Default: 5000. */
-    timeoutMs?: number;
-    /** Optional sink for transport errors. Defaults to a no-op. */
-    onError?: (err: unknown) => void;
-    /**
-     * Inject a custom SDK exporter (used by tests). When provided, supersedes
-     * the protocol selector — the wrapper passes converted ReadableSpans to
-     * this exporter as-is.
-     */
-    sdkExporter?: SdkSpanExporter;
-}
-/**
- * OTLP exporter that delegates wire-format serialization and HTTP transport
- * to the official `@opentelemetry/exporter-trace-otlp-*` SDK exporters.
- */
-export declare class OtlpExporter implements SpanExporter {
-    readonly endpoint: string;
-    readonly protocol: OtlpProtocol;
-    readonly headers: Record<string, string>;
-    readonly resource: Resource;
-    private readonly delegate;
-    private readonly onError;
-    private readonly inFlight;
-    constructor(opts: OtlpExporterOptions);
-    export(spans: ReadonlyArray<TraceSpan>): Promise<void>;
-    shutdown(): Promise<void>;
-}
-/**
- * Build an OtlpExporter from process env. Returns undefined when no
- * endpoint is configured or the requested protocol is unsupported.
- */
-export declare function otlpExporterFromEnv(opts: {
-    harness: string;
-    hostname?: string;
-    user?: string;
-    pluginVersion?: string;
-    cwd?: string;
-    gitBranch?: string;
-    gitCommit?: string;
-    onError?: (err: unknown) => void;
-    env?: NodeJS.ProcessEnv;
-}): OtlpExporter | undefined;
-/**
- * Read an OTel env var, falling back to its `ORY_OTLP_*`-prefixed alias when
- * the standard name is unset. Trims whitespace and treats empty strings as
- * absent so a propagated-but-blank var doesn't shadow the alias.
- */
-export declare function readEnvWithAlias(env: NodeJS.ProcessEnv, standardName: string): string | undefined;
-/**
- * Parse the OTel `k=v,k2=v2` env-var format. Values may be URL-encoded.
- */
-export declare function parseKeyValueList(raw: string | undefined): Record<string, string>;
-/**
- * Convert our internal `TraceSpan` record to an OTel SDK `ReadableSpan`.
- * Exported for tests; the OTLP exporters consume this shape directly.
- */
-export declare function toReadableSpan(span: TraceSpan, resource: Resource): ReadableSpan;