feat(mcp): add remote + stdio mirror for loopover_get_upstream_ruleset

Expose GET /v1/upstream/ruleset through remote MCP and local stdio using the
same public, no-argument shape as loopover_get_upstream_drift, including the
upstream_ruleset_not_found result when no snapshot exists.

Closes #7807

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: bohdansolovie

test/unit/mcp-cli-upstream-ruleset.test.ts

@@ -1,70 +1,70 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { closeFixtureServer, startFixtureServer } from "./support/mcp-cli-harness";
-
-const bin = join(process.cwd(), "packages/loopover-mcp/bin/loopover-mcp.js");
-const FORBIDDEN_PUBLIC_TERMS = /wallet\s*[:=]\s*\S+|hotkey\s*[:=]\s*\S+|coldkey\s*[:=]\s*\S+|raw trust score is|your trust score|reward estimate is|estimated reward/i;
-
-let client: Client;
-let transport: StdioClientTransport;
-let configDir: string;
-let apiUrl: string;
-let capturedRequests: Array<{ url: string; method: string }>;
-
-async function connect() {
-  configDir = mkdtempSync(join(tmpdir(), "loopover-upstream-ruleset-"));
-  capturedRequests = [];
-  apiUrl = await startFixtureServer({
-    onApiRequest: (request) => {
-      if (request.url && request.url.includes("/v1/upstream/ruleset")) {
-        capturedRequests.push({ url: request.url ?? "", method: request.method ?? "GET" });
-      }
-    },
-  });
-  transport = new StdioClientTransport({
-    command: "node",
-    args: [bin, "--stdio"],
-    env: {
-      ...process.env,
-      LOOPOVER_CONFIG_DIR: configDir,
-      LOOPOVER_API_URL: apiUrl,
-      LOOPOVER_TOKEN: "session-token",
-      LOOPOVER_API_TIMEOUT_MS: "5000",
-    },
-  });
-  client = new Client({ name: "upstream-ruleset-test", version: "0.0.1" });
-  await client.connect(transport);
-}
-
-async function disconnect() {
-  await client.close().catch(() => undefined);
-  await closeFixtureServer();
-  if (configDir) rmSync(configDir, { recursive: true, force: true });
-}
-
-describe("loopover_get_upstream_ruleset stdio proxy (#7807)", () => {
-  beforeEach(connect);
-  afterEach(disconnect);
-
-  it("registers the tool in the stdio server tool list", async () => {
-    const { tools } = await client.listTools();
-    expect(tools.map((t) => t.name)).toContain("loopover_get_upstream_ruleset");
-  });
-
-  it("proxies the call to /v1/upstream/ruleset via apiGet and returns the payload", async () => {
-    const result = await client.callTool({ name: "loopover_get_upstream_ruleset", arguments: {} });
-    expect(capturedRequests.length).toBe(1);
-    const captured = capturedRequests[0]!;
-    expect(captured.url).toContain("/v1/upstream/ruleset");
-    expect(captured.method).toBe("GET");
-    expect(result.isError).toBeFalsy();
-    const text = JSON.stringify(result);
-    expect(text).not.toMatch(FORBIDDEN_PUBLIC_TERMS);
-    expect(text).toContain("ruleset-1");
-    expect(text).toContain("pending_saturation_model");
-  });
-});
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { closeFixtureServer, startFixtureServer } from "./support/mcp-cli-harness";
+
+const bin = join(process.cwd(), "packages/loopover-mcp/bin/loopover-mcp.js");
+const FORBIDDEN_PUBLIC_TERMS = /wallet\s*[:=]\s*\S+|hotkey\s*[:=]\s*\S+|coldkey\s*[:=]\s*\S+|raw trust score is|your trust score|reward estimate is|estimated reward/i;
+
+let client: Client;
+let transport: StdioClientTransport;
+let configDir: string;
+let apiUrl: string;
+let capturedRequests: Array<{ url: string; method: string }>;
+
+async function connect() {
+  configDir = mkdtempSync(join(tmpdir(), "loopover-upstream-ruleset-"));
+  capturedRequests = [];
+  apiUrl = await startFixtureServer({
+    onApiRequest: (request) => {
+      if (request.url && request.url.includes("/v1/upstream/ruleset")) {
+        capturedRequests.push({ url: request.url ?? "", method: request.method ?? "GET" });
+      }
+    },
+  });
+  transport = new StdioClientTransport({
+    command: "node",
+    args: [bin, "--stdio"],
+    env: {
+      ...process.env,
+      LOOPOVER_CONFIG_DIR: configDir,
+      LOOPOVER_API_URL: apiUrl,
+      LOOPOVER_TOKEN: "session-token",
+      LOOPOVER_API_TIMEOUT_MS: "5000",
+    },
+  });
+  client = new Client({ name: "upstream-ruleset-test", version: "0.0.1" });
+  await client.connect(transport);
+}
+
+async function disconnect() {
+  await client.close().catch(() => undefined);
+  await closeFixtureServer();
+  if (configDir) rmSync(configDir, { recursive: true, force: true });
+}
+
+describe("loopover_get_upstream_ruleset stdio proxy (#7807)", () => {
+  beforeEach(connect);
+  afterEach(disconnect);
+
+  it("registers the tool in the stdio server tool list", async () => {
+    const { tools } = await client.listTools();
+    expect(tools.map((t) => t.name)).toContain("loopover_get_upstream_ruleset");
+  });
+
+  it("proxies the call to /v1/upstream/ruleset via apiGet and returns the payload", async () => {
+    const result = await client.callTool({ name: "loopover_get_upstream_ruleset", arguments: {} });
+    expect(capturedRequests.length).toBe(1);
+    const captured = capturedRequests[0]!;
+    expect(captured.url).toContain("/v1/upstream/ruleset");
+    expect(captured.method).toBe("GET");
+    expect(result.isError).toBeFalsy();
+    const text = JSON.stringify(result);
+    expect(text).not.toMatch(FORBIDDEN_PUBLIC_TERMS);
+    expect(text).toContain("ruleset-1");
+    expect(text).toContain("pending_saturation_model");
+  });
+});

