@thotischner/observability-mcp 1.8.1 → 3.0.1

package/dist/connectors/interface.d.ts

@@ -1,4 +1,4 @@
-import type { SignalType, ConnectorHealth, ServiceInfo, MetricInfo, MetricQuery, MetricResult, LogQuery, LogResult, SourceConfig, MetricDefinition, Resource, Edge, TopologySnapshot, TopologyChangeListener } from "../types.js";
+import type { SignalType, ConnectorHealth, ServiceInfo, MetricInfo, MetricQuery, MetricResult, LogQuery, LogResult, TraceQuery, TraceResult, SourceConfig, MetricDefinition, Resource, Edge, TopologySnapshot, TopologyChangeListener } from "../types.js";
 export interface ObservabilityConnector {
     readonly name: string;
     readonly type: string;
@@ -14,6 +14,10 @@ export interface ObservabilityConnector {
     listAvailableMetrics?(service: string): Promise<MetricInfo[]>;
     queryMetrics?(params: MetricQuery): Promise<MetricResult>;
     queryLogs?(params: LogQuery): Promise<LogResult>;
+    /** Optional traces capability — Tempo / Jaeger / OTLP backends
+     *  implement this. The MCP `query_traces` tool fans out to every
+     *  connector that has it. */
+    queryTraces?(params: TraceQuery): Promise<TraceResult>;
     /** Current in-memory resource list. Should be O(1) — backed by the watch cache. */
     listResources?(): Promise<Resource[]>;
     /** Current in-memory edge list. Should be O(1) — backed by the watch cache. */

package/dist/connectors/loader.d.ts

@@ -1,5 +1,6 @@
 import type { ObservabilityConnector } from "./interface.js";
 import type { ConnectorFactory, ConnectorManifest } from "../sdk/index.js";
+import type { HookRegistry } from "../sdk/hooks.js";
 export interface LoadedConnector {
     /** Connector type id, e.g. "prometheus". Matches `source.type` in sources.yaml. */
     name: string;
@@ -26,11 +27,18 @@ export declare class PluginLoader {
     private verify;
     private trustRootPath?;
     private trustRoot?;
+    /** Optional HookRegistry — when set, the loader auto-registers
+     *  every entry in `manifest.hooks[]` after the plugin loads, and
+     *  unregisters them when a same-name plugin replaces it. Hooks
+     *  re-registered by name+kind on hot-reload (HookRegistry.register
+     *  already deduplicates). */
+    private hookRegistry?;
     constructor(opts?: {
         pluginsDir?: string;
         disabled?: string[];
         verify?: boolean;
         trustRoot?: string;
+        hookRegistry?: HookRegistry;
     });
     load(): Promise<void>;
     list(): LoadedConnector[];

package/dist/connectors/loader.js

@@ -23,23 +23,32 @@ export class PluginLoader {
     pluginsDir;
     disabled;
     // Fail-closed verification for filesystem plugins. Builtins are part
-    // of the trusted image and are never gated. Default off so existing
-    // deployments are unchanged; recommended on in prod/airgapped (the
-    // Helm chart sets it).
+    // of the trusted image and are never gated. Default ON — operators
+    // who want to load unsigned filesystem plugins must opt out with
+    // VERIFY_PLUGINS=false. Without a trust root configured, no
+    // filesystem plugins load (only builtins), so the demo and any
+    // deployment without /app/plugins is unaffected.
     verify;
     trustRootPath;
     trustRoot;
+    /** Optional HookRegistry — when set, the loader auto-registers
+     *  every entry in `manifest.hooks[]` after the plugin loads, and
+     *  unregisters them when a same-name plugin replaces it. Hooks
+     *  re-registered by name+kind on hot-reload (HookRegistry.register
+     *  already deduplicates). */
+    hookRegistry;
     constructor(opts = {}) {
         this.pluginsDir = opts.pluginsDir
             ?? process.env.PLUGINS_DIR
             ?? "/app/plugins";
+        this.hookRegistry = opts.hookRegistry;
         // Per-plugin disable via env: PLUGINS_DISABLED="prometheus,loki"
         const envDisabled = (process.env.PLUGINS_DISABLED ?? "")
             .split(",")
             .map((s) => s.trim())
             .filter(Boolean);
         this.disabled = new Set([...(opts.disabled ?? []), ...envDisabled]);
-        this.verify = opts.verify ?? /^(1|true|yes)$/i.test(process.env.VERIFY_PLUGINS ?? "");
+        this.verify = opts.verify ?? !/^(0|false|no|off)$/i.test(process.env.VERIFY_PLUGINS ?? "true");
         this.trustRootPath = opts.trustRoot ?? process.env.PLUGIN_TRUST_ROOT;
     }
     async load() {
@@ -200,6 +209,48 @@ export class PluginLoader {
             manifest,
             factory,
         });
+        // Manifest-driven hook auto-registration (Q10). After the
+        // entry module loads (and is integrity/sig-verified above), walk
+        // manifest.hooks[] and resolve each entry's `module` against the
+        // plugin root. Default export is the handler. Errors during
+        // individual hook load are logged + skipped — they don't tear
+        // down the connector itself.
+        if (this.hookRegistry && manifest?.hooks?.length) {
+            // Drop any prior registrations for this plugin so a hot-reload
+            // doesn't leave stale entries side-by-side with new ones.
+            this.hookRegistry.unregisterPlugin(marker.name);
+            for (const hookEntry of manifest.hooks) {
+                const hookPath = resolve(pluginRoot, hookEntry.module);
+                const inside = hookPath.startsWith(resolve(pluginRoot) + "/") || hookPath === resolve(pluginRoot);
+                if (!inside) {
+                    console.warn("Plugin %s hook module %s escapes the plugin root — skipping", sanitizeForLog(marker.name), sanitizeForLog(hookEntry.module));
+                    continue;
+                }
+                if (!existsSync(hookPath)) {
+                    console.warn("Plugin %s hook module %s not found — skipping", sanitizeForLog(marker.name), sanitizeForLog(hookEntry.module));
+                    continue;
+                }
+                try {
+                    const hookMod = await import(pathToFileURL(hookPath).href);
+                    const handler = hookMod.default ?? hookMod.handler;
+                    if (typeof handler !== "function") {
+                        console.warn("Plugin %s hook module %s has no default export — skipping", sanitizeForLog(marker.name), sanitizeForLog(hookEntry.module));
+                        continue;
+                    }
+                    this.hookRegistry.register({
+                        pluginName: marker.name,
+                        kind: hookEntry.kind,
+                        priority: hookEntry.priority,
+                        mode: hookEntry.mode,
+                        handler: handler,
+                    });
+                    console.log('Plugin "%s": registered %s hook from %s', sanitizeForLog(marker.name), sanitizeForLog(hookEntry.kind), sanitizeForLog(hookEntry.module));
+                }
+                catch (err) {
+                    console.warn("Plugin %s hook %s/%s failed to load: %s", sanitizeForLog(marker.name), sanitizeForLog(hookEntry.kind), sanitizeForLog(hookEntry.module), sanitizeForLog(err instanceof Error ? err.message : String(err)));
+                }
+            }
+        }
         console.log('Connector plugin "%s" loaded from %s', sanitizeForLog(marker.name), sanitizeForLog(pluginRoot));
     }
     register(entry) {

package/dist/connectors/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/connectors/loader.test.js

@@ -0,0 +1,78 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PluginLoader } from "./loader.js";
+function tmp() {
+    return mkdtempSync(join(tmpdir(), "loader-default-"));
+}
+function withEnv(overrides, fn) {
+    const saved = {};
+    for (const k of Object.keys(overrides)) {
+        saved[k] = process.env[k];
+        if (overrides[k] === undefined)
+            delete process.env[k];
+        else
+            process.env[k] = overrides[k];
+    }
+    try {
+        fn();
+    }
+    finally {
+        for (const k of Object.keys(saved)) {
+            if (saved[k] === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = saved[k];
+        }
+    }
+}
+test("PluginLoader: VERIFY_PLUGINS defaults to ON when env var unset", () => {
+    withEnv({ VERIFY_PLUGINS: undefined, PLUGIN_TRUST_ROOT: undefined }, () => {
+        const loader = new PluginLoader({ pluginsDir: tmp() });
+        assert.equal(loader["verify"], true, "verify default should be true (fail-closed)");
+    });
+});
+test("PluginLoader: VERIFY_PLUGINS=false opts out explicitly", () => {
+    withEnv({ VERIFY_PLUGINS: "false" }, () => {
+        const loader = new PluginLoader({ pluginsDir: tmp() });
+        assert.equal(loader["verify"], false);
+    });
+});
+test("PluginLoader: VERIFY_PLUGINS=0 / no / off also opt out", () => {
+    for (const v of ["0", "no", "off", "FALSE", "Off"]) {
+        withEnv({ VERIFY_PLUGINS: v }, () => {
+            const loader = new PluginLoader({ pluginsDir: tmp() });
+            assert.equal(loader["verify"], false, `value ${v} should disable verify`);
+        });
+    }
+});
+test("PluginLoader: VERIFY_PLUGINS=true / 1 / yes keep verify on", () => {
+    for (const v of ["true", "1", "yes", "TRUE", "Yes"]) {
+        withEnv({ VERIFY_PLUGINS: v }, () => {
+            const loader = new PluginLoader({ pluginsDir: tmp() });
+            assert.equal(loader["verify"], true);
+        });
+    }
+});
+test("PluginLoader: opts.verify overrides env var", () => {
+    withEnv({ VERIFY_PLUGINS: "false" }, () => {
+        const onLoader = new PluginLoader({ pluginsDir: tmp(), verify: true });
+        assert.equal(onLoader["verify"], true);
+    });
+    withEnv({ VERIFY_PLUGINS: "true" }, () => {
+        const offLoader = new PluginLoader({ pluginsDir: tmp(), verify: false });
+        assert.equal(offLoader["verify"], false);
+    });
+});
+test("PluginLoader.load(): with verify on + no trust root → builtins still load, filesystem skipped", async () => {
+    withEnv({ VERIFY_PLUGINS: undefined, PLUGIN_TRUST_ROOT: undefined }, async () => {
+        const loader = new PluginLoader({ pluginsDir: tmp() });
+        await loader.load();
+        const names = loader.supportedTypes();
+        assert.ok(names.includes("prometheus"), "prometheus builtin must remain available");
+        assert.ok(names.includes("loki"), "loki builtin must remain available");
+        assert.ok(names.includes("kubernetes"), "kubernetes builtin must remain available");
+    });
+});

package/dist/connectors/manifest-hooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/connectors/manifest-hooks.test.js

@@ -0,0 +1,206 @@
+// Manifest-driven hook auto-registration (Q10).
+//
+// Stages a synthetic plugin directory with:
+//   - package.json + manifest.json declaring hooks[]
+//   - index.js exporting a no-op connector factory
+//   - hooks/<kind>.js modules exporting handler defaults
+// Runs PluginLoader (with VERIFY_PLUGINS off — we test the
+// hook wiring, not the trust-root path) and asserts the
+// HookRegistry now has the entries the manifest declared.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PluginLoader } from "./loader.js";
+import { HookRegistry } from "../sdk/hooks.js";
+function stagePlugin(opts) {
+    const stage = mkdtempSync(join(tmpdir(), "omcp-plugin-hooks-"));
+    const root = join(stage, opts.name);
+    mkdirSync(root, { recursive: true });
+    writeFileSync(join(root, "package.json"), JSON.stringify({
+        name: `@observability-mcp/connector-${opts.name}`,
+        observabilityMcp: { kind: "connector", name: opts.name, manifest: "./manifest.json" },
+        main: "./index.js",
+    }));
+    writeFileSync(join(root, "manifest.json"), JSON.stringify({
+        schemaVersion: 1,
+        name: opts.name,
+        displayName: opts.name,
+        version: "1.0.0",
+        description: "test plugin",
+        signalTypes: ["topology"],
+        capabilities: { listServices: true },
+        compat: { serverVersion: ">=3.0.0" },
+        hooks: opts.hooks?.map((h) => ({
+            kind: h.kind,
+            module: h.module,
+            priority: h.priority,
+            mode: h.mode,
+        })),
+    }));
+    // Tiny no-op connector factory.
+    writeFileSync(join(root, "index.js"), opts.indexJs ??
+        `export default function create() {
+        return {
+          type: "${opts.name}",
+          signalType: "topology",
+          name: "${opts.name}",
+          async connect() {},
+          async healthCheck() { return { status: "down", latencyMs: 0 }; },
+          async disconnect() {},
+          getDefaultMetrics() { return []; },
+          getMetrics() { return []; },
+          async listServices() { return []; },
+        };
+      }`);
+    // Hook modules — each writes a marker into the global for assertions.
+    for (const h of opts.hooks ?? []) {
+        const hookPath = join(root, h.module);
+        mkdirSync(join(hookPath, ".."), { recursive: true });
+        writeFileSync(hookPath, h.body ??
+            `export default async function handler(ctx, payload) {
+          globalThis.__omcp_test_hook_calls = (globalThis.__omcp_test_hook_calls ?? []);
+          globalThis.__omcp_test_hook_calls.push({ plugin: ctx.principal, kind: ctx.kind, target: ctx.target });
+          return { allow: true, payload };
+        }`);
+    }
+    return stage;
+}
+test("PluginLoader: manifest hooks auto-register on plugin load", async () => {
+    const stage = stagePlugin({
+        name: "alpha",
+        hooks: [
+            { kind: "tool_pre_invoke", module: "hooks/pre.mjs", priority: 50 },
+            { kind: "tool_post_invoke", module: "hooks/post.mjs" },
+        ],
+    });
+    const registry = new HookRegistry();
+    const loader = new PluginLoader({
+        pluginsDir: stage,
+        verify: false,
+        hookRegistry: registry,
+    });
+    await loader.load();
+    const pre = registry.list("tool_pre_invoke");
+    const post = registry.list("tool_post_invoke");
+    assert.equal(pre.length, 1);
+    assert.equal(pre[0].pluginName, "alpha");
+    assert.equal(pre[0].priority, 50);
+    assert.equal(post.length, 1);
+    assert.equal(post[0].pluginName, "alpha");
+    assert.equal(post[0].priority, 100); // default
+});
+test("PluginLoader: hook handlers fire end-to-end through HookRegistry", async () => {
+    delete globalThis.__omcp_test_hook_calls;
+    const stage = stagePlugin({
+        name: "beta",
+        hooks: [{ kind: "tool_pre_invoke", module: "hooks/pre.mjs" }],
+    });
+    const registry = new HookRegistry();
+    const loader = new PluginLoader({ pluginsDir: stage, verify: false, hookRegistry: registry });
+    await loader.load();
+    const result = await registry.fire("tool_pre_invoke", { principal: "alice", tenant: "default", kind: "tool_pre_invoke", target: "tool.x" }, { args: { foo: 1 } });
+    assert.equal(result.allow, true);
+    const calls = globalThis.__omcp_test_hook_calls;
+    assert.ok(calls && calls.length === 1, "hook should have fired once");
+});
+test("PluginLoader: missing hook module is skipped with a warning, others still register", async () => {
+    // Stage one good hook normally, then rewrite the manifest to ALSO
+    // reference a sibling module path that doesn't exist on disk. The
+    // loader must skip the missing one (existsSync branch) and still
+    // register the good one.
+    const stage = stagePlugin({
+        name: "gamma",
+        hooks: [{ kind: "tool_post_invoke", module: "hooks/post.mjs" }],
+    });
+    const manifestPath = join(stage, "gamma", "manifest.json");
+    const raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+    raw.hooks = [
+        { kind: "tool_pre_invoke", module: "hooks/genuinely-missing.mjs" },
+        { kind: "tool_post_invoke", module: "hooks/post.mjs" },
+    ];
+    writeFileSync(manifestPath, JSON.stringify(raw));
+    const registry = new HookRegistry();
+    await new PluginLoader({ pluginsDir: stage, verify: false, hookRegistry: registry }).load();
+    // The missing pre hook was skipped; the good post hook registered.
+    assert.equal(registry.list("tool_pre_invoke").length, 0);
+    assert.equal(registry.list("tool_post_invoke").length, 1);
+});
+test("PluginLoader: hook module path that escapes the plugin root is rejected", async () => {
+    // Stage a plugin whose manifest tries to reference a path with `..`
+    // — the loader must refuse to import it.
+    const stage = mkdtempSync(join(tmpdir(), "omcp-plugin-escape-"));
+    const root = join(stage, "evil");
+    mkdirSync(root, { recursive: true });
+    writeFileSync(join(root, "package.json"), JSON.stringify({
+        name: "@observability-mcp/connector-evil",
+        observabilityMcp: { kind: "connector", name: "evil", manifest: "./manifest.json" },
+        main: "./index.js",
+    }));
+    writeFileSync(join(root, "manifest.json"), JSON.stringify({
+        schemaVersion: 1,
+        name: "evil",
+        displayName: "evil",
+        version: "1.0.0",
+        description: "x",
+        signalTypes: ["topology"],
+        capabilities: { listServices: true },
+        hooks: [{ kind: "tool_pre_invoke", module: "../escape.mjs" }],
+    }));
+    writeFileSync(join(root, "index.js"), `export default function create() {
+      return {
+        type: "evil", signalType: "topology", name: "evil",
+        async connect() {},
+        async healthCheck() { return { status: "down", latencyMs: 0 }; },
+        async disconnect() {},
+        getDefaultMetrics() { return []; },
+        getMetrics() { return []; },
+        async listServices() { return []; },
+      };
+    }`);
+    // Stage a file outside the plugin root the manifest references.
+    writeFileSync(join(stage, "escape.mjs"), `export default async () => ({ allow: false, reason: "should never run" });`);
+    const registry = new HookRegistry();
+    const loader = new PluginLoader({ pluginsDir: stage, verify: false, hookRegistry: registry });
+    await loader.load();
+    // The escape hook was refused; nothing in the registry.
+    assert.equal(registry.list("tool_pre_invoke").length, 0);
+});
+test("PluginLoader: hot-reload — re-loading replaces prior hook registrations", async () => {
+    const stage = stagePlugin({
+        name: "delta",
+        hooks: [{ kind: "tool_pre_invoke", module: "hooks/pre.mjs", priority: 10 }],
+    });
+    const registry = new HookRegistry();
+    await new PluginLoader({ pluginsDir: stage, verify: false, hookRegistry: registry }).load();
+    assert.equal(registry.list("tool_pre_invoke").length, 1);
+    // Re-load (same stage, same plugin) — registry should still hold
+    // exactly one entry for tool_pre_invoke owned by delta. The loader
+    // calls unregisterPlugin first, then re-registers.
+    await new PluginLoader({ pluginsDir: stage, verify: false, hookRegistry: registry }).load();
+    const after = registry.list("tool_pre_invoke");
+    assert.equal(after.length, 1);
+    assert.equal(after[0].pluginName, "delta");
+});
+test("PluginLoader: no hookRegistry passed → hooks are silently ignored (back-compat)", async () => {
+    const stage = stagePlugin({
+        name: "epsilon",
+        hooks: [{ kind: "tool_pre_invoke", module: "hooks/pre.mjs" }],
+    });
+    // No hookRegistry — load() must not throw.
+    const loader = new PluginLoader({ pluginsDir: stage, verify: false });
+    await loader.load();
+    assert.ok(loader.has("epsilon"));
+});
+test("PluginLoader: hook with no default export is skipped", async () => {
+    const stage = stagePlugin({
+        name: "zeta",
+        hooks: [{ kind: "tool_pre_invoke", module: "hooks/noexport.mjs" }],
+    });
+    // Overwrite the noexport.mjs file to remove default export.
+    writeFileSync(join(stage, "zeta", "hooks", "noexport.mjs"), "export const meta = 'no handler here';");
+    const registry = new HookRegistry();
+    await new PluginLoader({ pluginsDir: stage, verify: false, hookRegistry: registry }).load();
+    assert.equal(registry.list("tool_pre_invoke").length, 0);
+});

package/dist/connectors/prometheus.test.js

@@ -77,27 +77,45 @@ describe("PrometheusConnector", () => {
         });
     });
     describe("buildQuery", () => {
-        it("replaces {{service}} placeholder in known metrics", async () => {
+        // buildQuery is private async and returns `{ promql, label, candidate }`.
+        // To keep these tests off the network, every case uses a user-
+        // override metric — that short-circuits the candidate-probe path
+        // (which would otherwise call Prometheus to pick the best variant
+        // and resolveServiceLabel to discover the right scoping label).
+        // The label / candidate fields are exercised via the public
+        // queryMetrics path elsewhere.
+        const fakeSource = { name: "test", type: "prometheus", url: "http://localhost:9090", enabled: true };
+        it("replaces {{service}} placeholder in user-defined metrics", async () => {
             const connector = new PrometheusConnector();
-            await connector.connect({ name: "test", type: "prometheus", url: "http://localhost:9090", enabled: true });
-            const query = proto.buildQuery.call(connector, "payment-service", "cpu");
-            assert.ok(query.includes("payment-service"));
-            assert.ok(!query.includes("{{service}}"));
-        });
-        it("falls back to generic query for unknown metrics", async () => {
+            await connector.connect({
+                ...fakeSource,
+                metrics: [{ name: "cpu", query: 'cpu_usage{svc="{{service}}"}', unit: "%", description: "CPU" }],
+            });
+            const { promql } = await proto.buildQuery.call(connector, "payment-service", "cpu");
+            assert.ok(promql.includes("payment-service"));
+            assert.ok(!promql.includes("{{service}}"));
+        });
+        it("respects an explicit {{service}} substitution outside the {{selector}} sugar", async () => {
+            // Different from the other two: the override here uses {{service}}
+            // directly inside a hand-written selector (no {{selector}} sugar).
+            // Confirms the substitution applies to the raw template, not only
+            // through the label-resolver path.
             const connector = new PrometheusConnector();
-            await connector.connect({ name: "test", type: "prometheus", url: "http://localhost:9090", enabled: true });
-            const query = proto.buildQuery.call(connector, "my-svc", "unknown_metric");
-            assert.equal(query, 'unknown_metric{job="my-svc"}');
+            await connector.connect({
+                ...fakeSource,
+                metrics: [{ name: "explicit_selector", query: 'explicit_metric{job="{{service}}"}', unit: "", description: "" }],
+            });
+            const { promql } = await proto.buildQuery.call(connector, "my-svc", "explicit_selector");
+            assert.equal(promql, 'explicit_metric{job="my-svc"}');
         });
         it("uses custom metrics from source config", async () => {
             const connector = new PrometheusConnector();
             await connector.connect({
-                name: "test", type: "prometheus", url: "http://localhost:9090", enabled: true,
+                ...fakeSource,
                 metrics: [{ name: "custom", query: 'my_custom_metric{svc="{{service}}"}', unit: "ops", description: "Custom" }],
             });
-            const query = proto.buildQuery.call(connector, "api", "custom");
-            assert.equal(query, 'my_custom_metric{svc="api"}');
+            const { promql } = await proto.buildQuery.call(connector, "api", "custom");
+            assert.equal(promql, 'my_custom_metric{svc="api"}');
         });
     });
 });

package/dist/connectors/registry.d.ts

@@ -17,5 +17,18 @@ export declare class ConnectorRegistry {
     getAll(): ObservabilityConnector[];
     getByName(name: string): ObservabilityConnector | undefined;
     getBySignal(signal: SignalType): ObservabilityConnector[];
+    /** Connectors visible to the named tenant: every source whose
+     *  config.tenant matches OR is unset (global). Unset = available
+     *  everywhere — keeps single-tenant deployments untouched.
+     *  Anonymous traffic / the agent / internal callers can pass
+     *  the DEFAULT_TENANT sentinel and see exactly what the default-
+     *  tenant operator sees. */
+    getByTenant(tenant: string): ObservabilityConnector[];
+    /** Same as `getByName`, but enforces the tenant gate: a source
+     *  whose config.tenant is set and differs from the calling tenant
+     *  returns undefined — indistinguishable from "no such source",
+     *  per the rest of the tenancy layer (no cross-tenant existence
+     *  leak). Unset source tenant = global, always resolves. */
+    getByNameForTenant(name: string, tenant: string): ObservabilityConnector | undefined;
     healthCheckAll(): Promise<Record<string, ConnectorHealth>>;
 }

package/dist/connectors/registry.js

@@ -80,6 +80,36 @@ export class ConnectorRegistry {
     getBySignal(signal) {
         return this.getAll().filter((c) => c.signalType === signal);
     }
+    /** Connectors visible to the named tenant: every source whose
+     *  config.tenant matches OR is unset (global). Unset = available
+     *  everywhere — keeps single-tenant deployments untouched.
+     *  Anonymous traffic / the agent / internal callers can pass
+     *  the DEFAULT_TENANT sentinel and see exactly what the default-
+     *  tenant operator sees. */
+    getByTenant(tenant) {
+        const out = [];
+        for (const [name, c] of this.connectors) {
+            const cfg = this.sourceConfigs.get(name);
+            const srcTenant = cfg?.tenant;
+            if (!srcTenant || srcTenant === tenant)
+                out.push(c);
+        }
+        return out;
+    }
+    /** Same as `getByName`, but enforces the tenant gate: a source
+     *  whose config.tenant is set and differs from the calling tenant
+     *  returns undefined — indistinguishable from "no such source",
+     *  per the rest of the tenancy layer (no cross-tenant existence
+     *  leak). Unset source tenant = global, always resolves. */
+    getByNameForTenant(name, tenant) {
+        const c = this.connectors.get(name);
+        if (!c)
+            return undefined;
+        const cfg = this.sourceConfigs.get(name);
+        if (cfg?.tenant && cfg.tenant !== tenant)
+            return undefined;
+        return c;
+    }
     async healthCheckAll() {
         const results = {};
         for (const [name, connector] of this.connectors) {

package/dist/connectors/registry.test.js

@@ -2,15 +2,21 @@ import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { getSupportedTypes, ConnectorRegistry } from "./registry.js";
 import { DEFAULT_SETTINGS, DEFAULT_HEALTH_THRESHOLDS } from "../config/loader.js";
+import { getPluginLoader } from "./loader.js";
 function makeConfig(sources = []) {
     return { sources, settings: DEFAULT_SETTINGS, healthThresholds: DEFAULT_HEALTH_THRESHOLDS };
 }
 describe("getSupportedTypes", () => {
-    it("returns prometheus and loki", () => {
+    it("returns the builtins (prometheus, loki, kubernetes) after loader.load()", async () => {
+        // The PluginLoader registers builtins inside load(), not the
+        // constructor — at server boot index.ts awaits load() before any
+        // tool registration code runs. Mirror that here so the test
+        // reflects the real wiring rather than a transient empty state.
+        await getPluginLoader().load();
         const types = getSupportedTypes();
         assert.ok(types.includes("prometheus"));
         assert.ok(types.includes("loki"));
-        assert.equal(types.length, 2);
+        assert.ok(types.includes("kubernetes"));
     });
 });
 describe("ConnectorRegistry", () => {
@@ -90,4 +96,52 @@ describe("ConnectorRegistry", () => {
             assert.deepEqual(results, {});
         });
     });
+    describe("getByTenant / getByNameForTenant", () => {
+        it("untagged sources are visible to every tenant (pre-E7 single-tenant default)", async () => {
+            await getPluginLoader().load();
+            const reg = new ConnectorRegistry();
+            await reg.initialize(makeConfig([
+                // No tenant on either source — both are "global".
+                { name: "prom-global", type: "prometheus", url: "http://p:9090", enabled: true },
+                { name: "loki-global", type: "loki", url: "http://l:3100", enabled: true },
+            ]));
+            const acmeVisible = reg.getByTenant("acme").map((c) => c.name).sort();
+            const bigcoVisible = reg.getByTenant("bigco").map((c) => c.name).sort();
+            assert.deepEqual(acmeVisible, ["loki-global", "prom-global"]);
+            assert.deepEqual(bigcoVisible, ["loki-global", "prom-global"]);
+        });
+        it("tenant-tagged source is invisible to other tenants", async () => {
+            await getPluginLoader().load();
+            const reg = new ConnectorRegistry();
+            await reg.initialize(makeConfig([
+                { name: "shared", type: "prometheus", url: "http://p:9090", enabled: true },
+                { name: "acme-only", type: "loki", url: "http://l:3100", enabled: true, tenant: "acme" },
+            ]));
+            assert.deepEqual(reg.getByTenant("acme").map((c) => c.name).sort(), ["acme-only", "shared"]);
+            // bigco sees only the shared source — the acme-only one is hidden.
+            assert.deepEqual(reg.getByTenant("bigco").map((c) => c.name).sort(), ["shared"]);
+        });
+        it("getByNameForTenant returns undefined on cross-tenant probe (no existence leak)", async () => {
+            await getPluginLoader().load();
+            const reg = new ConnectorRegistry();
+            await reg.initialize(makeConfig([
+                { name: "acme-loki", type: "loki", url: "http://l:3100", enabled: true, tenant: "acme" },
+            ]));
+            // Within tenant: resolves.
+            assert.ok(reg.getByNameForTenant("acme-loki", "acme"));
+            // Cross-tenant: undefined — indistinguishable from "no such source".
+            assert.equal(reg.getByNameForTenant("acme-loki", "bigco"), undefined);
+            // Unknown name in own tenant: also undefined.
+            assert.equal(reg.getByNameForTenant("nope", "acme"), undefined);
+        });
+        it("a source whose tenant is unset resolves for every tenant via getByNameForTenant", async () => {
+            await getPluginLoader().load();
+            const reg = new ConnectorRegistry();
+            await reg.initialize(makeConfig([
+                { name: "global", type: "prometheus", url: "http://p:9090", enabled: true },
+            ]));
+            assert.ok(reg.getByNameForTenant("global", "acme"));
+            assert.ok(reg.getByNameForTenant("global", "bigco"));
+        });
+    });
 });