@akira-tl/forgerelay 1.1.0 → 1.1.1

package/dist/cli/mcp/status.js

@@ -0,0 +1,295 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { loadConfig } from "../../runtime/config/config.js";
+import { ExternalMcpCredentialStore, externalMcpCredentialIdentity, } from "../../runtime/config/external-mcp-auth-store.js";
+import { ExternalMcpConfigRegistry, } from "../../runtime/config/external-mcp-registry.js";
+export function resolveExternalMcpScope(request, dependencies = {}) {
+    if (request.global && request.projectRoot) {
+        throw new Error("--global and --project cannot be used together.");
+    }
+    const env = dependencies.env ?? process.env;
+    const config = loadConfig(env);
+    const cwd = resolve(dependencies.cwd ?? process.cwd());
+    const registry = new ExternalMcpConfigRegistry({
+        configDir: config.configDir,
+        legacyServers: config.mcpServers,
+    });
+    const store = new ExternalMcpCredentialStore({ configDir: config.configDir });
+    if (request.global) {
+        return {
+            mode: "global",
+            projectRoot: cwd,
+            projectSelection: "global",
+            config,
+            registry,
+            snapshot: registry.resolveGlobal(),
+            store,
+        };
+    }
+    const selected = selectProjectRoot(request.projectRoot, cwd, env);
+    return {
+        mode: "project",
+        projectRoot: selected.root,
+        projectSelection: selected.selection,
+        config,
+        registry,
+        snapshot: registry.resolve(selected.root),
+        store,
+    };
+}
+export function inspectExternalMcpStatus(scope) {
+    let credentialStore = "missing";
+    let credentialStoreMessage;
+    try {
+        credentialStore = scope.store.inspect().exists ? "ok" : "missing";
+    }
+    catch (error) {
+        credentialStore = "invalid";
+        credentialStoreMessage = boundedStatusMessage(error);
+    }
+    const effective = Object.entries(scope.snapshot.servers).map(([name, config]) => {
+        const source = scope.snapshot.origins[name];
+        return serverStatus(scope, name, source, config, credentialStore === "invalid");
+    });
+    const disabled = Object.entries(scope.snapshot.masked).map(([name, source]) => ({
+        name,
+        source,
+        enabled: false,
+    }));
+    const servers = [...effective, ...disabled].sort((left, right) => left.name.localeCompare(right.name));
+    return {
+        scope,
+        servers,
+        configIssues: scope.snapshot.sources.filter((source) => source.state === "invalid").length
+            + (credentialStore === "invalid" ? 1 : 0),
+        credentialStore,
+        ...(credentialStoreMessage ? { credentialStoreMessage } : {}),
+    };
+}
+export function findExternalMcpServerStatus(status, name) {
+    return status.servers.find((server) => server.name === name);
+}
+export function formatExternalMcpList(status) {
+    const lines = ["External MCP", ""];
+    if (status.scope.mode === "global") {
+        lines.push("Scope: global");
+    }
+    else {
+        lines.push("Scope: project", `Project: ${status.scope.projectRoot}`);
+    }
+    lines.push("", "Config:");
+    for (const source of status.scope.snapshot.sources) {
+        lines.push(`  ${source.source.padEnd(7)} ${source.path} · ${formatConfigSourceState(source, status)}`);
+    }
+    if (status.credentialStore === "invalid") {
+        lines.push(`  auth    ${status.scope.store.filePath} · invalid`);
+        if (status.credentialStoreMessage)
+            lines.push(`          ${status.credentialStoreMessage}`);
+    }
+    else {
+        lines.push(`  auth    ${status.scope.store.filePath} · ${status.credentialStore}`);
+    }
+    lines.push("", "Servers:");
+    if (status.servers.length === 0) {
+        lines.push("  none");
+    }
+    else {
+        for (const server of status.servers) {
+            lines.push(`  ${server.name}`);
+            lines.push(`    source: ${server.source}`);
+            if (!server.enabled) {
+                lines.push("    status: disabled");
+                continue;
+            }
+            lines.push(`    transport: ${server.transport}`);
+            lines.push(`    auth: ${formatAuth(server)}`);
+            lines.push("    status: configured");
+        }
+    }
+    if (status.scope.snapshot.diagnostics.length > 0) {
+        lines.push("", "Config issues:");
+        for (const diagnostic of status.scope.snapshot.diagnostics) {
+            const source = status.scope.snapshot.sources.find((candidate) => candidate.source === diagnostic.source);
+            lines.push(`  ${diagnostic.source}: ${diagnostic.message}`);
+            if (source?.usingLastKnownGood) {
+                lines.push("    Using this process's last-known-good configuration.");
+            }
+            else {
+                lines.push("    Existing ForgeRelay runtimes that loaded a valid version may continue using last-known-good configuration.");
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export function formatExternalMcpDoctor(status) {
+    const enabled = status.servers.filter((server) => server.enabled);
+    const disabled = status.servers.length - enabled.length;
+    const authenticated = enabled.filter((server) => server.authState === "authenticated").length;
+    const authRequired = enabled.filter((server) => server.authState === "auth-required").length;
+    const reauthRequired = enabled.filter((server) => server.authState === "reauth-required").length;
+    const sourceSummary = status.scope.snapshot.sources
+        .map((source) => `${source.source}=${compactSourceState(source, status)}`)
+        .join(" · ");
+    return [
+        "External MCP:",
+        `  Scope: ${status.scope.mode}${status.scope.mode === "project" ? ` (${status.scope.projectRoot})` : ""}`,
+        `  Config: ${sourceSummary}`,
+        `  Effective servers: ${enabled.length}`,
+        `  Disabled: ${disabled}`,
+        `  OAuth authenticated: ${authenticated}`,
+        `  Auth required: ${authRequired}`,
+        `  Reauthorization required: ${reauthRequired}`,
+        `  Credential store: ${status.credentialStore}`,
+        `  Config issues: ${status.configIssues}`,
+        "  Hot reload: active",
+        "  Active checks: not run (use `forgerelay mcp test <server>`)",
+    ].join("\n");
+}
+export function formatAuth(status) {
+    switch (status.authKind) {
+        case "oauth":
+            if (status.authState === "authenticated")
+                return "oauth · authenticated";
+            if (status.authState === "auth-required")
+                return "oauth · auth required";
+            if (status.authState === "reauth-required")
+                return "oauth · reauthorization required";
+            return "oauth · not authenticated";
+        case "static":
+            return "static · configured";
+        case "config-managed":
+            return "config-managed";
+        case "none-detected":
+        default:
+            return "none detected";
+    }
+}
+function serverStatus(scope, name, source, config, credentialStoreInvalid) {
+    if (config.transport === "stdio") {
+        return {
+            name,
+            source,
+            enabled: true,
+            transport: config.transport,
+            authKind: "config-managed",
+            authState: "configured",
+        };
+    }
+    if (hasStaticAuthorizationHeader(config.headers)) {
+        return {
+            name,
+            source,
+            enabled: true,
+            transport: config.transport,
+            authKind: "static",
+            authState: "configured",
+        };
+    }
+    if (credentialStoreInvalid) {
+        return {
+            name,
+            source,
+            enabled: true,
+            transport: config.transport,
+            authKind: config.oauth ? "oauth" : "none-detected",
+            authState: "not-detected",
+        };
+    }
+    const identity = externalMcpCredentialIdentity(source, name, scope.projectRoot);
+    let record;
+    try {
+        record = scope.store.read(identity);
+    }
+    catch {
+        record = undefined;
+    }
+    const bindingMismatch = record ? !credentialBindingMatches(record, config.url) : false;
+    const authState = bindingMismatch
+        ? "reauth-required"
+        : record?.reauthorization?.reason === "authorization_required" && !record.tokens?.access_token
+            ? "auth-required"
+            : record?.reauthorization
+                ? "reauth-required"
+                : record?.tokens?.access_token
+                    ? "authenticated"
+                    : "not-detected";
+    const authKind = record || config.oauth ? "oauth" : "none-detected";
+    return {
+        name,
+        source,
+        enabled: true,
+        transport: config.transport,
+        authKind,
+        authState,
+    };
+}
+function credentialBindingMatches(record, serverUrl) {
+    try {
+        if (new URL(record.serverUrl).toString() !== new URL(serverUrl).toString())
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const expectedIssuer = record.discoveryState?.authorizationServerMetadata?.issuer
+        ?? record.authorizationServerUrl
+        ?? record.discoveryState?.authorizationServerUrl;
+    if (!expectedIssuer)
+        return true;
+    for (const candidate of [record.tokens?.issuer, record.clientInformation?.issuer]) {
+        if (candidate && candidate !== expectedIssuer)
+            return false;
+    }
+    return true;
+}
+function selectProjectRoot(explicit, cwd, env) {
+    if (explicit)
+        return { root: resolve(explicit), selection: "explicit" };
+    if (env.FORGERELAY_WORKSPACE_ROOT) {
+        return { root: resolve(env.FORGERELAY_WORKSPACE_ROOT), selection: "workspace-env" };
+    }
+    const ancestor = findNearestProjectConfig(cwd);
+    if (ancestor)
+        return { root: ancestor, selection: "ancestor-config" };
+    return { root: cwd, selection: "cwd" };
+}
+function findNearestProjectConfig(start) {
+    let current = resolve(start);
+    while (true) {
+        if (existsSync(join(current, ".forgerelay", "mcp.json")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function hasStaticAuthorizationHeader(headers) {
+    return Object.keys(headers ?? {}).some((name) => name.toLowerCase() === "authorization");
+}
+function formatConfigSourceState(source, status) {
+    if (source.source === "legacy") {
+        const legacyCount = status.servers.filter((server) => server.enabled && server.source === "legacy").length;
+        return legacyCount > 0 ? `compatibility · ${legacyCount} server${legacyCount === 1 ? "" : "s"}` : "compatibility · none";
+    }
+    if (source.state === "valid")
+        return "ok";
+    if (source.state === "missing")
+        return "missing";
+    return source.usingLastKnownGood ? "invalid · using last-known-good" : "invalid";
+}
+function compactSourceState(source, status) {
+    if (source.source === "legacy") {
+        return status.servers.some((server) => server.enabled && server.source === "legacy") ? "compat" : "none";
+    }
+    if (source.state === "valid")
+        return "ok";
+    if (source.state === "missing")
+        return "missing";
+    return source.usingLastKnownGood ? "invalid/lkg" : "invalid";
+}
+function boundedStatusMessage(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    const normalized = raw.replace(/\s+/g, " ").trim() || "External MCP status unavailable.";
+    return normalized.length <= 320 ? normalized : `${normalized.slice(0, 317)}...`;
+}

package/dist/cli.js

@@ -12,6 +12,8 @@ import { loadConfig } from "./runtime/config/config.js";
 import { acquireRuntimeLease } from "./runtime/state/runtime-lease.js";
 import { runInit } from "./cli/init.js";
 import { runMaintenanceCommand } from "./cli/maintenance.js";
+import { runExternalMcpCommand } from "./cli/mcp/external-mcp.js";
+import { formatExternalMcpDoctor, inspectExternalMcpStatus, resolveExternalMcpScope, } from "./cli/mcp/status.js";
 import { runHooksCommand } from "./mcp/hooks/hook-cli.js";
 import { executeSubagentSession } from "./subagents/sessions/execution.js";
 import { SubagentDeliveryMailbox } from "./subagents/sessions/delivery-mailbox.js";
@@ -63,6 +65,9 @@ async function main(argv) {
         case "auth":
             await runAuthCommand(args);
             return;
+        case "mcp":
+            await runExternalMcpCommand(args);
+            return;
         case "maintenance":
             runMaintenanceCommand(args);
             return;
@@ -77,7 +82,7 @@ async function main(argv) {
 function normalizeCommand(command) {
     if (!command || command === "serve" || command === "start")
         return "serve";
-    if (command === "init" || command === "doctor" || command === "config" || command === "hooks" || command === "agents" || command === "auth" || command === "maintenance")
+    if (command === "init" || command === "doctor" || command === "config" || command === "hooks" || command === "agents" || command === "auth" || command === "mcp" || command === "maintenance")
         return command;
     if (command === "help" || command === "--help" || command === "-h")
         return "help";
@@ -379,6 +384,10 @@ async function runDoctor() {
         console.log(`Agent-managed Language Server install: ${config.allowAgentLanguageServerInstall ? "enabled" : "disabled"}`);
         console.log(`Allowed roots: ${config.allowedRoots.join(", ")}`);
         console.log(`Allowed hosts: ${config.allowedHosts.join(", ")}`);
+        console.log(formatExternalMcpDoctor(inspectExternalMcpStatus(resolveExternalMcpScope({}, {
+            env: process.env,
+            cwd: process.cwd(),
+        }))));
     }
     catch (error) {
         console.log(`Config status: ${error instanceof Error ? error.message : String(error)}`);
@@ -430,6 +439,10 @@ function printHelp() {
         "  forgerelay auth test <alias>",
         "  forgerelay auth rename <old-alias> <new-alias>",
         "  forgerelay auth remove <alias>",
+        "  forgerelay mcp list [--project <path>|--global]",
+        "  forgerelay mcp test <server> [--project <path>|--global]",
+        "  forgerelay mcp auth <server> [--project <path>|--global]",
+        "  forgerelay mcp logout <server> [--project <path>|--global]",
         "  forgerelay maintenance inspect [--json]",
         "  forgerelay -v, --version   Print the installed version",
         "",

package/dist/lsp/test-support/server-fixture.js

@@ -2,8 +2,7 @@ import assert from "node:assert/strict";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
 import { ActivityAuditStore } from "../../activity/history/audit-store.js";
 import { BashOutputStore } from "../../activity/history/bash-output-store.js";
 import { HostTurnStore } from "../../activity/history/host-turn-store.js";