test/unit/mcp-upstream-ruleset.test.ts

@@ -1,70 +1,70 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { describe, expect, it } from "vitest";
-import { persistUpstreamRulesetSnapshot } from "../../src/db/repositories";
-import { LoopoverMcp } from "../../src/mcp/server";
-import type { UpstreamRulesetSnapshotRecord } from "../../src/types";
-import { createTestEnv } from "../helpers/d1";
-
-async function connect(env: Env) {
-  const server = new LoopoverMcp(env).createServer();
-  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-  await server.connect(serverTransport);
-  const client = new Client({ name: "loopover-upstream-ruleset-test", version: "0.1.0" }, { capabilities: {} });
-  await client.connect(clientTransport);
-  return client;
-}
-
-function ruleset(id: string, generatedAt: string): UpstreamRulesetSnapshotRecord {
-  return {
-    id,
-    sourceRepo: "entrius/gittensor",
-    sourceRef: "test",
-    commitSha: `${id}-commit`,
-    sourceSnapshotIds: [],
-    activeModel: "pending_saturation_model",
-    registryRepoCount: 1,
-    totalEmissionShare: 0.01,
-    semanticHash: `${id}-hash`,
-    payload: {
-      registry: { repoCount: 1, totalEmissionShare: 0.01, repositories: [] },
-      scoring: { activeModel: "pending_saturation_model", constants: {}, semanticFlags: {} },
-      issueDiscovery: { branchEligibilityRequired: false },
-      mirrorLinkage: { solvedByPrRequired: false },
-      languageWeights: { count: 0, weights: {} },
-      sourceSnapshots: [],
-    },
-    warnings: [],
-    generatedAt,
-  };
-}
-
-describe("MCP loopover_get_upstream_ruleset (#7807)", () => {
-  it("registers as a utility-category no-argument tool", async () => {
-    const client = await connect(createTestEnv());
-    const { tools } = await client.listTools();
-    const tool = tools.find((entry) => entry.name === "loopover_get_upstream_ruleset");
-    expect(tool).toBeDefined();
-    expect((tool as { _meta?: { category?: string } })._meta?.category).toBe("utility");
-    expect(tool?.inputSchema).toMatchObject({ type: "object" });
-  });
-
-  it("returns not_found as a normal result when no snapshot exists", async () => {
-    const client = await connect(createTestEnv());
-    const result = await client.callTool({ name: "loopover_get_upstream_ruleset", arguments: {} });
-    expect(result.isError).toBeFalsy();
-    expect(result.structuredContent).toEqual({ error: "upstream_ruleset_not_found" });
-  });
-
-  it("returns the latest persisted ruleset snapshot", async () => {
-    const env = createTestEnv();
-    await persistUpstreamRulesetSnapshot(env, ruleset("ruleset-live", "2026-05-30T00:00:00.000Z"));
-    const client = await connect(env);
-    const result = await client.callTool({ name: "loopover_get_upstream_ruleset", arguments: {} });
-    expect(result.isError).toBeFalsy();
-    const payload = result.structuredContent as UpstreamRulesetSnapshotRecord;
-    expect(payload.id).toBe("ruleset-live");
-    expect(payload.activeModel).toBe("pending_saturation_model");
-    expect(payload.semanticHash).toBe("ruleset-live-hash");
-  });
-});
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { describe, expect, it } from "vitest";
+import { persistUpstreamRulesetSnapshot } from "../../src/db/repositories";
+import { LoopoverMcp } from "../../src/mcp/server";
+import type { UpstreamRulesetSnapshotRecord } from "../../src/types";
+import { createTestEnv } from "../helpers/d1";
+
+async function connect(env: Env) {
+  const server = new LoopoverMcp(env).createServer();
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await server.connect(serverTransport);
+  const client = new Client({ name: "loopover-upstream-ruleset-test", version: "0.1.0" }, { capabilities: {} });
+  await client.connect(clientTransport);
+  return client;
+}
+
+function ruleset(id: string, generatedAt: string): UpstreamRulesetSnapshotRecord {
+  return {
+    id,
+    sourceRepo: "entrius/gittensor",
+    sourceRef: "test",
+    commitSha: `${id}-commit`,
+    sourceSnapshotIds: [],
+    activeModel: "pending_saturation_model",
+    registryRepoCount: 1,
+    totalEmissionShare: 0.01,
+    semanticHash: `${id}-hash`,
+    payload: {
+      registry: { repoCount: 1, totalEmissionShare: 0.01, repositories: [] },
+      scoring: { activeModel: "pending_saturation_model", constants: {}, semanticFlags: {} },
+      issueDiscovery: { branchEligibilityRequired: false },
+      mirrorLinkage: { solvedByPrRequired: false },
+      languageWeights: { count: 0, weights: {} },
+      sourceSnapshots: [],
+    },
+    warnings: [],
+    generatedAt,
+  };
+}
+
+describe("MCP loopover_get_upstream_ruleset (#7807)", () => {
+  it("registers as a utility-category no-argument tool", async () => {
+    const client = await connect(createTestEnv());
+    const { tools } = await client.listTools();
+    const tool = tools.find((entry) => entry.name === "loopover_get_upstream_ruleset");
+    expect(tool).toBeDefined();
+    expect((tool as { _meta?: { category?: string } })._meta?.category).toBe("utility");
+    expect(tool?.inputSchema).toMatchObject({ type: "object" });
+  });
+
+  it("returns not_found as a normal result when no snapshot exists", async () => {
+    const client = await connect(createTestEnv());
+    const result = await client.callTool({ name: "loopover_get_upstream_ruleset", arguments: {} });
+    expect(result.isError).toBeFalsy();
+    expect(result.structuredContent).toEqual({ error: "upstream_ruleset_not_found" });
+  });
+
+  it("returns the latest persisted ruleset snapshot", async () => {
+    const env = createTestEnv();
+    await persistUpstreamRulesetSnapshot(env, ruleset("ruleset-live", "2026-05-30T00:00:00.000Z"));
+    const client = await connect(env);
+    const result = await client.callTool({ name: "loopover_get_upstream_ruleset", arguments: {} });
+    expect(result.isError).toBeFalsy();
+    const payload = result.structuredContent as UpstreamRulesetSnapshotRecord;
+    expect(payload.id).toBe("ruleset-live");
+    expect(payload.activeModel).toBe("pending_saturation_model");
+    expect(payload.semanticHash).toBe("ruleset-live-hash");
+  });
+});