@akira-tl/forgerelay 1.2.4 → 1.3.0

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

@@ -2,6 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { parse as parseYaml } from "yaml";
+import { parseConfigSource } from "../../runtime/config/definition/definition.js";
 import { configSchemaId } from "../../runtime/config/definition/schema.js";
 import { generalConfigDefinition } from "../../runtime/config/definition/general-config.js";
 import { externalMcpConfigDefinition } from "../../runtime/config/definition/external-mcp.js";
@@ -13,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 });
@@ -52,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 });
@@ -137,8 +122,10 @@ function buildGlobalMigrationPlan(configDir) {
         nextConfig.$schema = generalSchema;
         configChanged = true;
     }
-    if (configChanged)
-        writes.push(jsonWrite(files.configPath, nextConfig));
+    if (configChanged) {
+        const validatedConfig = parseConfigSource(generalConfigDefinition, "user", nextConfig);
+        writes.push(jsonWrite(files.configPath, validatedConfig));
+    }
     if (configChanged && files.configExists)
         backupSources.push({ path: files.configPath, relativePath: "config.json" });
     if (files.hooksExists)

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"));
+}

package/dist/cli/core/command-tree.js

@@ -0,0 +1,68 @@
+export const CLI_ROOT_ROUTES = [
+    { command: "serve", handler: "serve", publicSummary: "Start the ForgeRelay runtime" },
+    { command: "init", handler: "init", publicSummary: "Run first-time or setup-owned configuration" },
+    { command: "config", handler: "config", publicSummary: "Inspect and mutate declarative configuration" },
+    { command: "connect", handler: "connect", publicSummary: "Manage remote ForgeRelay and External MCP relationships" },
+    { command: "system", handler: "system", publicSummary: "Diagnose and maintain ForgeRelay" },
+    { command: "help", handler: "help", publicSummary: "Show this help" },
+    { command: "version", handler: "version", publicSummary: "Print the installed version" },
+    // Compatibility-only routes. These remain dispatchable during the supported
+    // compatibility window but never appear in generated public root help.
+    { command: "start", handler: "serve" },
+    { command: "doctor", handler: "system", argsPrefix: ["doctor"] },
+    { command: "hooks", handler: "config", argsPrefix: ["hooks", "--compat"] },
+    { command: "auth", handler: "connect", argsPrefix: ["relay"] },
+    { command: "mcp", handler: "connect", argsPrefix: ["mcp"] },
+    { command: "maintenance", handler: "system" },
+    { command: "agents", compatibilityHandler: "agents" },
+    { command: "--help", handler: "help" },
+    { command: "-h", handler: "help" },
+    { command: "--version", handler: "version" },
+    { command: "-v", handler: "version" },
+];
+export function resolveCliRootRoute(command) {
+    if (command === undefined)
+        return { command: "help", handler: "help" };
+    const route = CLI_ROOT_ROUTES.find((candidate) => candidate.command === command);
+    if (!route)
+        throw new Error(`Unknown command: ${command}`);
+    return route;
+}
+export function routeArguments(route, args) {
+    return [...(route.argsPrefix ?? []), ...args];
+}
+const SERVE_OPTION_HELP_LINES = [
+    "--host <host>             Override the bind host for this invocation",
+    "--port <port>             Override the listen port for this invocation",
+    "--root <path>             Override allowed roots; repeat for multiple roots",
+    "--public-url <url>        Override client-facing base URLs; repeat for multiple URLs",
+    "--allow-elevated          Explicitly allow this invocation to run with elevated/unknown OS privilege",
+];
+export function renderCliRootHelp() {
+    const publicRoutes = CLI_ROOT_ROUTES.filter((route) => route.publicSummary !== undefined);
+    const commandWidth = Math.max(...publicRoutes.map((route) => route.command.length));
+    return [
+        "ForgeRelay",
+        "",
+        "Usage:",
+        "  forgerelay                         Show help",
+        "  forgerelay <command> [options]     Run a command",
+        "",
+        "Commands:",
+        ...publicRoutes.map((route) => `  forgerelay ${route.command.padEnd(commandWidth)}  ${route.publicSummary}`),
+        "",
+        "Serve options:",
+        ...SERVE_OPTION_HELP_LINES.map((line) => `  forgerelay serve ${line}`),
+    ].join("\n");
+}
+export function renderServeHelp() {
+    return [
+        "ForgeRelay serve",
+        "",
+        "Usage:",
+        "  forgerelay serve [options]",
+        "",
+        "Options:",
+        ...SERVE_OPTION_HELP_LINES.map((line) => `  ${line}`),
+    ].join("\n");
+}

package/dist/cli/core/serve-options.js

@@ -0,0 +1,71 @@
+import { normalizeAllowedRootPath } from "../../runtime/config/validation/paths.js";
+import { normalizePublicBaseUrlsInput, validateBindAddress, validateClientFacingBaseUrls, validatePort, } from "../setup-support.js";
+export function parseServeCommandArgs(args) {
+    let allowElevated = false;
+    let host;
+    let port;
+    const roots = [];
+    const publicBaseUrls = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--allow-elevated") {
+            if (allowElevated)
+                throw new Error("--allow-elevated may only be supplied once.");
+            allowElevated = true;
+            continue;
+        }
+        if (arg === "--host") {
+            if (host !== undefined)
+                throw new Error("--host may only be supplied once.");
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error("Missing value for --host.");
+            const validation = validateBindAddress(value);
+            if (validation)
+                throw new Error(`Invalid --host: ${validation}`);
+            host = value.trim();
+            continue;
+        }
+        if (arg === "--port") {
+            if (port !== undefined)
+                throw new Error("--port may only be supplied once.");
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error("Missing value for --port.");
+            const validation = validatePort(value);
+            if (validation)
+                throw new Error(`Invalid --port: ${validation}`);
+            port = Number(value);
+            continue;
+        }
+        if (arg === "--root") {
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error("Missing value for --root.");
+            roots.push(normalizeAllowedRootPath(value));
+            continue;
+        }
+        if (arg === "--public-url") {
+            const value = args[++index];
+            if (value === undefined)
+                throw new Error("Missing value for --public-url.");
+            const validation = validateClientFacingBaseUrls(value);
+            if (validation)
+                throw new Error(`Invalid --public-url: ${validation}`);
+            publicBaseUrls.push(...normalizePublicBaseUrlsInput(value));
+            continue;
+        }
+        throw new Error(`Unknown serve option: ${arg}`);
+    }
+    return {
+        allowElevated,
+        runtimeOverrides: {
+            ...(host === undefined ? {} : { host }),
+            ...(port === undefined ? {} : { port }),
+            ...(roots.length === 0 ? {} : { allowedRoots: roots }),
+            ...(publicBaseUrls.length === 0
+                ? {}
+                : { publicBaseUrl: Array.from(new Set(publicBaseUrls)) }),
+        },
+    };
+}