@akira-tl/forgerelay 0.8.7 → 0.8.9

package/dist/mcp/filesystem/filesystem-tools.js

@@ -0,0 +1,245 @@
+import { constants } from "node:fs";
+import { access, mkdir, readFile, realpath, writeFile, } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createPatch } from "diff";
+import { resolveCanonicalAllowedPath } from "./roots.js";
+const DEFAULT_MAX_LINES = 2_000;
+const DEFAULT_MAX_BYTES = 50 * 1_024;
+const mutationQueues = new Map();
+function textContent(text) {
+    return [{ type: "text", text }];
+}
+function failed(error) {
+    return {
+        content: textContent(error instanceof Error ? error.message : String(error)),
+        isError: true,
+    };
+}
+export async function readFileTool(input, context) {
+    try {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.readRoots ?? [context.root]);
+        await access(path, constants.R_OK);
+        const buffer = await readFile(path);
+        const mimeType = supportedImageMimeType(buffer);
+        if (mimeType) {
+            return {
+                content: [
+                    { type: "text", text: `Read image file [${mimeType}]` },
+                    { type: "image", data: buffer.toString("base64"), mimeType },
+                ],
+            };
+        }
+        return { content: textContent(readText(buffer.toString("utf8"), input)) };
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export async function writeFileTool(input, context) {
+    try {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.fileRoots ?? [context.root]);
+        await withMutationQueue(path, async () => {
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, input.content, "utf8");
+        });
+        return { content: textContent(`Successfully wrote ${input.content.length} bytes to ${input.path}`) };
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export async function editFileTool(input, context, signal) {
+    try {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.fileRoots ?? [context.root]);
+        const details = await withMutationQueue(path, async () => {
+            signal?.throwIfAborted();
+            await access(path, constants.R_OK | constants.W_OK);
+            signal?.throwIfAborted();
+            const raw = await readFile(path, "utf8");
+            signal?.throwIfAborted();
+            const applied = applyExactEdits(raw, input.edits, input.path);
+            await writeFile(path, applied.output, "utf8");
+            signal?.throwIfAborted();
+            return applied.details;
+        });
+        return {
+            content: textContent(`Successfully replaced ${input.edits.length} block(s) in ${input.path}.`),
+            details,
+        };
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export async function preflightEditFiles(paths, edits, context, signal) {
+    const seen = new Map();
+    for (const path of paths) {
+        signal?.throwIfAborted();
+        const absolute = await resolveCanonicalAllowedPath(path, context.cwd, context.fileRoots ?? [context.root]);
+        const canonical = await realpath(absolute);
+        const previous = seen.get(canonical);
+        if (previous) {
+            throw new Error(`Bulk Edit targets overlap: ${previous} and ${path} resolve to the same file.`);
+        }
+        seen.set(canonical, path);
+        await access(absolute, constants.R_OK | constants.W_OK);
+        const content = await readFile(absolute, "utf8");
+        applyExactEdits(content, edits, path);
+    }
+}
+function readText(content, input) {
+    const lines = content.split("\n");
+    const startIndex = Math.max(0, (input.offset ?? 1) - 1);
+    if (startIndex >= lines.length) {
+        throw new Error(`Offset ${input.offset} is beyond end of file (${lines.length} lines total)`);
+    }
+    const explicitEnd = input.limit === undefined
+        ? lines.length
+        : Math.min(lines.length, startIndex + input.limit);
+    const selected = lines.slice(startIndex, explicitEnd);
+    const limited = truncateLinesAndBytes(selected, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES);
+    const startLine = startIndex + 1;
+    const endLine = startLine + limited.lines.length - 1;
+    let output = limited.lines.join("\n");
+    if (limited.truncated) {
+        const nextOffset = endLine + 1;
+        output += `\n\n[Showing lines ${startLine}-${endLine} of ${lines.length}. Use offset=${nextOffset} to continue.]`;
+    }
+    else if (explicitEnd < lines.length) {
+        const remaining = lines.length - explicitEnd;
+        output += `\n\n[${remaining} more lines in file. Use offset=${explicitEnd + 1} to continue.]`;
+    }
+    return output;
+}
+function truncateLinesAndBytes(lines, maxLines, maxBytes) {
+    const output = [];
+    let bytes = 0;
+    for (const line of lines) {
+        if (output.length >= maxLines)
+            return { lines: output, truncated: true };
+        const prefix = output.length === 0 ? "" : "\n";
+        const lineBytes = Buffer.byteLength(prefix + line, "utf8");
+        if (bytes + lineBytes > maxBytes) {
+            if (output.length === 0) {
+                return {
+                    lines: [`[Line exceeds ${maxBytes} byte read limit. Use bash for byte-oriented inspection.]`],
+                    truncated: true,
+                };
+            }
+            return { lines: output, truncated: true };
+        }
+        output.push(line);
+        bytes += lineBytes;
+    }
+    return { lines: output, truncated: false };
+}
+function applyExactEdits(rawContent, edits, displayPath) {
+    if (!Array.isArray(edits) || edits.length === 0) {
+        throw new Error("Edit tool input is invalid. edits must contain at least one replacement.");
+    }
+    const { bom, text } = stripBom(rawContent);
+    const lineEnding = detectLineEnding(text);
+    const original = normalizeLineEndings(text);
+    const prepared = edits.map((edit, index) => {
+        if (typeof edit.oldText !== "string" || typeof edit.newText !== "string" || edit.oldText.length === 0) {
+            throw new Error(`Edit ${index + 1} must contain non-empty oldText and string newText.`);
+        }
+        const oldText = normalizeLineEndings(edit.oldText);
+        const newText = normalizeLineEndings(edit.newText);
+        const start = original.indexOf(oldText);
+        if (start < 0) {
+            throw new Error(`Could not edit ${displayPath}: oldText for replacement ${index + 1} did not match.`);
+        }
+        if (original.indexOf(oldText, start + oldText.length) >= 0) {
+            throw new Error(`Could not edit ${displayPath}: oldText for replacement ${index + 1} must be unique but matched multiple locations.`);
+        }
+        return { start, end: start + oldText.length, newText };
+    }).sort((left, right) => left.start - right.start);
+    for (let index = 1; index < prepared.length; index += 1) {
+        if (prepared[index].start < prepared[index - 1].end) {
+            throw new Error(`Could not edit ${displayPath}: replacements overlap in the original file.`);
+        }
+    }
+    let cursor = 0;
+    let updated = "";
+    for (const edit of prepared) {
+        updated += original.slice(cursor, edit.start);
+        updated += edit.newText;
+        cursor = edit.end;
+    }
+    updated += original.slice(cursor);
+    const firstChangedLine = prepared.length === 0
+        ? undefined
+        : original.slice(0, prepared[0].start).split("\n").length;
+    const patch = createPatch(displayPath, original, updated, "", "", { context: 3 });
+    const diff = patch;
+    const output = bom + restoreLineEndings(updated, lineEnding);
+    return { output, details: { diff, patch, firstChangedLine } };
+}
+function stripBom(content) {
+    return content.charCodeAt(0) === 0xfeff
+        ? { bom: "\ufeff", text: content.slice(1) }
+        : { bom: "", text: content };
+}
+function detectLineEnding(content) {
+    if (content.includes("\r\n"))
+        return "\r\n";
+    if (content.includes("\r"))
+        return "\r";
+    return "\n";
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, "\n");
+}
+function restoreLineEndings(content, lineEnding) {
+    return lineEnding === "\n" ? content : content.replaceAll("\n", lineEnding);
+}
+function supportedImageMimeType(buffer) {
+    if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+        return "image/png";
+    }
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    const header6 = buffer.subarray(0, 6).toString("ascii");
+    if (header6 === "GIF87a" || header6 === "GIF89a")
+        return "image/gif";
+    if (buffer.length >= 12 &&
+        buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buffer.subarray(8, 12).toString("ascii") === "WEBP")
+        return "image/webp";
+    if (buffer.length >= 2 && buffer.subarray(0, 2).toString("ascii") === "BM")
+        return "image/bmp";
+    return undefined;
+}
+async function withMutationQueue(path, operation) {
+    const canonical = await canonicalMutationPath(path);
+    const previous = mutationQueues.get(canonical) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    mutationQueues.set(canonical, previous.then(() => current));
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (mutationQueues.get(canonical) === current)
+            mutationQueues.delete(canonical);
+    }
+}
+async function canonicalMutationPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        try {
+            return `${await realpath(dirname(path))}/${path.slice(dirname(path).length + 1)}`;
+        }
+        catch {
+            return path;
+        }
+    }
+}

