@akira-tl/forgerelay 0.5.6 → 0.6.0

package/CHANGELOG.md

@@ -4,6 +4,49 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-08-27
+
+### Added
+
+- Added the unified ForgeRelay Panel for ChatGPT MCP App hosts: one Host Turn now keeps the Workspace Summary above a collapsible Activity Panel, groups live Activities, lazily loads detailed operation data, and streams durable Bash output without turning follow-up process control into duplicate top-level Activities.
+- Added a local MCP Inspector debug host on the dedicated `127.0.0.1:7677` path so the real HTTP/OAuth/MCP App lifecycle can be inspected without touching the normal product port.
+- Added release-candidate publication support: `vX.Y.Z-rc.N` tags run the normal release gate, publish npm packages on the `next` dist-tag, and create GitHub prereleases while stable releases continue to use `latest`.
+
+### Changed
+
+- Promoted the validated `0.6.0-rc.1` build to the stable 0.6 line without additional runtime changes.
+- Skills are now advertised by name and loaded through the virtual `skills://<name>` namespace; real local Skill paths stay out of normal Agent-facing metadata, and files inside an activated Skill use `skills://<name>/<relative-path>`.
+- `publicBaseUrl` may now be either one routed URL or an ordered list of routed public URLs. The first remains canonical, every configured hostname joins the Host allowlist, and the complete ordered list participates in MCP App resource identity and CSP metadata.
+- Host Turn scoping now prefers Host conversation metadata, then the MCP transport session, then the current connection, preserving one Workspace-specific panel even on Hosts such as Inspector that do not provide OpenAI conversation metadata.
+- When an Agent only needs to wait for an already running Bash process, `bash(action="process", processId=..., yieldTimeMs=...)` now acts as one bounded wait and reuses the same process ID if the window expires, reducing repeated short polling.
+
+### Fixed
+
+- Preserved routed public base paths through OAuth endpoints and local debug configuration instead of collapsing deployment URLs back to the origin.
+- Preserved complete Workspace IDs in diagnostic logging and kept Activity Panel state attached across successive tool results.
+- Explicit Bash process waits now honor `yieldTimeMs` even when the process has already produced buffered output, so continuously logging commands can still be efficiently awaited to completion.
+
+## [0.6.0-rc.1] - 2026-08-27
+
+### Added
+
+- Added the unified ForgeRelay Panel for ChatGPT MCP App hosts: one Host Turn now keeps the Workspace Summary above a collapsible Activity Panel, groups live Activities, lazily loads detailed operation data, and streams durable Bash output without turning follow-up process control into duplicate top-level Activities.
+- Added a local MCP Inspector debug host on the dedicated `127.0.0.1:7677` path so the real HTTP/OAuth/MCP App lifecycle can be inspected without touching the normal product port.
+- Added release-candidate publication support: `vX.Y.Z-rc.N` tags run the normal release gate, publish npm packages on the `next` dist-tag, and create GitHub prereleases while stable releases continue to use `latest`.
+
+### Changed
+
+- Skills are now advertised by name and loaded through the virtual `skills://<name>` namespace; real local Skill paths stay out of normal Agent-facing metadata, and files inside an activated Skill use `skills://<name>/<relative-path>`.
+- `publicBaseUrl` may now be either one routed URL or an ordered list of routed public URLs. The first remains canonical, every configured hostname joins the Host allowlist, and the complete ordered list participates in MCP App resource identity and CSP metadata.
+- Host Turn scoping now prefers Host conversation metadata, then the MCP transport session, then the current connection, preserving one Workspace-specific panel even on Hosts such as Inspector that do not provide OpenAI conversation metadata.
+- When an Agent only needs to wait for an already running Bash process, `bash(action="process", processId=..., yieldTimeMs=...)` now acts as one bounded wait and reuses the same process ID if the window expires, reducing repeated short polling.
+
+### Fixed
+
+- Preserved routed public base paths through OAuth endpoints and local debug configuration instead of collapsing deployment URLs back to the origin.
+- Preserved complete Workspace IDs in diagnostic logging and kept Activity Panel state attached across successive tool results.
+- Explicit Bash process waits now honor `yieldTimeMs` even when the process has already produced buffered output, so continuously logging commands can still be efficiently awaited to completion.
+
 ## [0.5.6] - 2026-08-17
 
 ### Fixed

