@akira-tl/forgerelay 0.9.3 → 0.10.0

package/dist/cli/shell/setup.js

@@ -0,0 +1,99 @@
+import { defaultCommandShellSelection, normalizeCommandShellSelection, } from "../../runtime/shell/command-shell-runtime.js";
+export function commandShellSetupOptions(platform, current, launcher) {
+    const options = [];
+    if (current?.mode === "pinned") {
+        options.push({
+            value: "keep-pinned",
+            label: `Keep pinned ${current.family}`,
+            hint: current.executable,
+        });
+    }
+    options.push({
+        value: "follow-launcher",
+        label: "Follow the shell used to launch ForgeRelay",
+        hint: launcher
+            ? `Detected ${launcher.family ?? "shell"}: ${launcher.executable}`
+            : "Use the recorded fallback when no launcher shell can be identified.",
+    });
+    const families = platform === "win32"
+        ? ["pwsh", "powershell", "cmd", "bash"]
+        : ["bash", "zsh", "fish", "sh"];
+    for (const family of families) {
+        options.push({
+            value: family,
+            label: shellFamilyLabel(family),
+            hint: family === "bash" && platform !== "win32"
+                ? "Recommended compatibility path"
+                : undefined,
+        });
+    }
+    options.push({
+        value: "custom",
+        label: "Custom executable path",
+        hint: "Pin a portable/green install or a shell-development test binary.",
+    });
+    return options;
+}
+export function defaultCommandShellSetupChoice(current) {
+    return current?.mode === "pinned" ? "keep-pinned" : "follow-launcher";
+}
+export function followLauncherPreference(current, launcher, platform = process.platform, environment = process.env) {
+    const fallback = launcher
+        ?? (current?.mode === "follow-launcher" ? current : undefined)
+        ?? defaultCommandShellSelection(platform === "win32" ? "cmd" : "bash", platform, environment);
+    const normalized = normalizeCommandShellSelection(fallback, platform, environment, true);
+    const family = normalized.family ?? fallback.family;
+    if (!family)
+        throw new Error(`Unable to identify command-shell family for ${normalized.executable}.`);
+    return {
+        mode: "follow-launcher",
+        family,
+        executable: normalized.executable,
+    };
+}
+export function pinnedFamilyPreference(family, platform = process.platform, environment = process.env) {
+    const normalized = normalizeCommandShellSelection(defaultCommandShellSelection(family, platform, environment), platform, environment, true);
+    return {
+        mode: "pinned",
+        family,
+        executable: normalized.executable,
+    };
+}
+export function customPinnedPreference(family, executable, platform = process.platform, environment = process.env) {
+    const normalized = normalizeCommandShellSelection({ family, executable }, platform, environment, true);
+    return {
+        mode: "pinned",
+        family,
+        executable: normalized.executable,
+    };
+}
+export function preservePinnedPreference(current, platform = process.platform, environment = process.env) {
+    if (!current || current.mode !== "pinned") {
+        throw new Error("No pinned command-shell selection is available to preserve.");
+    }
+    return customPinnedPreference(current.family, current.executable, platform, environment);
+}
+export function commandShellCompatibilityWarning(family) {
+    if (family === "zsh") {
+        return "zsh is supported as an explicit command runtime, but Bash remains ForgeRelay's primary POSIX compatibility target. Agent commands and Hooks must use zsh syntax.";
+    }
+    if (family === "fish") {
+        return "fish may be selected explicitly, but ForgeRelay compatibility is less mature than Bash and native fish execution is not enabled until its runtime adapter is available. Agent commands and Hooks must use fish syntax when enabled.";
+    }
+    return undefined;
+}
+export function shellFamiliesForCustomSelection() {
+    return ["bash", "zsh", "fish", "sh", "pwsh", "powershell", "cmd"]
+        .map((family) => ({ value: family, label: shellFamilyLabel(family) }));
+}
+function shellFamilyLabel(family) {
+    switch (family) {
+        case "bash": return "Bash";
+        case "zsh": return "zsh";
+        case "fish": return "fish";
+        case "sh": return "POSIX sh";
+        case "pwsh": return "PowerShell 7 (pwsh)";
+        case "powershell": return "Windows PowerShell 5.1";
+        case "cmd": return "cmd.exe";
+    }
+}