package/dist/mcp/hooks/command-runner.js

@@ -0,0 +1,79 @@
+import { spawn } from "node:child_process";
+import { terminateProcessTree } from "../process/process-platform.js";
+const MAX_CAPTURE_BYTES = 64 * 1024;
+export function executeHookCommand(input) {
+    input.signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.executable, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            detached: input.detached,
+            windowsHide: true,
+            windowsVerbatimArguments: input.windowsVerbatimArguments,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let forceKillTimer;
+        let aborted = false;
+        const abort = () => {
+            if (aborted)
+                return;
+            aborted = true;
+            terminateProcessTree(child, "SIGTERM", input.detached);
+            forceKillTimer = setTimeout(() => {
+                terminateProcessTree(child, "SIGKILL", input.detached);
+            }, 500);
+            forceKillTimer.unref();
+        };
+        input.signal?.addEventListener("abort", abort, { once: true });
+        child.stdout?.on("data", (chunk) => {
+            stdout = appendCaptured(stdout, chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr = appendCaptured(stderr, chunk);
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(child, "SIGTERM", input.detached);
+            forceKillTimer = setTimeout(() => {
+                terminateProcessTree(child, "SIGKILL", input.detached);
+            }, 500);
+            forceKillTimer.unref();
+        }, input.timeoutMs);
+        timeout.unref();
+        child.once("error", (error) => {
+            clearTimeout(timeout);
+            if (forceKillTimer)
+                clearTimeout(forceKillTimer);
+            input.signal?.removeEventListener("abort", abort);
+            reject(error);
+        });
+        child.once("close", (exitCode, signal) => {
+            clearTimeout(timeout);
+            if (forceKillTimer)
+                clearTimeout(forceKillTimer);
+            input.signal?.removeEventListener("abort", abort);
+            if (aborted) {
+                reject(input.signal?.reason instanceof Error
+                    ? input.signal.reason
+                    : Object.assign(new Error("Hook execution cancelled by Host."), { name: "AbortError" }));
+                return;
+            }
+            resolve({ exitCode, signal, stdout, stderr, timedOut });
+        });
+    });
+}
+function appendCaptured(current, chunk) {
+    if (Buffer.byteLength(current) >= MAX_CAPTURE_BYTES)
+        return current;
+    const next = current + chunk.toString();
+    if (Buffer.byteLength(next) <= MAX_CAPTURE_BYTES)
+        return next;
+    return Buffer.from(next).subarray(0, MAX_CAPTURE_BYTES).toString("utf8");
+}
+export function hookFailureOutput(stdout, stderr) {
+    const output = (stderr.trim() || stdout.trim()).replace(/\s+/g, " ");
+    return output.length > 1_000 ? `${output.slice(0, 997)}...` : output;
+}