package/README.md

@@ -55,18 +55,22 @@ http://127.0.0.1:7676/mcp
 
 If the MCP host cannot reach localhost, put ForgeRelay behind a public HTTPS
 tunnel or reverse proxy such as Cloudflare Tunnel, ngrok, Pinggy, Tailscale
-Funnel, or your own proxy. During setup, enter the public origin without `/mcp`:
+Funnel, or your own proxy. During setup, enter the public base URL before the
+final `/mcp`; routed prefixes are allowed:
 
 ```text
-https://your-tunnel-host.example.com
+https://your-tunnel-host.example.com/forgerelay/main
 ```
 
 The client then connects to:
 
 ```text
-https://your-tunnel-host.example.com/mcp
+https://your-tunnel-host.example.com/forgerelay/main/mcp
 ```
 
+`publicBaseUrl` may also be an ordered list when multiple public entries are
+valid; each entry may use its own route and the first is canonical.
+
 ForgeRelay uses an Owner-password OAuth approval flow. `forgerelay init` prints
 the password and stores it in the active config directory. New installations use:
 

package/capabilities/host-integration/GUIDE.md

@@ -6,14 +6,20 @@
 
 ForgeRelay 本地监听一个 HTTP origin，MCP endpoint 是 `/mcp`。当 Host 无法直接访问 localhost 时，需要用户自己提供 public HTTPS tunnel/reverse proxy；ForgeRelay 不创建 tunnel。
 
-持久化的 `publicBaseUrl` 必须是 origin，不要包含 `/mcp`：
-
-```text
-publicBaseUrl: https://forge.example.com
-Host MCP URL:  https://forge.example.com/mcp
+公网部署继续使用 `publicBaseUrl`；它既可以是单个字符串，也可以是多个 URL 的列表。每个 URL 可以带自己的路由前缀，第一项是 canonical：
+
+```json
+{
+  "publicBaseUrl": [
+    "https://forge.example.com/forgerelay/main",
+    "https://forge-alt.example.com/relay"
+  ]
+}
 ```
 
-临时覆盖可使用 `FORGERELAY_PUBLIC_BASE_URL`。Host-header/403 问题先运行 `forgerelay doctor` 检查 resolved public URL 与 allowed hosts；`FORGERELAY_ALLOWED_HOSTS="*"` 只适合明确的本地调试。
+对应 canonical Host MCP URL 为 `https://forge.example.com/forgerelay/main/mcp`。全部配置项的 hostname 都会进入派生 Host-header allowlist；MCP、OAuth 与 MCP App asset URL 使用第一项作为 canonical base。单个字符串形式保持完全兼容，不需要迁移。
+
+临时覆盖使用 `FORGERELAY_PUBLIC_BASE_URL`；多个 URL 用逗号分隔。Host-header/403 问题先运行 `forgerelay doctor` 检查 resolved public base URLs 与 allowed hosts；`FORGERELAY_ALLOWED_HOSTS="*"` 只适合明确的本地调试。
 
 当 ForgeRelay 绑定 loopback、但 `publicBaseUrl` 指向公网 tunnel/reverse proxy 时，ForgeRelay 会自动信任恰好 1 个上游代理 hop，让 Express 与 OAuth rate limiter 使用一致的客户端 IP。不要把 Express `trust proxy` 设为无条件 `true`；直接监听 `0.0.0.0` 等非 loopback 地址时也不会自动开启代理信任。可用 `FORGERELAY_TRUST_PROXY=0|1` 显式覆盖。
 
@@ -47,13 +53,13 @@ npm run build
 npm run debug:accept
 ```
 
-ForgeRelay 正常会广告 content-hashed：
+ForgeRelay 对新的项目工作只广告统一 Panel 的 content-hashed App resource：
 
 ```text
