@akira-tl/forgerelay 1.2.5 → 1.3.1

package/dist/cli/config/general.js

@@ -0,0 +1,174 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { forgerelayConfigDir, loadForgeRelayFiles, writeConfigJsonFile, writeForgeRelayConfig, } from "../../runtime/config/user-config.js";
+import { parseConfigSource } from "../../runtime/config/definition/definition.js";
+import { generalConfigDefinition } from "../../runtime/config/definition/general-config.js";
+import { resolveGeneralConfig } from "../../runtime/config/resolution/general.js";
+import { readJsonConfigSource } from "../../runtime/config/resolution/project-sources.js";
+import { assertConfigResolutionValid } from "../../runtime/config/resolution/resolver.js";
+import { ProjectContextResolver } from "../../workspaces/state/project-context.js";
+import { normalizeOptionalPublicBaseUrl } from "../setup-support.js";
+import { parseConfigScopeArgs } from "./scope.js";
+export function renderGeneralConfigHelp() {
+    return [
+        "ForgeRelay config",
+        "",
+        "Usage:",
+        "  forgerelay config get [--project <path>|--global]",
+        "  forgerelay config set <logical-path> <value> [--project <path>|--global]",
+        "  forgerelay config unset <logical-path> [--project <path>|--global]",
+        "  forgerelay config check [--project <path>|--global] [--json]",
+        "  forgerelay config sources [--project <path>|--global] [--json]",
+        "  forgerelay config explain <logical-path> [--project <path>|--global] [--json]",
+        "  forgerelay config migrate [--dry-run] [--project <path>|--global]",
+        "  forgerelay config context <get|set|unset|check|sources|explain> ...",
+        "  forgerelay config <mcp|hooks|lsp|subagents> <get|set|unset|remove|check|sources|explain> ...",
+    ].join("\n");
+}
+export async function runGeneralConfigGet(args) {
+    const parsed = parseConfigScopeArgs(args);
+    if (parsed.rest.length > 0)
+        throw new Error(`Unknown config get option: ${parsed.rest[0]}`);
+    const resolution = await resolveGeneralConfigForScope(parsed.scope);
+    assertConfigResolutionValid(resolution);
+    console.log(JSON.stringify(resolution.values, null, 2));
+}
+export async function resolveGeneralConfigForScope(scope) {
+    const configDir = forgerelayConfigDir();
+    const userSource = await readJsonConfigSource({
+        id: "user:config",
+        scope: "user",
+        location: join(configDir, "config.json"),
+    });
+    const project = scope.mode === "project"
+        ? await new ProjectContextResolver(configDir).inspect(scope.projectRoot)
+        : undefined;
+    const projectSource = project
+        ? await readJsonConfigSource({
+            id: "project:config",
+            scope: "project",
+            location: join(project.sharedConfigDir, "config.json"),
+        })
+        : undefined;
+    const projectLocalSource = project?.localConfigDir
+        ? await readJsonConfigSource({
+            id: "project-local:config",
+            scope: "project-local",
+            location: join(project.localConfigDir, "config.json"),
+        })
+        : undefined;
+    return resolveGeneralConfig({
+        env: process.env,
+        ...(userSource ? { userSource } : {}),
+        ...(projectSource ? { projectSource } : {}),
+        ...(projectLocalSource ? { projectLocalSource } : {}),
+    });
+}
+export async function runGeneralConfigSet(args) {
+    const parsed = parseConfigScopeArgs(args);
+    if (parsed.rest.length < 2) {
+        throw new Error("Usage: forgerelay config set <logical-path> <value> [--project <path>|--global]");
+    }
+    const [logicalPath, ...valueParts] = parsed.rest;
+    const path = generalPathSegments(logicalPath);
+    const rawValue = valueParts.join(" ").trim();
+    if (!rawValue)
+        throw new Error(`Missing value for ${logicalPath}.`);
+    const target = await generalConfigWriteTarget(parsed.scope);
+    const next = readGeneralConfigTarget(target);
+    setNestedValue(next, path, coerceConfigValue(path, rawValue));
+    console.log(`Updated ${writeGeneralConfigTarget(target, next)}`);
+}
+export async function runGeneralConfigUnset(args) {
+    const parsed = parseConfigScopeArgs(args);
+    if (parsed.rest.length !== 1) {
+        throw new Error("Usage: forgerelay config unset <logical-path> [--project <path>|--global]");
+    }
+    const path = generalPathSegments(parsed.rest[0]);
+    const target = await generalConfigWriteTarget(parsed.scope);
+    const next = readGeneralConfigTarget(target);
+    deleteNestedValue(next, path);
+    console.log(`Updated ${writeGeneralConfigTarget(target, next)}`);
+}
+async function generalConfigWriteTarget(scope) {
+    const configDir = forgerelayConfigDir();
+    if (scope.mode === "global") {
+        return { scope: "user", path: join(configDir, "config.json") };
+    }
+    const project = await new ProjectContextResolver(configDir).inspect(scope.projectRoot);
+    return { scope: "project", path: join(project.sharedConfigDir, "config.json") };
+}
+function readGeneralConfigTarget(target) {
+    if (target.scope === "user") {
+        return structuredClone(loadForgeRelayFiles().config);
+    }
+    if (!existsSync(target.path))
+        return {};
+    const parsed = JSON.parse(readFileSync(target.path, "utf8"));
+    if (!isRecord(parsed))
+        throw new Error(`General configuration must be a JSON object: ${target.path}`);
+    return structuredClone(parsed);
+}
+function writeGeneralConfigTarget(target, value) {
+    if (target.scope === "user") {
+        return writeForgeRelayConfig(value);
+    }
+    const validated = parseConfigSource(generalConfigDefinition, "project", value);
+    mkdirSync(dirname(target.path), { recursive: true });
+    writeConfigJsonFile(target.path, validated, 0o600);
+    return target.path;
+}
+function generalPathSegments(logicalPath) {
+    const normalized = logicalPath.trim();
+    const path = normalized.startsWith("config.") ? normalized.slice("config.".length) : normalized;
+    const segments = path.split(".").filter(Boolean);
+    if (segments.length === 0)
+        throw new Error(`Invalid General Config logical path: ${logicalPath}.`);
+    return segments;
+}
+function coerceConfigValue(path, rawValue) {
+    let value;
+    try {
+        value = JSON.parse(rawValue);
+    }
+    catch {
+        value = rawValue;
+    }
+    if (path.length === 1 && path[0] === "publicBaseUrl" && typeof value === "string") {
+        return normalizeOptionalPublicBaseUrl(value);
+    }
+    return value;
+}
+function setNestedValue(target, path, value) {
+    let current = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = current[segment];
+        if (existing !== undefined && !isRecord(existing)) {
+            throw new Error(`Cannot set config.${path.join(".")}: config.${segment} is not an object.`);
+        }
+        const next = existing ?? {};
+        current[segment] = next;
+        current = next;
+    }
+    current[path[path.length - 1]] = value;
+}
+function deleteNestedValue(target, path) {
+    const parents = [];
+    let current = target;
+    for (const segment of path.slice(0, -1)) {
+        const existing = current[segment];
+        if (!isRecord(existing))
+            return;
+        parents.push({ object: current, key: segment });
+        current = existing;
+    }
+    delete current[path[path.length - 1]];
+    for (const parent of parents.reverse()) {
+        const value = parent.object[parent.key];
+        if (isRecord(value) && Object.keys(value).length === 0)
+            delete parent.object[parent.key];
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/cli/config/inspect.js

@@ -1,4 +1,4 @@
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { forgerelayConfigDir } from "../../runtime/config/user-config.js";
 import { ExternalMcpConfigRegistry } from "../../runtime/config/external-mcp-registry.js";
 import { resolveGeneralConfig } from "../../runtime/config/resolution/general.js";
@@ -8,12 +8,13 @@ import { readJsonConfigSource } from "../../runtime/config/resolution/project-so
 import { ConfigSourceRuntime } from "../../runtime/config/runtime/source-refresh.js";
 import { resolveSubagentProfilesConfigSources } from "../../subagents/profiles.js";
 import { ProjectContextResolver } from "../../workspaces/state/project-context.js";
+import { parseConfigScopeArgs } from "./scope.js";
 const OFFLINE_LIVE_STATE = {
     mode: "offline",
     lastKnownGood: "unknown",
     appliedValues: "unknown",
 };
-export async function runConfigInspection(args) {
+export async function runConfigInspection(args, domainFilter, logicalPathFilter) {
     let options;
     try {
         options = parseInspectionArgs(args);
@@ -25,6 +26,10 @@ export async function runConfigInspection(args) {
     let domains;
     try {
         domains = await resolveInspectionDomains(options);
+        if (domainFilter)
+            domains = domains.filter((domain) => domain.domain === domainFilter);
+        if (logicalPathFilter)
+            domains = domains.map((domain) => filterResolvedDomain(domain, logicalPathFilter));
     }
     catch (error) {
         console.error(error instanceof Error ? error.message : String(error));
@@ -95,38 +100,20 @@ export async function runConfigInspection(args) {
     return summary.errors > 0 ? 1 : 0;
 }
 function parseInspectionArgs(args) {
-    const [command, ...rest] = args;
+    const scoped = parseConfigScopeArgs(args);
+    const [command, ...rest] = scoped.rest;
     if (command !== "check" && command !== "sources" && command !== "explain") {
         throw new Error("Expected config check, config sources, or config explain <logical-path>.");
     }
     let json = false;
-    let global = false;
-    let projectRoot;
     let logicalPath;
-    for (let index = 0; index < rest.length; index += 1) {
-        const arg = rest[index];
+    for (const arg of rest) {
         if (arg === "--json") {
             if (json)
                 throw new Error("--json may only be supplied once.");
             json = true;
             continue;
         }
-        if (arg === "--global") {
-            if (global || projectRoot)
-                throw new Error("--global and --project cannot be used together or repeated.");
-            global = true;
-            continue;
-        }
-        if (arg === "--project") {
-            if (global || projectRoot)
-                throw new Error("--global and --project cannot be used together or repeated.");
-            const value = rest[index + 1];
-            if (!value || value.startsWith("--"))
-                throw new Error("--project requires a project path.");
-            projectRoot = resolve(value);
-            index += 1;
-            continue;
-        }
         if (command === "explain" && logicalPath === undefined && !arg.startsWith("--")) {
             logicalPath = arg;
             continue;
@@ -138,9 +125,7 @@ function parseInspectionArgs(args) {
     return {
         command,
         json,
-        scope: global
-            ? { mode: "global" }
-            : { mode: "project", projectRoot: projectRoot ?? resolve(process.env.FORGERELAY_WORKSPACE_ROOT ?? process.cwd()) },
+        scope: scoped.scope,
         ...(logicalPath ? { logicalPath } : {}),
     };
 }
@@ -210,6 +195,24 @@ async function resolveInspectionDomains(options) {
     });
     return [general, mcp, languageServers, hooks, subagents];
 }
+function filterResolvedDomain(domain, logicalPaths) {
+    const entries = Object.fromEntries(Object.entries(domain.entries).filter(([, entry]) => logicalPaths.has(entry.logicalPath)));
+    const diagnostics = domain.diagnostics.filter((diagnostic) => diagnostic.logicalPath === undefined || logicalPaths.has(diagnostic.logicalPath));
+    const sourceIds = new Set();
+    for (const entry of Object.values(entries)) {
+        sourceIds.add(entry.effective.source.id);
+        for (const shadowed of entry.shadowed)
+            sourceIds.add(shadowed.source.id);
+    }
+    for (const diagnostic of diagnostics)
+        sourceIds.add(diagnostic.source.id);
+    return {
+        ...domain,
+        entries,
+        diagnostics,
+        sources: domain.sources.filter((source) => sourceIds.has(source.id)),
+    };
+}
 function shadowDiagnostics(domain) {
     return Object.values(domain.entries).flatMap((entry) => entry.shadowed.map((shadowed) => ({
         severity: shadowed.reason === "source-shadowed" ? "warning" : "info",

package/dist/cli/config/migrate.js

@@ -14,6 +14,7 @@ import { hooksConfigDefinition, normalizeLegacyHookEntries, } from "../../mcp/ho
 import { mergeHookConfigs, parseHookConfig } from "../../mcp/hooks/hooks.js";
 import { canonicalSubagentProfileDocumentFromLegacy } from "../../subagents/profiles.js";
 import { resolveProjectContext } from "../../workspaces/state/project-context.js";
+import { parseConfigScopeArgs } from "./scope.js";
 export async function runConfigMigration(args) {
     const options = parseMigrationArgs(args);
     const files = loadForgeRelayFiles(process.env, { readLegacyHooks: true });
@@ -53,37 +54,20 @@ export async function runConfigMigration(args) {
     printPlan(plan);
 }
 function parseMigrationArgs(args) {
+    const scoped = parseConfigScopeArgs(args);
     let dryRun = false;
-    let scope;
-    let projectPath;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
+    for (const arg of scoped.rest) {
         if (arg === "--dry-run") {
             if (dryRun)
                 throw new Error("--dry-run may only be supplied once.");
             dryRun = true;
             continue;
         }
-        if (arg === "--global") {
-            if (scope)
-                throw new Error("Choose exactly one migration scope: --global or --project <path>.");
-            scope = "global";
-            continue;
-        }
-        if (arg === "--project") {
-            if (scope)
-                throw new Error("Choose exactly one migration scope: --global or --project <path>.");
-            const value = args[index + 1];
-            if (!value || value.startsWith("--"))
-                throw new Error("--project requires a project path.");
-            scope = "project";
-            projectPath = resolve(value);
-            index += 1;
-            continue;
-        }
         throw new Error(`Unknown config migrate option: ${arg}`);
     }
-    return { dryRun, scope: scope ?? "global", ...(projectPath ? { projectPath } : {}) };
+    return scoped.scope.mode === "global"
+        ? { dryRun, scope: "global" }
+        : { dryRun, scope: "project", projectPath: scoped.scope.projectRoot };
 }
 function buildGlobalMigrationPlan(configDir) {
     const files = loadForgeRelayFiles({ ...process.env, FORGERELAY_CONFIG_DIR: configDir }, { readLegacyHooks: true });

package/dist/cli/config/scope.js

@@ -0,0 +1,35 @@
+import { resolve } from "node:path";
+export function parseConfigScopeArgs(args, env = process.env) {
+    let global = false;
+    let projectRoot;
+    const rest = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--global") {
+            if (global || projectRoot)
+                throw new Error("--global and --project cannot be used together or repeated.");
+            global = true;
+            continue;
+        }
+        if (arg === "--project") {
+            if (global || projectRoot)
+                throw new Error("--global and --project cannot be used together or repeated.");
+            const value = args[index + 1];
+            if (!value || value.startsWith("--"))
+                throw new Error("--project requires a project path.");
+            projectRoot = resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === "--project-local") {
+            throw new Error("--project-local is not a public configuration scope.");
+        }
+        rest.push(arg);
+    }
+    return {
+        scope: global
+            ? { mode: "global" }
+            : { mode: "project", projectRoot: projectRoot ?? resolve(env.FORGERELAY_WORKSPACE_ROOT ?? process.cwd()) },
+        rest,
+    };
+}

package/dist/cli/connect/relay.js

@@ -0,0 +1,284 @@
+import { stdin as input, stdout as output } from "node:process";
+import * as prompts from "@clack/prompts";
+import { ensureForgeRelayInstanceId, loadForgeRelayFiles, removeForgeRelayRemote, renameForgeRelayRemote, writeForgeRelayRemote, } from "../../runtime/config/user-config.js";
+import { authenticateRemote, defaultRemoteAlias, isRemoteMcpUnauthorized, normalizeRemoteServiceTarget, refreshRemoteAuthentication, verifyRemoteMcp, } from "../../workspaces/relay/auth/remote-auth.js";
+import { defaultSshRouteAlias, parseSshRoute, readRemoteOwnerToken, withRemoteServiceEndpoint, } from "../../workspaces/relay/transport/remote-transport.js";
+export async function runRelayCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "__owner-token") {
+        if (rest.length > 0)
+            throw new Error("Internal owner-token command does not accept arguments.");
+        process.stdout.write(`${localOwnerToken()}\n`);
+        return;
+    }
+    if (subcommand === "list") {
+        if (rest.length > 0)
+            throw new Error("forgerelay connect relay list does not accept additional arguments.");
+        printRemoteList();
+        return;
+    }
+    if (subcommand === "status") {
+        if (rest.length > 1)
+            throw new Error("Usage: forgerelay connect relay status [alias]");
+        printRemoteStatus(rest[0]);
+        return;
+    }
+    if (subcommand === "rename") {
+        const [fromAlias, toAlias, ...extra] = rest;
+        if (!fromAlias || !toAlias || extra.length > 0) {
+            throw new Error("Usage: forgerelay connect relay rename <old-alias> <new-alias>");
+        }
+        await renameForgeRelayRemote(fromAlias, toAlias);
+        console.log(`Renamed remote ${fromAlias} to ${toAlias}.`);
+        return;
+    }
+    if (subcommand === "remove") {
+        const [alias, ...extra] = rest;
+        if (!alias || extra.length > 0) {
+            throw new Error("Usage: forgerelay connect relay remove <alias>");
+        }
+        await removeForgeRelayRemote(alias);
+        console.log(`Removed remote ${alias}.`);
+        return;
+    }
+    if (subcommand === "test") {
+        const [alias, ...extra] = rest;
+        if (!alias || extra.length > 0)
+            throw new Error("Usage: forgerelay connect relay test <alias>");
+        await testRemote(alias);
+        return;
+    }
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        printRelayHelp();
+        return;
+    }
+    let parsed = parseRelayCommandArgs(args);
+    if (!parsed.target) {
+        if (!input.isTTY || !output.isTTY) {
+            throw new Error("Missing remote service target in non-interactive mode. Pass a target or run `forgerelay connect relay` in an interactive terminal.");
+        }
+        parsed = await completeInteractiveRelaySetup(parsed);
+    }
+    await authenticateAndPersist(parsed);
+}
+function parseRelayCommandArgs(args) {
+    let target;
+    let alias;
+    let ownerToken;
+    let sshRoute;
+    let sshAuth = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--alias") {
+            alias = args[++index];
+            if (!alias)
+                throw new Error("Missing value for --alias.");
+            continue;
+        }
+        if (arg === "--token") {
+            ownerToken = args[++index];
+            if (!ownerToken)
+                throw new Error("Missing value for --token.");
+            continue;
+        }
+        if (arg === "-J") {
+            const route = args[++index];
+            if (!route)
+                throw new Error("Missing value for -J.");
+            sshRoute = parseSshRoute(route);
+            continue;
+        }
+        if (arg === "--ssh-auth") {
+            sshAuth = true;
+            continue;
+        }
+        if (arg.startsWith("-"))
+            throw new Error(`Unknown relay option: ${arg}`);
+        if (target)
+            throw new Error(`Unexpected relay argument: ${arg}`);
+        target = arg;
+    }
+    if (sshAuth && !sshRoute)
+        throw new Error("--ssh-auth requires -J <ssh-route>.");
+    if (sshAuth && ownerToken)
+        throw new Error("--ssh-auth and --token cannot be used together.");
+    return { target, alias, ownerToken, sshRoute, sshAuth };
+}
+async function completeInteractiveRelaySetup(parsed) {
+    const target = parsed.target ?? await promptText("Remote service target", "", (value) => value?.trim() ? undefined : "Enter the remote service target.");
+    let sshRoute = parsed.sshRoute;
+    if (!parsed.sshRoute) {
+        const selectedRoute = await prompts.select({
+            message: "Connection route",
+            initialValue: "direct",
+            options: [
+                { value: "direct", label: "Direct" },
+                { value: "ssh", label: "SSH" },
+            ],
+        });
+        if (prompts.isCancel(selectedRoute))
+            throw new Error("Remote connection setup cancelled.");
+        if (selectedRoute === "ssh") {
+            const route = await promptText("SSH route (-J)", "", (value) => value?.trim() ? undefined : "Enter the SSH route.");
+            sshRoute = parseSshRoute(route);
+        }
+    }
+    const normalizedTarget = normalizeRemoteServiceTarget(target);
+    const defaultAlias = sshRoute
+        ? defaultSshRouteAlias(sshRoute)
+        : defaultRemoteAlias(normalizedTarget);
+    const alias = parsed.alias ?? await promptText("Forge alias", defaultAlias);
+    let ownerToken = parsed.ownerToken;
+    let sshAuth = parsed.sshAuth;
+    if (!ownerToken && !sshAuth) {
+        if (sshRoute) {
+            const selectedAuthentication = await prompts.select({
+                message: "Authentication",
+                initialValue: "ssh",
+                options: [
+                    { value: "ssh", label: "Read owner token over SSH" },
+                    { value: "token", label: "Enter owner token locally" },
+                ],
+            });
+            if (prompts.isCancel(selectedAuthentication))
+                throw new Error("Remote connection setup cancelled.");
+            if (selectedAuthentication === "ssh")
+                sshAuth = true;
+            else
+                ownerToken = await promptOwnerToken();
+        }
+        else {
+            ownerToken = await promptOwnerToken();
+        }
+    }
+    return { target, alias, ownerToken, sshRoute, sshAuth };
+}
+async function authenticateAndPersist(parsed) {
+    if (!parsed.target)
+        throw new Error("Missing remote service target.");
+    const target = normalizeRemoteServiceTarget(parsed.target);
+    const authenticated = await withRemoteServiceEndpoint(target, parsed.sshRoute, async (endpoint) => {
+        const ownerToken = parsed.sshAuth
+            ? await readRemoteOwnerToken(parsed.sshRoute ?? [])
+            : await resolveOwnerToken(parsed.ownerToken);
+        return authenticateRemote(endpoint, ownerToken);
+    });
+    const remote = {
+        ...authenticated,
+        target,
+        ...(parsed.sshRoute ? { sshRoute: parsed.sshRoute } : {}),
+    };
+    const files = loadForgeRelayFiles();
+    const existingAlias = Object.entries(files.auth.remotes ?? {}).find(([, record]) => record.instanceId === remote.instanceId)?.[0];
+    const defaultAlias = parsed.sshRoute
+        ? defaultSshRouteAlias(parsed.sshRoute)
+        : defaultRemoteAlias(remote.target);
+    const alias = parsed.alias?.trim() || existingAlias || defaultAlias;
+    if (!files.auth.instanceId)
+        await ensureForgeRelayInstanceId();
+    await writeForgeRelayRemote(alias, remote);
+    console.log(`Authenticated remote ${alias} (${remote.instanceId}).`);
+}
+async function resolveOwnerToken(ownerToken) {
+    if (ownerToken)
+        return ownerToken;
+    if (!input.isTTY || !output.isTTY) {
+        throw new Error("Missing owner token. Pass --token, use --ssh-auth with -J, or run in an interactive terminal.");
+    }
+    return promptOwnerToken();
+}
+async function promptOwnerToken() {
+    const result = await prompts.password({
+        message: "Remote ForgeRelay owner token",
+        validate: (value) => value?.trim() ? undefined : "Enter the remote owner token.",
+    });
+    if (prompts.isCancel(result))
+        throw new Error("Remote connection setup cancelled.");
+    return String(result);
+}
+async function promptText(message, defaultValue, validate) {
+    const result = await prompts.text({
+        message,
+        ...(defaultValue ? { placeholder: defaultValue } : {}),
+        validate: (value) => validate?.(value?.trim() ? value : defaultValue),
+    });
+    if (prompts.isCancel(result))
+        throw new Error("Remote connection setup cancelled.");
+    const value = String(result).trim();
+    return value || defaultValue;
+}
+function localOwnerToken() {
+    const token = process.env.FORGERELAY_OAUTH_OWNER_TOKEN
+        ?? loadForgeRelayFiles().auth.ownerToken;
+    if (!token)
+        throw new Error("ForgeRelay owner token is not configured on this machine.");
+    return token;
+}
+function printRemoteList() {
+    const remotes = loadForgeRelayFiles().auth.remotes ?? {};
+    if (Object.keys(remotes).length === 0) {
+        console.log("No remote ForgeRelay instances registered.");
+        return;
+    }
+    for (const [alias, remote] of Object.entries(remotes).sort(([left], [right]) => left.localeCompare(right))) {
+        console.log(`${alias}\t${remote.target}\t${remote.instanceId}`);
+    }
+}
+function printRemoteStatus(alias) {
+    const remotes = loadForgeRelayFiles().auth.remotes ?? {};
+    if (alias) {
+        const remote = remotes[alias];
+        if (!remote)
+            throw new Error(`Unknown remote alias: ${alias}`);
+        console.log(`${alias}\tregistered\t${remote.target}\t${remote.instanceId}`);
+        return;
+    }
+    if (Object.keys(remotes).length === 0) {
+        console.log("No remote ForgeRelay instances registered.");
+        return;
+    }
+    for (const [name, remote] of Object.entries(remotes).sort(([left], [right]) => left.localeCompare(right))) {
+        console.log(`${name}\tregistered\t${remote.target}\t${remote.instanceId}`);
+    }
+}
+async function testRemote(alias) {
+    const files = loadForgeRelayFiles();
+    const storedRemote = files.auth.remotes?.[alias];
+    if (!storedRemote)
+        throw new Error(`Unknown remote alias: ${alias}`);
+    let remote = storedRemote;
+    await withRemoteServiceEndpoint(remote.target, remote.sshRoute, async (endpoint) => {
+        let refreshed = false;
+        if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
+            remote = await refreshRemoteAuthentication(remote, endpoint);
+            await writeForgeRelayRemote(alias, remote);
+            refreshed = true;
+        }
+        try {
+            await verifyRemoteMcp(remote, endpoint);
+        }
+        catch (error) {
+            if (refreshed || !isRemoteMcpUnauthorized(error))
+                throw error;
+            remote = await refreshRemoteAuthentication(remote, endpoint);
+            await writeForgeRelayRemote(alias, remote);
+            await verifyRemoteMcp(remote, endpoint);
+        }
+    });
+    console.log(`${alias}\tok\t${remote.instanceId}`);
+}
+function printRelayHelp() {
+    console.log([
+        "ForgeRelay connect relay",
+        "",
+        "Usage:",
+        "  forgerelay connect relay",
+        "  forgerelay connect relay <target> [--alias <name>] [--token <owner-token>]",
+        "  forgerelay connect relay -J <ssh-route> <target> [--ssh-auth|--token <owner-token>] [--alias <name>]",
+        "  forgerelay connect relay list",
+        "  forgerelay connect relay status [alias]",
+        "  forgerelay connect relay test <alias>",
+        "  forgerelay connect relay rename <old-alias> <new-alias>",
+        "  forgerelay connect relay remove <alias>",
+    ].join("\n"));
+}