package/dist/{hook-cli.js → mcp/hooks/hook-cli.js}

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { HOOK_EVENTS, loadProjectHookConfig, mergeHookConfigs, parseHookConfig, } from "./hooks.js";
-import { loadForgeRelayFiles } from "./user-config.js";
+import { loadForgeRelayFiles } from "../../runtime/config/user-config.js";
 export async function checkHookConfiguration(projectRoot, globalHooks = loadGlobalHooks()) {
     const globalEntries = flattenHooks(globalHooks, "global");
     const project = await loadProjectHookConfig(projectRoot);

package/dist/{hooks.js → mcp/hooks/hooks.js}

@@ -1,9 +1,9 @@
-import { spawn } from "node:child_process";
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { performance } from "node:perf_hooks";
-import { commandPreview, logEvent, workspaceLogLabel } from "./logger.js";
-import { resolveShellCommand, terminateProcessTree } from "./process-platform.js";
+import { commandPreview, logEvent, workspaceLogLabel } from "../../runtime/logging/logger.js";
+import { resolveShellCommand } from "../process/process-platform.js";
+import { executeHookCommand, hookFailureOutput } from "./command-runner.js";
 export const HOOK_EVENTS = [
     "WorkspaceOpen",
     "BeforeTool",
@@ -19,7 +19,6 @@ const DEFAULT_HOOK_TIMEOUT_SECONDS = 30;
 const MAX_HOOK_TIMEOUT_SECONDS = 300;
 const PROJECT_HOOKS_PATH = join(".forgerelay", "hooks.json");
 const PROJECT_HOOKS_DIR = join(".forgerelay", "hooks");
-const MAX_CAPTURE_BYTES = 64 * 1024;
 const BLOCKING_EVENTS = new Set(["BeforeTool", "BeforeWorktreeClose"]);
 const EVENT_SET = new Set(HOOK_EVENTS);
 export class HookExecutionError extends Error {
@@ -529,82 +528,6 @@ function hookEnvironment(baseEnv, event, invocation) {
         FORGERELAY_TOOL_NAME: typeof invocation.payload?.tool === "string" ? invocation.payload.tool : undefined,
     };
 }
-function executeHookCommand(input) {
-    input.signal?.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const child = spawn(input.executable, input.args, {
-            cwd: input.cwd,
-            env: input.env,
-            detached: input.detached,
-            windowsHide: true,
-            windowsVerbatimArguments: input.windowsVerbatimArguments,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let forceKillTimer;
-        let aborted = false;
-        const abort = () => {
-            if (aborted)
-                return;
-            aborted = true;
-            terminateProcessTree(child, "SIGTERM", input.detached);
-            forceKillTimer = setTimeout(() => {
-                terminateProcessTree(child, "SIGKILL", input.detached);
-            }, 500);
-            forceKillTimer.unref();
-        };
-        input.signal?.addEventListener("abort", abort, { once: true });
-        child.stdout?.on("data", (chunk) => {
-            stdout = appendCaptured(stdout, chunk);
-        });
-        child.stderr?.on("data", (chunk) => {
-            stderr = appendCaptured(stderr, chunk);
-        });
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            terminateProcessTree(child, "SIGTERM", input.detached);
-            forceKillTimer = setTimeout(() => {
-                terminateProcessTree(child, "SIGKILL", input.detached);
-            }, 500);
-            forceKillTimer.unref();
-        }, input.timeoutMs);
-        timeout.unref();
-        child.once("error", (error) => {
-            clearTimeout(timeout);
-            if (forceKillTimer)
-                clearTimeout(forceKillTimer);
-            input.signal?.removeEventListener("abort", abort);
-            reject(error);
-        });
-        child.once("close", (exitCode, signal) => {
-            clearTimeout(timeout);
-            if (forceKillTimer)
-                clearTimeout(forceKillTimer);
-            input.signal?.removeEventListener("abort", abort);
-            if (aborted) {
-                reject(input.signal?.reason instanceof Error
-                    ? input.signal.reason
-                    : Object.assign(new Error("Hook execution cancelled by Host."), { name: "AbortError" }));
-                return;
-            }
-            resolve({ exitCode, signal, stdout, stderr, timedOut });
-        });
-    });
-}
-function appendCaptured(current, chunk) {
-    if (Buffer.byteLength(current) >= MAX_CAPTURE_BYTES)
-        return current;
-    const next = current + chunk.toString();
-    if (Buffer.byteLength(next) <= MAX_CAPTURE_BYTES)
-        return next;
-    return Buffer.from(next).subarray(0, MAX_CAPTURE_BYTES).toString("utf8");
-}
-function hookFailureOutput(stdout, stderr) {
-    const output = (stderr.trim() || stdout.trim()).replace(/\s+/g, " ");
-    return output.length > 1_000 ? `${output.slice(0, 997)}...` : output;
-}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/{oauth-provider.js → mcp/oauth/oauth-provider.js}