-ui://forgerelay/workspace-app-<hash>.html
+ui://forgerelay/activity-panel-app-<hash>.html
 ```
 
-`resources/list` 与 `resources/read` 的 MCP App metadata 都应包含唯一 `_meta.ui.domain`，其值来自 resolved `publicBaseUrl` 的 origin；CSP 仍使用完整 public base URL 约束资源与连接域。`resources/read` 应返回 `text/html;profile=mcp-app`，并且 HTML 引用的 `/mcp-app-assets/` 资源必须可达。ForgeRelay 还保留 legacy `ui://forgerelay/workspace-app.html` 和历史 `workspace-app-*.html` 兼容指针，以容忍 Host 暂时持有旧 metadata snapshot。
+`activity_panel(workspaceId)` 是唯一的新 render tool；`open_workspace` 只返回 Workspace handle/context，不单独挂 UI。`resources/list` 与 `resources/read` 的当前 App metadata 都应包含 `_meta.ui.domain`，其值使用 canonical `publicBaseUrl` 的 origin；标准 `ui.domain` 本身不塞路由。CSP 的 resource/connect entries 使用完整 `publicBaseUrl` 列表，因此每个入口可以有不同路由。完整、有序的 public base URL 列表与 bundle/template contract 一起进入 MCP App resource identity；修改任一域名或路由都必须生成新的 `ui://` URI，不能让 Host 继续命中旧 metadata cache。`resources/read` 应返回 `text/html;profile=mcp-app`，并且 HTML 引用的 canonical routed `/mcp-app-assets/` 资源必须可达。ForgeRelay 仍保留 legacy `workspace-app` 与 Workspace Lifecycle URI/template 作为历史卡片读取兼容入口，但它们不代表当前产品存在第二个 App。
 
 需要 live trace 时，可用：
 

package/dist/activity/host-turn-store.js

@@ -9,14 +9,15 @@ export class HostTurnStore {
         this.now = options.now ?? (() => new Date());
         this.nextTurnId = options.turnId ?? (() => `turn_${randomUUID().replaceAll("-", "")}`);
     }