package/dist/cli.js

@@ -9,7 +9,9 @@ import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as prompts from "@clack/prompts";
 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 { runHooksCommand } from "./mcp/hooks/hook-cli.js";
 import { executeSubagentSession } from "./subagents/sessions/execution.js";
 import { SubagentDeliveryMailbox } from "./subagents/sessions/delivery-mailbox.js";
@@ -19,21 +21,31 @@ import { parseSubagentRunArgs } from "./subagents/cli-target.js";
 import { ensureForgeRelayInstanceId, loadForgeRelayFiles, removeForgeRelayRemote, renameForgeRelayRemote, writeForgeRelayConfig, writeForgeRelayRemote, } from "./runtime/config/user-config.js";
 import { shutdownHttpServer } from "./mcp/server/transport/server-shutdown.js";
 import { publicEndpointUrl } from "./mcp/oauth/public-url.js";
+import { assertRuntimePrivilegeAllowed, detectRuntimePrivilege, elevatedRuntimeWarning, formatRuntimePrivilege, } from "./runtime/security/runtime-privilege.js";
+import { formatCommandShellRuntime } from "./runtime/shell/command-shell-runtime.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";
 import { assertSupportedNode, checkBashShell, checkGitAvailable, checkSqliteNative, nodeVersionStatus, normalizeOptionalPublicBaseUrl, } from "./cli/setup-support.js";
 const require = createRequire(import.meta.url);
 async function main(argv) {
     assertSupportedNode();
-    const [rawCommand, ...args] = argv;
-    const command = normalizeCommand(rawCommand);
+    const [rawCommand, ...rest] = argv;
+    const defaultServeFlag = rawCommand === "--allow-elevated";
+    const command = defaultServeFlag ? "serve" : normalizeCommand(rawCommand);
+    const args = defaultServeFlag ? argv : rest;
     switch (command) {
-        case "serve":
+        case "serve": {
+            const serveOptions = parseServeCommandArgs(args);
+            const runtimePrivilege = detectRuntimePrivilege();
+            assertRuntimePrivilegeAllowed(runtimePrivilege, serveOptions.allowElevated);
+            if (serveOptions.allowElevated)
+                console.warn(elevatedRuntimeWarning(runtimePrivilege));
             await ensureConfigured();
-            await serve();
+            await serve(runtimePrivilege);
             return;
+        }
         case "init":
-            await runInit({ force: args.includes("--force") });
+            await runInit({ force: args.includes("--force"), version: installedForgeRelayVersion() });
             return;
         case "doctor":
             await runDoctor();
@@ -50,6 +62,9 @@ async function main(argv) {
         case "auth":
             await runAuthCommand(args);
             return;
+        case "maintenance":
+            runMaintenanceCommand(args);
+            return;
         case "help":
             printHelp();
             return;
@@ -61,7 +76,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")
+    if (command === "init" || command === "doctor" || command === "config" || command === "hooks" || command === "agents" || command === "auth" || command === "maintenance")
         return command;
     if (command === "help" || command === "--help" || command === "-h")
         return "help";
@@ -69,6 +84,19 @@ function normalizeCommand(command) {
         return "version";
     throw new Error(`Unknown command: ${command}`);
 }
+function parseServeCommandArgs(args) {
+    let allowElevated = false;
+    for (const arg of args) {
+        if (arg === "--allow-elevated") {
+            if (allowElevated)
+                throw new Error("--allow-elevated may only be supplied once.");
+            allowElevated = true;
+            continue;
+        }
+        throw new Error(`Unknown serve option: ${arg}`);
+    }
+    return { allowElevated };
+}
 async function ensureConfigured() {
     const files = loadForgeRelayFiles();
     if (files.configExists && files.authExists) {
@@ -89,9 +117,9 @@ async function ensureConfigured() {
             "Or provide FORGERELAY_OAUTH_OWNER_TOKEN and FORGERELAY_ALLOWED_ROOTS.",
         ].join("\n"));
     }
-    await runInit({ force: false });
+    await runInit({ force: false, version: installedForgeRelayVersion() });
 }
-async function serve() {
+async function serve(runtimePrivilege) {
     const sqliteStatus = checkSqliteNative();
     if (sqliteStatus !== "ok") {
         throw new Error([
@@ -104,9 +132,19 @@ async function serve() {
     }
     const { createServer } = await import("./server.js");
     const config = loadConfig();
-    const { app, close, subagentProviders } = createServer(config);
+    config.runtimePrivilege = runtimePrivilege;
+    const runtimeLease = acquireRuntimeLease(config.stateDir);
+    let server;
+    try {
+        server = createServer(config);
+    }
+    catch (error) {
+        runtimeLease.release();
+        throw error;
+    }
+    const { app, close, subagentProviders } = server;
     const httpServer = app.listen(config.port, config.host, () => {
-        console.log(`forgerelay listening on http://${config.host}:${config.port}/mcp`);
+        console.log(`forgerelay listening on http://${config.host}:${config.port}${publicEndpointUrl(config.publicBaseUrl, "mcp").pathname}`);
         console.log(`client-facing base url: ${config.publicBaseUrl}`);
         console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
         console.log(`allowed hosts: ${config.allowedHosts.join(", ")}`);
@@ -114,17 +152,27 @@ async function serve() {
             console.warn("warning: Host header allowlist is disabled because FORGERELAY_ALLOWED_HOSTS=*");
         }
         console.log("auth: Owner password approval required");
+        console.log(`command shell: ${formatCommandShellRuntime(config.commandShellRuntime)}`);
+        console.log(`runtime privilege: ${formatRuntimePrivilege(runtimePrivilege)}`);
         console.log(`logging: ${config.logging.level} ${config.logging.format}`);
         if (config.subagents) {
             console.log(`subagent providers: ${formatSubagentProviderAvailabilitySummary(subagentProviders)}`);
         }
     });
     let shuttingDown = false;
+    const releaseRuntimeLease = () => runtimeLease.release();
+    process.once("exit", releaseRuntimeLease);
     const shutdown = async () => {
         if (shuttingDown)
             return;
         shuttingDown = true;
-        await shutdownHttpServer(httpServer, close);
+        try {
+            await shutdownHttpServer(httpServer, close);
+        }
+        finally {
+            process.removeListener("exit", releaseRuntimeLease);
+            runtimeLease.release();
+        }
         process.exit(0);
     };
     const handleShutdown = () => {
@@ -303,18 +351,20 @@ async function runDoctor() {
     console.log(`Node: ${process.version} (${nodeVersionStatus()})`);
     console.log(`Node ABI: ${process.versions.modules}`);
     console.log(`Platform: ${process.platform} ${process.arch}`);
+    console.log(`Runtime privilege: ${formatRuntimePrivilege(detectRuntimePrivilege())}`);
     console.log(`Git: ${checkGitAvailable()}`);
     console.log(`Bash shell: ${checkBashShell()}`);
     console.log(`SQLite native dependency: ${checkSqliteNative()}`);
     try {
         const config = loadConfig();
-        console.log(`Bind MCP URL: http://${config.host}:${config.port}/mcp`);
+        console.log(`Bind MCP URL: http://${config.host}:${config.port}${publicEndpointUrl(config.publicBaseUrl, "mcp").pathname}`);
         console.log(`Client-facing base URLs: ${config.publicBaseUrls.join(", ")}`);
         console.log(`Client-facing base URL: ${config.publicBaseUrl}`);
         console.log(`Client-facing MCP URL: ${publicEndpointUrl(config.publicBaseUrl, "mcp").toString()}`);
+        console.log(`Command shell: ${formatCommandShellRuntime(config.commandShellRuntime)}`);
         console.log(`Tool mode: ${config.toolMode}`);
         console.log(`Widgets: ${config.widgets}`);
-        console.log(`Trust proxy: ${config.logging.trustProxy ? "one hop" : "off"}`);
+        console.log(`Trust proxy: ${config.proxyTrust === false ? "off" : config.proxyTrust.join(", ")}`);
         console.log(`Artifacts: ${config.artifactsEnabled ? "enabled" : "disabled"}`);
         console.log(`Subagents: ${config.subagents ? "enabled" : "disabled"}`);
         console.log(`Skills: ${config.skillsEnabled ? "enabled" : "disabled"}`);
@@ -355,6 +405,8 @@ function printHelp() {
         "Usage:",
         "  forgerelay                 Run first-time setup if needed, then start the server",
         "  forgerelay serve           Start the server",
+        "  forgerelay serve --allow-elevated",
+        "                            Explicitly allow this invocation to run with elevated/unknown OS privilege",
         "  forgerelay init            Create or update ~/.forgerelay/config.json and auth.json",
         "  forgerelay doctor          Show config, runtime, and native dependency status",
         "  forgerelay config get      Print persisted config",
@@ -370,6 +422,7 @@ function printHelp() {
         "  forgerelay auth test <alias>",
         "  forgerelay auth rename <old-alias> <new-alias>",
         "  forgerelay auth remove <alias>",
+        "  forgerelay maintenance inspect [--json]",
         "  forgerelay -v, --version   Print the installed version",
         "",
         "For temporary tunnels:",
@@ -547,12 +600,15 @@ function printAgentsHelp() {
         "  forgerelay agents show <id>",
     ].join("\n"));
 }
-function printVersion() {
+function installedForgeRelayVersion() {
     const packageJson = require("../package.json");
-    if (typeof packageJson.version !== "string") {
+    if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
         throw new Error("Unable to read ForgeRelay package version.");
     }
-    console.log(packageJson.version);
+    return packageJson.version;
+}
+function printVersion() {
+    console.log(installedForgeRelayVersion());
 }
 main(process.argv.slice(2)).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));

package/dist/mcp/hooks/hooks.js

@@ -2,7 +2,8 @@ import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { performance } from "node:perf_hooks";
 import { commandPreview, logEvent, workspaceLogLabel } from "../../runtime/logging/logger.js";
-import { resolveShellCommand } from "../process/process-platform.js";
+import { resolveCompatibilityCommandShellRuntime, snapshotCommandShellRuntime, } from "../../runtime/shell/command-shell-runtime.js";
+import { resolveShellCommandForRuntime } from "../process/process-platform.js";
 import { executeHookCommand, hookFailureOutput } from "./command-runner.js";
 export const HOOK_EVENTS = [
     "WorkspaceOpen",
@@ -212,11 +213,13 @@ export class HookRunner {
     logging;
     baseEnv;
     resultDecorator;
-    constructor(hooks, logging, baseEnv = process.env, resultDecorator) {
+    commandShellRuntime;
+    constructor(hooks, logging, baseEnv = process.env, resultDecorator, commandShellRuntime) {
         this.hooks = hooks;
         this.logging = logging;
         this.baseEnv = baseEnv;
         this.resultDecorator = resultDecorator;
+        this.commandShellRuntime = snapshotCommandShellRuntime(commandShellRuntime ?? resolveCompatibilityCommandShellRuntime(process.platform, baseEnv));
     }
     decorateResult(workspaceId, result) {
         return (this.resultDecorator?.(workspaceId, result) ?? result);
@@ -274,7 +277,7 @@ export class HookRunner {
     async runHandler(event, handler, index, invocation, scope, signal) {
         const startedAt = performance.now();
         const name = handler.name ?? `${event} handler ${index + 1}`;
-        const shell = resolveShellCommand(handler.command, process.platform, this.baseEnv);
+        const shell = resolveShellCommandForRuntime(handler.command, this.commandShellRuntime);
         const detached = process.platform !== "win32";
         const env = hookEnvironment(this.baseEnv, event, invocation);
         try {

package/dist/mcp/oauth/public-url.js

@@ -7,6 +7,9 @@ export function publicEndpointUrl(baseUrl, suffix) {
     url.hash = "";
     return url;
 }
+export function publicEndpointPaths(baseUrls, suffix) {
+    return Array.from(new Set(baseUrls.map((baseUrl) => publicEndpointUrl(baseUrl, suffix).pathname)));
+}
 export function oauthAuthorizationServerMetadataPath(issuerUrl) {
     const issuer = new URL(issuerUrl instanceof URL ? issuerUrl.href : issuerUrl);
     const issuerPath = issuer.pathname === "/" ? "" : issuer.pathname.replace(/\/+$/, "");

package/dist/mcp/oauth/router.js

@@ -5,9 +5,9 @@ import { tokenHandler } from "@modelcontextprotocol/sdk/server/auth/handlers/tok
 import { clientRegistrationHandler } from "@modelcontextprotocol/sdk/server/auth/handlers/register.js";
 import { revocationHandler } from "@modelcontextprotocol/sdk/server/auth/handlers/revoke.js";
 import { metadataHandler } from "@modelcontextprotocol/sdk/server/auth/handlers/metadata.js";
-import { oauthAuthorizationServerMetadataPath, publicEndpointUrl, } from "./public-url.js";
+import { oauthAuthorizationServerMetadataPath, publicEndpointPaths, publicEndpointUrl, } from "./public-url.js";
 export function createForgeRelayAuthRouter(options) {
-    const { provider, cliAuthenticationProvider, instanceId, issuerUrl, resourceServerUrl, scopesSupported, resourceName, } = options;
+    const { provider, cliAuthenticationProvider, instanceId, issuerUrl, resourceServerUrl, routeBaseUrls = [issuerUrl], scopesSupported, resourceName, } = options;
     const authorizationEndpoint = publicEndpointUrl(issuerUrl, "authorize");
     const tokenEndpoint = publicEndpointUrl(issuerUrl, "token");
     const registrationEndpoint = provider.clientsStore.registerClient
@@ -16,6 +16,11 @@ export function createForgeRelayAuthRouter(options) {
     const revocationEndpoint = provider.revokeToken
         ? publicEndpointUrl(issuerUrl, "revoke")
         : undefined;
+    const cliAuthenticationPaths = publicEndpointPaths(routeBaseUrls, "auth/cli");
+    const authorizationPaths = publicEndpointPaths(routeBaseUrls, "authorize");
+    const tokenPaths = publicEndpointPaths(routeBaseUrls, "token");
+    const registrationPaths = publicEndpointPaths(routeBaseUrls, "register");
+    const revocationPaths = publicEndpointPaths(routeBaseUrls, "revoke");
     const oauthMetadata = {
         ...createOAuthMetadata({
             provider,
@@ -36,7 +41,7 @@ export function createForgeRelayAuthRouter(options) {
     };
     const router = express.Router();
     if (cliAuthenticationProvider) {
-        router.post("/auth/cli", express.json({ limit: "4kb" }), (req, res) => {
+        router.post(cliAuthenticationPaths, express.json({ limit: "4kb" }), (req, res) => {
             const ownerToken = typeof req.body?.owner_token === "string" ? req.body.owner_token : undefined;
             const refreshToken = typeof req.body?.refresh_token === "string" ? req.body.refresh_token : undefined;
             if ((ownerToken ? 1 : 0) + (refreshToken ? 1 : 0) !== 1) {
@@ -55,13 +60,13 @@ export function createForgeRelayAuthRouter(options) {
             res.status(200).json({ ...tokens, ...(instanceId ? { instance_id: instanceId } : {}) });
         });
     }
-    router.use("/authorize", authorizationHandler({ provider }));
-    router.use("/token", tokenHandler({ provider }));
-    if (provider.clientsStore.registerClient) {
-        router.use("/register", clientRegistrationHandler({ clientsStore: provider.clientsStore }));
+    router.use(authorizationPaths, authorizationHandler({ provider }));
+    router.use(tokenPaths, tokenHandler({ provider }));
+    if (provider.clientsStore.registerClient && registrationEndpoint) {
+        router.use(registrationPaths, clientRegistrationHandler({ clientsStore: provider.clientsStore }));
     }
-    if (provider.revokeToken) {
-        router.use("/revoke", revocationHandler({ provider }));
+    if (provider.revokeToken && revocationEndpoint) {
+        router.use(revocationPaths, revocationHandler({ provider }));
     }
     router.use(oauthAuthorizationServerMetadataPath(issuerUrl), metadataHandler(oauthMetadata));
     router.use(new URL(getOAuthProtectedResourceMetadataUrl(resourceServerUrl)).pathname, metadataHandler(protectedResourceMetadata));

package/dist/mcp/process/process-platform.js

@@ -1,5 +1,5 @@
-import { basename } from "node:path";
 import { spawnSync } from "node:child_process";
+import { resolveCompatibilityCommandShellRuntime, } from "../../runtime/shell/command-shell-runtime.js";
 const defaultProcessTreeRuntime = {
     platform: process.platform,
     killGroup: (pid, signal) => process.kill(-pid, signal),
@@ -11,37 +11,35 @@ const defaultProcessTreeRuntime = {
         return !result.error && result.status === 0;
     },
 };
-const POSIX_SHELLS = new Set(["ash", "dash", "ksh", "sh"]);
 export function resolveShellCommand(command, platform = process.platform, environment = process.env) {
-    if (platform === "win32") {
-        return {
-            executable: environment.ComSpec ?? environment.COMSPEC ?? "cmd.exe",
-            // Match Node's native `spawn(command, { shell: cmd.exe })` quoting.
-            // cmd.exe /S applies special quote stripping, so the whole command must
-            // be wrapped even when the executable inside it is already quoted.
-            args: ["/d", "/s", "/c", `"${command}"`],
-            windowsVerbatimArguments: true,
-        };
-    }
+    return resolveShellCommandForRuntime(command, resolveCompatibilityCommandShellRuntime(platform, environment));
+}
+export function resolveShellCommandForRuntime(command, runtime) {
     // Agent and Hook commands must not source the user's interactive/login shell
     // configuration. ForgeRelay already inherits PATH and other environment from
     // the process that launched the server; re-running zsh/bash as a login shell
     // can inject prompts, banners, aliases, plugins, or other user-only behavior.
-    const configuredShell = environment.FORGERELAY_COMMAND_SHELL?.trim();
-    const executable = configuredShell || (platform === "linux" || platform === "darwin"
-        ? "/bin/bash"
-        : "/bin/sh");
-    const shellName = basename(executable);
-    if (shellName === "bash") {
-        return { executable, args: ["--noprofile", "--norc", "-c", command] };
-    }
-    if (shellName === "zsh") {
-        return { executable, args: ["-f", "-c", command] };
-    }
-    if (POSIX_SHELLS.has(shellName)) {
-        return { executable, args: ["-c", command] };
+    switch (runtime.family) {
+        case "cmd":
+            return {
+                executable: runtime.executable,
+                // Match Node's native `spawn(command, { shell: cmd.exe })` quoting.
+                // cmd.exe /S applies special quote stripping, so the whole command must
+                // be wrapped even when the executable inside it is already quoted.
+                args: ["/d", "/s", "/c", `"${command}"`],
+                windowsVerbatimArguments: true,
+            };
+        case "bash":
+            return { executable: runtime.executable, args: ["--noprofile", "--norc", "-c", command] };
+        case "zsh":
+            return { executable: runtime.executable, args: ["-f", "-c", command] };
+        case "sh":
+            return { executable: runtime.executable, args: ["-c", command] };
+        case "fish":
+        case "pwsh":
+        case "powershell":
+            throw new Error(`Command shell runtime ${runtime.family} is identified but native execution support is not enabled in this release stage. ForgeRelay will not silently execute the command through another shell.`);
     }
-    return { executable: "/bin/sh", args: ["-c", command] };
 }
 export function terminateProcessTree(child, signal, detached, runtime = defaultProcessTreeRuntime) {
     if (runtime.platform === "win32" && child.pid) {

package/dist/mcp/process/process-sessions.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
-import { resolveShellCommand, terminateProcessTree } from "./process-platform.js";
+import { resolveShellCommandForRuntime, terminateProcessTree } from "./process-platform.js";
+import { resolveCompatibilityCommandShellRuntime, snapshotCommandShellRuntime } from "../../runtime/shell/command-shell-runtime.js";
 const DEFAULT_EXEC_YIELD_MS = 10_000;
 const DEFAULT_INTERACTIVE_YIELD_MS = 250;
 export const DEFAULT_POLL_YIELD_MS = 60_000;
@@ -210,6 +211,7 @@ export class ProcessManager {
     maxStartYieldMs;
     monotonicNow;
     outputAudit;
+    commandShellRuntime;
     nextProcessId = 1;
     constructor(options = {}) {
         this.maxBufferCharacters = options.maxBufferCharacters ?? DEFAULT_BUFFER_CHARACTERS;
@@ -227,6 +229,7 @@ export class ProcessManager {
         this.maxStartYieldMs = options.maxStartYieldMs ?? MAX_START_YIELD_MS;
         this.monotonicNow = options.monotonicNow ?? (() => performance.now());
         this.outputAudit = options.outputAudit;
+        this.commandShellRuntime = snapshotCommandShellRuntime(options.commandShellRuntime ?? resolveCompatibilityCommandShellRuntime());
     }
     async start(input) {
         input.signal?.throwIfAborted();
@@ -435,7 +438,7 @@ export class ProcessManager {
         };
     }
     startPipe(processEntry, input) {
-        const shell = resolveShellCommand(input.command);
+        const shell = resolveShellCommandForRuntime(input.command, this.commandShellRuntime);
         const detached = process.platform !== "win32";
         const child = spawn(shell.executable, shell.args, {
             cwd: input.cwd,
@@ -467,7 +470,7 @@ export class ProcessManager {
         catch {
             throw new Error("PTY support requires the optional node-pty dependency.");
         }
-        const shell = resolveShellCommand(input.command);
+        const shell = resolveShellCommandForRuntime(input.command, this.commandShellRuntime);
         let pty;
         try {
             pty = nodePty.spawn(shell.executable, shell.args, {

package/dist/mcp/server/transport/http-server.js

@@ -16,7 +16,7 @@ import { createOpenAIIncomingArtifactAdapter } from "../../artifacts/incoming-ar
 import { logEvent, requestPath, transportSessionIdPrefix } from "../../../runtime/logging/logger.js";
 import { SingleUserOAuthProvider } from "../../oauth/oauth-provider.js";
 import { createForgeRelayAuthRouter } from "../../oauth/router.js";
-import { publicEndpointUrl } from "../../oauth/public-url.js";
+import { publicEndpointPaths, publicEndpointUrl } from "../../oauth/public-url.js";
 import { McpTransportRegistry } from "./mcp-sessions.js";
 import { ProcessManager } from "../../process/process-sessions.js";
 import { createReviewCheckpointManager } from "../../../workspaces/review/review-checkpoints.js";
@@ -45,7 +45,11 @@ export function createHttpServer(config, options, createMcpServer) {
     const transports = new McpTransportRegistry({
         maxTransports: MAX_MCP_TRANSPORT_SESSIONS,
     });
+    const routeBaseUrls = config.publicBaseUrls.map((baseUrl) => new URL(baseUrl));
     const mcpUrl = publicEndpointUrl(config.publicBaseUrl, "mcp");
+    const mcpPaths = publicEndpointPaths(routeBaseUrls, "mcp");
+    const activityPanelAssetsPaths = publicEndpointPaths(routeBaseUrls, "mcp-app-assets");
+    const healthPaths = publicEndpointPaths(routeBaseUrls, "healthz");
     const resourceServerUrl = resourceUrlFromServerUrl(mcpUrl);
     const oauthProvider = new SingleUserOAuthProvider(config.oauth, mcpUrl, config.stateDir);
     const bearerAuth = requireBearerAuth({
@@ -67,7 +71,10 @@ export function createHttpServer(config, options, createMcpServer) {
         turnIdForConversation: (conversationScopeId, workspaceId) => activityQueries.currentTurnId(conversationScopeId, workspaceId),
     });
     const reviewCheckpoints = createReviewCheckpointManager();
-    const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
+    const processSessions = new ProcessManager({
+        outputAudit: bashOutputStore,
+        commandShellRuntime: config.commandShellRuntime,
+    });
     const codeIntelligence = new CodeIntelligenceManager(config);
     const subagentProviders = config.subagents
         ? getSubagentProviderAvailabilitySnapshot()
@@ -140,8 +147,8 @@ export function createHttpServer(config, options, createMcpServer) {
     }, MCP_TRANSPORT_CLEANUP_INTERVAL_MS);
     transportCleanupTimer.unref();
     logRuntimeResources();
-    if (config.logging.trustProxy) {
-        app.set("trust proxy", 1);
+    if (config.proxyTrust !== false) {
+        app.set("trust proxy", config.proxyTrust);
     }
     app.use((req, res, next) => {
         const requestId = randomUUID();
@@ -151,7 +158,7 @@ export function createHttpServer(config, options, createMcpServer) {
             const path = requestPath(req);
             if (!config.logging.requests)
                 return;
-            if (!config.logging.assets && path.startsWith("/mcp-app-assets"))
+            if (!config.logging.assets && activityPanelAssetsPaths.some((assetPath) => path.startsWith(assetPath)))
                 return;
             logEvent(config.logging, "info", "http_request", {
                 requestId,
@@ -170,23 +177,24 @@ export function createHttpServer(config, options, createMcpServer) {
         instanceId: config.instanceId,
         issuerUrl: new URL(config.publicBaseUrl),
         resourceServerUrl,
+        routeBaseUrls,
         scopesSupported: config.oauth.scopes,
         resourceName: "ForgeRelay",
     }));
-    app.options("/mcp-app-assets/{*asset}", (_req, res) => {
+    app.options(activityPanelAssetsPaths.map((assetPath) => `${assetPath}/{*asset}`), (_req, res) => {
         setActivityPanelAssetHeaders(res);
         res.sendStatus(204);
     });
-    app.use("/mcp-app-assets", express.static(activityPanelAssetDirectory(), {
+    app.use(activityPanelAssetsPaths, express.static(activityPanelAssetDirectory(), {
         immutable: true,
         maxAge: "1y",
         fallthrough: false,
         setHeaders: setActivityPanelAssetHeaders,
     }));
-    app.get("/healthz", (_req, res) => {
+    app.get(healthPaths, (_req, res) => {
         res.json({ ok: true, name: "forgerelay" });
     });
-    app.all("/mcp", async (req, res) => {
+    app.all(mcpPaths, async (req, res) => {
         const requestId = res.locals.requestId;
         const transportSessionId = req.header("mcp-session-id");
         const initializeRequest = req.method === "POST" && isInitializeRequest(req.body);

package/dist/mcp/server/workspace/runtime/workspace-open-presentation.js

@@ -71,6 +71,10 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
     const cardAvailableAgentsFiles = availableAgentsFiles.map((file) => ({
         path: formatAgentsPath(file.path, workspace.root),
     }));
+    const cardWorkspaceInstructions = workspace.workspaceInstructions.map((instruction) => ({
+        path: formatAgentsPath(instruction.path, workspace.root),
+        status: instruction.status,
+    }));
     const bootstrapComponents = new Set(effectiveBootstrapContextComponents);
     const visibleSkills = bootstrapComponents.has("skills") ? cardSkills : [];
     const visibleSkillDiagnostics = bootstrapComponents.has("skillDiagnostics")
@@ -185,6 +189,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
         capabilityCatalog,
         agentsFiles: cardAgentsFiles,
         availableAgentsFiles: cardAvailableAgentsFiles,
+        workspaceInstructions: cardWorkspaceInstructions,
         skills: cardSkills,
         agentProviders: cardAgentProviders,
         agents: cardAgents,
@@ -193,6 +198,7 @@ export async function presentLocalWorkspaceOpen(options, input, contextData) {
             mode: workspace.mode,
             agentsFiles: cardAgentsFiles.length,
             availableAgentsFiles: cardAvailableAgentsFiles.length,
+            workspaceInstructions: cardWorkspaceInstructions.length,
             skills: cardSkills.length,
             capabilities: capabilityCatalog.length,
             agentProviders: cardAgentProviders.length,

package/dist/mcp/server/workspace/runtime/workspace-tools.js

@@ -26,7 +26,7 @@ export function registerWorkspaceAuxiliaryTools(options) {
         outputSchema: {
             path: z.string(),
             content: z.string(),
-            status: z.enum(["loaded", "available"]),
+            status: z.enum(["loaded", "available", "disabled"]),
         },
         _meta: { ui: { visibility: ["app"] } },
         annotations: {