@@ -23,7 +23,7 @@ function htmlEscape(value) {
         .replaceAll("'", "'");
 }
 function formHtml(params) {
-    const scopeText = params.scopes.length > 0 ? params.scopes.join(" ") : "devspace";
+    const scopeText = params.scopes.length > 0 ? params.scopes.join(" ") : "forgerelay";
     const resourceText = params.resource?.href ?? "ForgeRelay MCP endpoint";
     const error = params.error
         ? `<p class="error">${htmlEscape(params.error)}</p>`

package/dist/{oauth-store.js → mcp/oauth/oauth-store.js}

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { InvalidRequestError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
-import { openDatabase } from "./db/client.js";
+import { openDatabase } from "../../runtime/state/db/client.js";
 function redirectHostAllowed(redirectUri, allowedHosts) {
     let parsed;
     try {
@@ -9,9 +9,10 @@ function redirectHostAllowed(redirectUri, allowedHosts) {
     catch {
         return false;
     }
-    if (["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname))
-        return true;
-    return allowedHosts.includes(parsed.hostname);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname);
+    if (loopback)
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    return parsed.protocol === "https:" && allowedHosts.includes(parsed.hostname);
 }
 export class SqliteOAuthStore {
     database;

package/dist/{operations → mcp/operations}/native-bulk-mutations.js

@@ -1,5 +1,5 @@
-import { preflightDeletePaths } from "../file-mutations.js";
-import { preflightEditFiles } from "../pi-tools.js";
+import { preflightDeletePaths } from "../filesystem/file-mutations.js";
+import { preflightEditFiles } from "../filesystem/filesystem-tools.js";
 import { openAiConversationScopeId } from "../request-meta.js";
 import { executeSequentialBulkMutation } from "./bulk-mutation.js";
 export class NativeBulkMutationExecutor {

package/dist/mcp/panel/app.js

@@ -0,0 +1,143 @@
+import { access } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
+import { logEvent, transportSessionIdPrefix } from "../../runtime/logging/logger.js";
+import { MCP_APP_RESOURCE_TEMPLATE_REVISION, readActivityPanelAppManifestEntry, resolveActivityPanelAppIdentity, } from "./mcp-app-template.js";
+const cachedIdentities = new Map();
+/**
+ * Build the complete Host-facing Activity Panel resource contract. Keeping URI
+ * identity, CSP, bootstrap HTML, and tool metadata in one module prevents a UI
+ * revision from changing on one surface while another surface keeps stale Host
+ * cache metadata.
+ */
+export function createActivityPanelApp(config, fallbackRevision) {
+    const identity = currentIdentity(config, fallbackRevision);
+    const domain = new URL(config.publicBaseUrl).origin;
+    const csp = activityPanelCsp(config);
+    return {
+        uri: identity.uri,
+        resourceMetadata: {
+            description: "ForgeRelay unified Workspace and Activity UI for one Host Turn.",
+            _meta: { ui: { domain, csp } },
+        },
+        toolMeta: config.widgets === "off"
+            ? { _meta: {} }
+            : {
+                _meta: {
+                    ui: {
+                        resourceUri: identity.uri,
+                        visibility: ["model", "app"],
+                    },
+                },
+            },
+        readResource: (requestedUri, transportSessionId) => readActivityPanelAppResource(config, fallbackRevision, requestedUri, transportSessionId),
+    };
+}
+export function activityPanelAssetDirectory() {
+    return fileURLToPath(new URL("../../../dist/ui", import.meta.url));
+}
+export function setActivityPanelAssetHeaders(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Range");
+    res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
+}
+function appResourceContractRevision(config) {
+    return [
+        MCP_APP_RESOURCE_TEMPLATE_REVISION,
+        `publicBaseUrls=${JSON.stringify(config.publicBaseUrls)}`,
+    ].join("\0");
+}
+function currentIdentity(config, fallbackRevision) {
+    const contractRevision = appResourceContractRevision(config);
+    const cacheKey = `${fallbackRevision}\0${contractRevision}`;
+    let identity = cachedIdentities.get(cacheKey);
+    if (!identity) {
+        identity = resolveActivityPanelAppIdentity({
+            manifestUrl: uiManifestUrl(),
+            buildDirectoryUrl: uiBuildDirectoryUrl(),
+            fallbackRevision,
+            resourceTemplateRevision: contractRevision,
+        });
+        cachedIdentities.set(cacheKey, identity);
+    }
+    return identity;
+}
+function activityPanelCsp(config) {
+    return {
+        resourceDomains: [...config.publicBaseUrls],
+        connectDomains: [...config.publicBaseUrls],
+    };
+}
+async function readActivityPanelAppResource(config, fallbackRevision, requestedUri, transportSessionId) {
+    const identity = currentIdentity(config, fallbackRevision);
+    const entry = readActivityPanelAppManifestEntry(uiManifestUrl());
+    const domain = new URL(config.publicBaseUrl).origin;
+    const csp = activityPanelCsp(config);
+    try {
+        await assertMcpAppAssets(entry);
+        const result = {
+            contents: [{
+                    uri: requestedUri,
+                    mimeType: RESOURCE_MIME_TYPE,
+                    text: activityPanelAppHtml(config, entry),
+                    _meta: {
+                        ui: { domain, csp },
+                        // MCP Apps defines these values under `_meta.ui`. Inspector 2.3.0
+                        // still reads them directly from the content-item metadata, so mirror
+                        // them until that installed-host compatibility gap is retired.
+                        domain,
+                        csp,
+                    },
+                }],
+        };
+        logEvent(config.logging, "debug", "mcp_app_template_read", {
+            requestedUri,
+            currentUri: identity.uri,
+            transportSessionIdPrefix: transportSessionIdPrefix(transportSessionId),
+        });
+        return result;
+    }
+    catch (error) {
+        logEvent(config.logging, "warn", "mcp_app_template_read_failed", {
+            requestedUri,
+            currentUri: identity.uri,
+            error: error instanceof Error ? error.message : String(error),
+            transportSessionIdPrefix: transportSessionIdPrefix(transportSessionId),
+        });
+        throw error;
+    }
+}
+function activityPanelAppHtml(config, entry) {
+    const baseUrl = `${config.publicBaseUrl.replace(/\/+$/, "")}/mcp-app-assets`;
+    const assetUrl = (assetPath) => `${baseUrl}/${assetPath.replace(/^\/+/, "")}`;
+    const stylesheets = (entry.css ?? [])
+        .map((stylesheet) => `    <link rel="stylesheet" crossorigin href="${assetUrl(stylesheet)}" />`)
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>ForgeRelay Activity Panel</title>
+    <script type="module" crossorigin src="${assetUrl(entry.file)}"></script>
+${stylesheets}
+  </head>
+  <body>
+    <main id="app" class="shell">
+      <section class="empty">Waiting for Activity Panel state.</section>
+    </main>
+  </body>
+</html>`;
+}
+async function assertMcpAppAssets(entry) {
+    const candidates = [entry.file, ...(entry.css ?? [])].map((assetPath) => new URL(`../../../dist/ui/${assetPath}`, import.meta.url));
+    for (const candidate of candidates)
+        await access(candidate);
+}
+function uiManifestUrl() {
+    return new URL("../../../dist/ui/.vite/manifest.json", import.meta.url);
+}
+function uiBuildDirectoryUrl() {
+    return new URL("../../../dist/ui/", import.meta.url);
+}