-    begin(conversationScopeId) {
+    begin(conversationScopeId, workspaceId) {
         const turnId = this.nextTurnId();
         const createdAt = this.now().toISOString();
-        this.database.sqlite.prepare(`insert into activity_host_turns (turn_id, conversation_scope_id, created_at)
-       values (?, ?, ?)`).run(turnId, conversationScopeId ?? null, createdAt);
+        this.database.sqlite.prepare(`insert into activity_host_turns (turn_id, conversation_scope_id, workspace_id, created_at)
+       values (?, ?, ?, ?)`).run(turnId, conversationScopeId ?? null, workspaceId, createdAt);
         return {
             turnId,
             ...(conversationScopeId ? { conversationScopeId } : {}),
+            workspaceId,
             createdAt,
         };
     }
@@ -24,13 +25,13 @@ export class HostTurnStore {
         const row = this.database.sqlite.prepare("select * from activity_host_turns where turn_id = ?").get(turnId);
         return row ? rowToTurn(row) : undefined;
     }
-    current(conversationScopeId) {
-        if (!conversationScopeId)
+    current(conversationScopeId, workspaceId) {
+        if (!conversationScopeId || !workspaceId)
             return undefined;
         const row = this.database.sqlite.prepare(`select * from activity_host_turns
-       where conversation_scope_id = ?
+       where conversation_scope_id = ? and workspace_id = ?
        order by rowid desc
-       limit 1`).get(conversationScopeId);
+       limit 1`).get(conversationScopeId, workspaceId);
         return row ? rowToTurn(row) : undefined;
     }
     close() {
@@ -41,6 +42,7 @@ function rowToTurn(row) {
     return {
         turnId: row.turn_id,
         ...(row.conversation_scope_id ? { conversationScopeId: row.conversation_scope_id } : {}),
+        ...(row.workspace_id ? { workspaceId: row.workspace_id } : {}),
         createdAt: row.created_at,
     };
 }

package/dist/activity/lifecycle.js

@@ -46,7 +46,7 @@ export class ActivityLifecycle {
     start(options) {
         const activityId = options.activityId ?? this.activityId();
         const turnId = options.turnId
-            ?? this.turnIdForConversation?.(options.conversationScopeId)
+            ?? this.turnIdForConversation?.(options.conversationScopeId, options.workspace.id)
             ?? this.turnId();
         const request = normalizeAuditValue(options.request);
         this.auditStore.append({

package/dist/activity/mcp-query-tools.js

@@ -1,6 +1,8 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
-import { openAiConversationScopeId } from "../request-meta.js";
+import { logEvent, transportSessionIdPrefix } from "../logger.js";
+import { hostConversationScopeId } from "../request-meta.js";
+import { ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY, ACTIVITY_PANEL_WORKSPACE_META_KEY, } from "./ui/contract.js";
 const READ_ONLY_ANNOTATIONS = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -9,6 +11,7 @@ const READ_ONLY_ANNOTATIONS = {
 };
 const activitySummarySchema = z.object({
     activityId: z.string(),
+    parentActivityId: z.string().optional(),
     tool: z.string(),
     kind: z.string(),
     status: z.enum(["working", "done", "error"]),
@@ -24,6 +27,12 @@ const activitySummarySchema = z.object({
     startedAt: z.string(),
     finishedAt: z.string().optional(),
     durationMs: z.number().nonnegative().optional(),
+    children: z.object({
+        total: z.number().int().nonnegative(),
+        working: z.number().int().nonnegative(),
+        done: z.number().int().nonnegative(),
+        error: z.number().int().nonnegative(),
+    }).optional(),
 });
 const snapshotOutputSchema = {
     turnId: z.string(),
@@ -31,48 +40,110 @@ const snapshotOutputSchema = {
     changed: z.boolean(),
     state: z.enum(["working", "done", "error"]),
     activities: z.array(activitySummarySchema),
+    [ACTIVITY_PANEL_WORKSPACE_META_KEY]: z.record(z.string(), z.unknown()).optional(),
 };
-export function registerActivityQueryTools(server, queries) {
+export function registerActivityQueryTools(server, queries, connectionScopeId, panelMeta = {}, panelDefaultExpanded = false, logging, workspacePanelState) {
+    const panelUi = typeof panelMeta.ui === "object" && panelMeta.ui !== null
+        ? panelMeta.ui
+        : {};
     registerAppTool(server, "activity_panel", {
-        title: "Begin Activity Panel",
-        description: "Begin one ForgeRelay Host Turn lifecycle for subsequent project work. This orchestration call does not read or modify project files. Call it once before the first ForgeRelay work operation in a Host Turn that performs project work.",
-        inputSchema: {},
+        title: "Begin ForgeRelay Panel",
+        description: "Begin one ForgeRelay Host Turn for project work in workspaceId as the single ForgeRelay UI render tool for that Workspace. If this Host Turn calls open_workspace, open_workspace must run first and its returned workspaceId must be passed here. A different workspaceId creates a different card. Call exactly once after workspace resolution and before the first non-lifecycle ForgeRelay work tool.",
+        inputSchema: {
+            workspaceId: z.string().min(1).describe("Workspace identifier returned by open_workspace for the project work in this Host Turn."),
+        },
         outputSchema: snapshotOutputSchema,
-        _meta: { ui: { visibility: ["model", "app"] } },
+        _meta: {
+            ...panelMeta,
+            ui: {
+                ...panelUi,
+                visibility: ["model", "app"],
+            },
+        },
         annotations: {
             ...READ_ONLY_ANNOTATIONS,
             idempotentHint: false,
         },
-    }, async (_input, extra) => {
-        const snapshot = queries.beginTurn(openAiConversationScopeId(extra._meta));
+    }, async ({ workspaceId }, extra) => {
+        const workspace = workspacePanelState?.(workspaceId);
+        if (!workspace) {
+            throw new Error(`No Workspace presentation is available for ${workspaceId}. Call open_workspace for that workspace before activity_panel.`);
+        }
+        const snapshot = queries.beginTurn(hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId), workspaceId);
+        if (logging) {
+            logEvent(logging, "debug", "activity_panel_call", {
+                turnId: snapshot.turnId,
+                revision: snapshot.revision,
+                state: snapshot.state,
+                activities: snapshot.activities.length,
+                workspaceId,
+                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+            });
+        }
         return {
+            _meta: {
+                [ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY]: panelDefaultExpanded,
+                [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
+            },
             content: [{
                     type: "text",
-                    text: `Started ForgeRelay Activity Panel Host Turn ${snapshot.turnId}.`,
+                    text: `Started ForgeRelay Panel Host Turn ${snapshot.turnId} for ${workspaceId}.`,
                 }],
-            structuredContent: { ...snapshot },
+            structuredContent: {
+                ...snapshot,
+                [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
+            },
         };
     });
     registerAppTool(server, "activity_snapshot", {
         title: "Read Activity snapshot",
         description: "App-only data source for lightweight Activity summaries in one durable Host Turn.",
         inputSchema: {
-            turnId: z.string(),
+            turnId: z.string().optional().describe("Existing Host Turn identifier. Omit only for initial App bootstrap; ForgeRelay then resolves the current Host Turn from conversation metadata."),
+            workspaceId: z.string().min(1).optional().describe("Workspace identifier used by the App during initial bootstrap so ForgeRelay can restore the Workspace section."),
             knownRevision: z.number().int().nonnegative().optional(),
         },
         outputSchema: snapshotOutputSchema,
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
-    }, async ({ turnId, knownRevision }) => {
-        const snapshot = queries.snapshot(turnId, knownRevision);
+    }, async ({ turnId, workspaceId, knownRevision }, extra) => {
+        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const resolvedTurnId = turnId ?? queries.currentTurnId(conversationScopeId, workspaceId);
+        if (!resolvedTurnId) {
+            throw new Error("Activity snapshot bootstrap could not resolve the current Host Turn from conversation and workspace metadata.");
+        }
+        const snapshot = queries.snapshot(resolvedTurnId, knownRevision);
+        if (logging) {
+            logEvent(logging, "debug", "activity_snapshot_call", {
+                turnId: resolvedTurnId,
+                bootstrap: turnId === undefined,
+                knownRevision,
+                revision: snapshot.revision,
+                changed: snapshot.changed,
+                state: snapshot.state,
+                activities: snapshot.activities.length,
+                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+            });
+        }
+        const workspace = workspaceId ? workspacePanelState?.(workspaceId) : undefined;
+        if (workspaceId && !workspace) {
+            throw new Error(`No Workspace presentation is available for ${workspaceId}.`);
+        }
         return {
+            _meta: {
+                [ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY]: panelDefaultExpanded,
+                ...(workspace ? { [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace } : {}),
+            },
             content: [{
                     type: "text",
                     text: snapshot.changed
-                        ? `Activity snapshot ${turnId} revision ${snapshot.revision}.`
-                        : `Activity snapshot ${turnId} unchanged at revision ${snapshot.revision}.`,
+                        ? `Activity snapshot ${resolvedTurnId} revision ${snapshot.revision}.`
+                        : `Activity snapshot ${resolvedTurnId} unchanged at revision ${snapshot.revision}.`,
                 }],
-            structuredContent: { ...snapshot },
+            structuredContent: {
+                ...snapshot,
+                ...(workspace ? { [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace } : {}),
+            },
         };
     });
     registerAppTool(server, "activity_detail", {
@@ -90,8 +161,18 @@ export function registerActivityQueryTools(server, queries) {
         },
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
-    }, async ({ turnId, activityId }) => {
+    }, async ({ turnId, activityId }, extra) => {
         const detail = queries.detail(turnId, activityId);
+        if (logging) {
+            logEvent(logging, "debug", "activity_detail_call", {
+                turnId,
+                activityId,
+                tool: detail.activity.tool,
+                kind: detail.activity.kind,
+                state: detail.activity.state,
+                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+            });
+        }
         return {
             content: [{ type: "text", text: `Activity detail ${activityId}.` }],
             structuredContent: { ...detail },
@@ -119,8 +200,19 @@ export function registerActivityQueryTools(server, queries) {
         },
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
-    }, async ({ turnId, outputId }) => {
+    }, async ({ turnId, outputId }, extra) => {
         const output = queries.bashOutput(turnId, outputId);
+        if (logging) {
+            logEvent(logging, "debug", "activity_output_call", {
+                turnId,
+                outputId,
+                activityId: output.activityId,
+                processId: output.processId,
+                status: output.status,
+                outputBytes: Buffer.byteLength(output.output),
+                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+            });
+        }
         return {
             content: [{ type: "text", text: `Bash output ${outputId}.` }],
             structuredContent: { ...output },

package/dist/activity/query-service.js

@@ -7,12 +7,12 @@ export class ActivityQueryService {
         this.audit = audit;
         this.outputs = outputs;
     }
-    beginTurn(conversationScopeId) {
-        const turn = this.turns.begin(conversationScopeId);
+    beginTurn(conversationScopeId, workspaceId) {
+        const turn = this.turns.begin(conversationScopeId, workspaceId);
         return this.snapshot(turn.turnId);
     }
-    currentTurnId(conversationScopeId) {
-        return this.turns.current(conversationScopeId)?.turnId;
+    currentTurnId(conversationScopeId, workspaceId) {
+        return this.turns.current(conversationScopeId, workspaceId)?.turnId;
     }
     snapshot(turnId, knownRevision) {
         this.requireTurn(turnId);

package/dist/activity/ui/contract.js

@@ -0,0 +1,2 @@
+export const ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY = "forgerelay/activityPanelDefaultExpanded";
+export const ACTIVITY_PANEL_WORKSPACE_META_KEY = "forgerelay/activityPanelWorkspace";

package/dist/cli.js

@@ -21,6 +21,7 @@ import { createLocalAgentStore } from "./local-agent-store.js";
 import { generateOwnerToken, loadDevspaceFiles, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
 import { shutdownHttpServer } from "./server-shutdown.js";
+import { publicEndpointUrl } from "./oauth/public-url.js";
 const require = createRequire(import.meta.url);
 const SUPPORTED_NODE_RANGE = ">=20.12 <27";
 async function main(argv) {
@@ -113,25 +114,30 @@ async function runInit({ force }) {
         });
         const port = Number(portAnswer);
         prompts.note([
-            "ForgeRelay needs a public base URL so ChatGPT or Claude can reach this MCP server.",
+            "ForgeRelay needs one or more public base URLs so ChatGPT or Claude can reach this MCP server.",
             "Create a tunnel or reverse proxy with Cloudflare Tunnel, ngrok, Pinggy, Tailscale Funnel, or your own HTTPS proxy.",
-            "Paste the public origin here, without /mcp.",
+            "Each URL may include its own route prefix. Separate multiple URLs with commas; the first is canonical.",
             "",
-            "Example: https://your-tunnel-host.example.com",
+            "Example: https://forge.example.com/forgerelay/main, https://alias.example.com/relay",
         ].join("\n"), "Public URL required");
-        const publicBaseUrl = normalizePublicBaseUrl(await textPrompt({
-            message: files.config.publicBaseUrl
-                ? `What is the public base URL? Press Enter to keep ${files.config.publicBaseUrl}`
-                : "What is the public base URL?",
-            placeholder: files.config.publicBaseUrl ?? "https://your-tunnel-host.example.com",
-            defaultValue: files.config.publicBaseUrl ?? "",
-            validate: validateRequiredPublicBaseUrl,
+        const defaultPublicBaseUrls = Array.isArray(files.config.publicBaseUrl)
+            ? files.config.publicBaseUrl.join(", ")
+            : files.config.publicBaseUrl ?? "";
+        const publicBaseUrls = normalizePublicBaseUrlsInput(await textPrompt({
+            message: defaultPublicBaseUrls
+                ? `What are the public base URLs? Press Enter to keep ${defaultPublicBaseUrls}`
+                : "What are the public base URLs?",
+            placeholder: defaultPublicBaseUrls || "https://your-tunnel-host.example.com",
+            defaultValue: defaultPublicBaseUrls,
+            validate: validateRequiredPublicBaseUrls,
         }));
+        const publicBaseUrl = compactPublicBaseUrlConfig(publicBaseUrls);
         const config = {
             host: files.config.host ?? "127.0.0.1",
             port,
             allowedRoots,
             publicBaseUrl,
+            allowedHosts: files.config.allowedHosts,
             workflowInstructions: files.config.workflowInstructions,
             appendInstructions: files.config.appendInstructions,
             subagents: resolveSubagentsFlag(files.config),
@@ -145,7 +151,7 @@ async function runInit({ force }) {
             `Config: ${configPath}`,
             `Auth: ${authPath}`,
             `Local MCP URL: http://${config.host}:${config.port}/mcp`,
-            ...(publicBaseUrl ? [`Public MCP URL: ${publicBaseUrl}/mcp`] : []),
+            ...publicBaseUrls.map((baseUrl, index) => `${index === 0 ? "Public MCP URL" : "Public MCP alias"}: ${publicEndpointUrl(baseUrl, "mcp").toString()}`),
         ];
         prompts.note(lines.join("\n"), "ForgeRelay configured");
         prompts.note([
@@ -222,8 +228,9 @@ async function runDoctor() {
     try {
         const config = loadConfig();
         console.log(`Local MCP URL: http://${config.host}:${config.port}/mcp`);
+        console.log(`Public base URLs: ${config.publicBaseUrls.join(", ")}`);
         console.log(`Public base URL: ${config.publicBaseUrl}`);
-        console.log(`Public MCP URL: ${new URL("/mcp", config.publicBaseUrl).toString()}`);
+        console.log(`Public MCP URL: ${publicEndpointUrl(config.publicBaseUrl, "mcp").toString()}`);
         console.log(`Tool mode: ${config.toolMode}`);
         console.log(`Widgets: ${config.widgets}`);
         console.log(`Trust proxy: ${config.logging.trustProxy ? "one hop" : "off"}`);
@@ -248,12 +255,11 @@ function runConfigCommand(args) {
         throw new Error(`Unknown config command: ${subcommand}`);
     }
     if (key !== "publicBaseUrl") {
-        throw new Error("Only `forgerelay config set publicBaseUrl <url|null>` is supported right now.");
+        throw new Error("Only `forgerelay config set publicBaseUrl <url[,url...]|null>` is supported right now.");
     }
     const value = rest.join(" ").trim();
-    if (!value) {
+    if (!value)
         throw new Error("Missing publicBaseUrl value.");
-    }
     writeDevspaceConfig({
         ...files.config,
         publicBaseUrl: normalizeOptionalPublicBaseUrl(value),
@@ -270,7 +276,7 @@ function printHelp() {
         "  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",
-        "  forgerelay config set publicBaseUrl <url|null>",
+        "  forgerelay config set publicBaseUrl <url[,url...]|null>",
         "  forgerelay hooks list [--project <path>]",
         "  forgerelay hooks check [--project <path>]",
         "  forgerelay agents ls       List subagent sessions",
@@ -279,7 +285,7 @@ function printHelp() {
         "  forgerelay -v, --version   Print the installed version",
         "",
         "For temporary tunnels:",
-        "  FORGERELAY_PUBLIC_BASE_URL=https://example.trycloudflare.com forgerelay serve",
+        "  FORGERELAY_PUBLIC_BASE_URL=https://example.trycloudflare.com/forgerelay/debug forgerelay serve",
     ].join("\n"));
 }
 async function runAgentsCommand(args) {
@@ -542,11 +548,27 @@ function printVersion() {
     }
     console.log(packageJson.version);
 }
+function isNullConfigValue(value) {
+    const normalized = value.trim().toLowerCase();
+    return !normalized || normalized === "null" || normalized === "none";
+}
 function normalizeOptionalPublicBaseUrl(value) {
     const trimmed = value.trim();
-    if (!trimmed || trimmed === "null" || trimmed === "none")
+    if (isNullConfigValue(trimmed))
         return null;
-    return normalizePublicBaseUrl(trimmed);
+    return compactPublicBaseUrlConfig(normalizePublicBaseUrlsInput(trimmed));
+}
+function normalizePublicBaseUrlsInput(value) {
+    const entries = value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (entries.length === 0)
+        throw new Error("Enter at least one public base URL.");
+    return Array.from(new Set(entries.map((entry) => normalizePublicBaseUrl(entry))));
+}
+function compactPublicBaseUrlConfig(baseUrls) {
+    return baseUrls.length === 1 ? baseUrls[0] : baseUrls;
 }
 function normalizePublicBaseUrl(value) {
     const trimmed = value.trim();
@@ -572,23 +594,16 @@ function validatePort(value) {
         ? undefined
         : "Enter a port between 1 and 65535.";
 }
-function validateRequiredPublicBaseUrl(value) {
+function validateRequiredPublicBaseUrls(value) {
     const trimmed = value?.trim() ?? "";
     if (!trimmed)
-        return "Enter the public URL from your tunnel or reverse proxy.";
-    if (trimmed.endsWith("/mcp"))
-        return "Enter the base URL only, without /mcp.";
-    return validatePublicBaseUrl(trimmed);
-}
-function validatePublicBaseUrl(value) {
+        return "Enter at least one public base URL from your tunnel or reverse proxy.";
     try {
-        const parsed = new URL(value);
-        return parsed.protocol === "http:" || parsed.protocol === "https:"
-            ? undefined
-            : "Use an http or https URL.";
+        normalizePublicBaseUrlsInput(trimmed);
+        return undefined;
     }
-    catch {
-        return "Enter a valid URL, for example https://your-tunnel-host.example.com.";
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
     }
 }
 function assertSupportedNode() {

package/dist/config.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { expandHomePath } from "./roots.js";
 import { mergeHookConfigs, parseHookConfig } from "./hooks.js";
-import { forgerelayAgentsDir, forgerelaySkillsDir, loadForgeRelayFiles } from "./user-config.js";
+import { forgerelayAgentsDir, forgerelaySkillsDir, loadForgeRelayFiles, } from "./user-config.js";
 const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
 const DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
 const DEFAULT_ARTIFACT_MAX_FILE_BYTES = 100 * 1024 * 1024;
@@ -186,17 +186,41 @@ function parseSystemInstructionsPath(value) {
     }
     return resolve(expandHomePath(value.trim()));
 }
+function parsePublicBaseUrls(value, fallback) {
+    if (value === null)
+        return fallback;
+    const raw = Array.isArray(value)
+        ? value.map((entry) => entry.trim()).filter(Boolean)
+        : value?.split(",").map((entry) => entry.trim()).filter(Boolean);
+    if (value !== undefined && (!raw || raw.length === 0)) {
+        throw new Error("FORGERELAY_PUBLIC_BASE_URL must contain at least one public base URL.");
+    }
+    const normalized = (raw ?? fallback).map((entry) => parsePublicBaseUrl(entry));
+    return Array.from(new Set(normalized));
+}
+function resolvePublicDeployment(env, fileConfig, host, port) {
+    const localBaseUrls = [parsePublicBaseUrl(localPublicBaseUrl(host, port))];
+    const envBaseUrl = productEnv(env, "PUBLIC_BASE_URL");
+    const baseUrls = envBaseUrl !== undefined
+        ? parsePublicBaseUrls(envBaseUrl, localBaseUrls)
+        : parsePublicBaseUrls(fileConfig.publicBaseUrl, localBaseUrls);
+    return {
+        baseUrls,
+        canonicalBaseUrl: baseUrls[0],
+    };
+}
 export function loadConfig(env = process.env) {
     const files = loadForgeRelayFiles(env);
     const host = env.HOST ?? files.config.host ?? "127.0.0.1";
     const port = parsePort(env.PORT ?? files.config.port);
-    const publicBaseUrl = parsePublicBaseUrl(productEnv(env, "PUBLIC_BASE_URL") ?? files.config.publicBaseUrl ?? localPublicBaseUrl(host, port));
+    const publicDeployment = resolvePublicDeployment(env, files.config, host, port);
+    const publicBaseUrl = publicDeployment.canonicalBaseUrl;
     const derivedAllowedHosts = [
         "localhost",
         "127.0.0.1",
         "::1",
         host,
-        new URL(publicBaseUrl).hostname,
+        ...publicDeployment.baseUrls.map((baseUrl) => new URL(baseUrl).hostname),
         ...(files.config.allowedHosts ?? []),
     ];
     return {
@@ -206,10 +230,14 @@ export function loadConfig(env = process.env) {
         allowedRoots: parseAllowedRoots(productEnv(env, "ALLOWED_ROOTS") ?? files.config.allowedRoots),
         allowedHosts: parseAllowedHosts(productEnv(env, "ALLOWED_HOSTS"), derivedAllowedHosts),
         publicBaseUrl,
+        publicBaseUrls: publicDeployment.baseUrls,
         toolMode: parseToolMode(env),
         workflowInstructions: parseWorkflowInstructions(productEnv(env, "WORKFLOW_INSTRUCTIONS"), files.config.workflowInstructions),
         appendInstructions: parseAppendInstructions(productEnv(env, "APPEND_INSTRUCTIONS"), files.config.appendInstructions),
         widgets: parseWidgetMode(productEnv(env, "WIDGETS")),
+        activityPanelExpanded: productEnv(env, "ACTIVITY_PANEL_EXPANDED") === undefined
+            ? files.config.activityPanelExpanded === true
+            : parseBoolean(productEnv(env, "ACTIVITY_PANEL_EXPANDED")),
         stateDir: resolve(expandHomePath(productEnv(env, "STATE_DIR") ?? files.config.stateDir ?? defaultStateDir())),
         worktreeRoot: resolve(expandHomePath(productEnv(env, "WORKTREE_ROOT") ?? files.config.worktreeRoot ?? defaultWorktreeRoot())),
         artifactsEnabled: productEnv(env, "ARTIFACTS") === undefined