@akira-tl/forgerelay 0.8.8 → 0.8.10

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

package/dist/{mcp-app-template.js → mcp/panel/mcp-app-template.js}

@@ -1,26 +1,10 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
-export const WORKSPACE_APP_MANIFEST_ENTRY = "workspace-app.html";
-export const WORKSPACE_LIFECYCLE_APP_MANIFEST_ENTRY = "workspace-lifecycle-app.html";
 export const ACTIVITY_PANEL_APP_MANIFEST_ENTRY = "activity-panel-app.html";
 // Host caches are keyed by the ui:// resource URI, so the revision must cover
 // both bundle assets and the HTML/resource contract that serves them. Bump this
-// when the MCP App HTML shell or resource-to-entry mapping changes.
-export const MCP_APP_RESOURCE_TEMPLATE_REVISION = "4";
-// Historical mixed-widget resource. Keep serving it so existing ChatGPT Web
-// conversations can still render cards created before the UI split.
-export const WORKSPACE_APP_LEGACY_URI = "ui://forgerelay/workspace-app.html";
-export const WORKSPACE_APP_URI_TEMPLATE = "ui://forgerelay/workspace-app-{revision}.html";
-export const WORKSPACE_LIFECYCLE_APP_LEGACY_URI = "ui://forgerelay/workspace-lifecycle-app.html";
-export const WORKSPACE_LIFECYCLE_APP_URI_TEMPLATE = "ui://forgerelay/workspace-lifecycle-app-{revision}.html";
-export const ACTIVITY_PANEL_APP_LEGACY_URI = "ui://forgerelay/activity-panel-app.html";
-export const ACTIVITY_PANEL_APP_URI_TEMPLATE = "ui://forgerelay/activity-panel-app-{revision}.html";
-export function workspaceAppUriForRevision(revision) {
-    return `ui://forgerelay/workspace-app-${encodeURIComponent(revision)}.html`;
-}
-export function workspaceLifecycleAppUriForRevision(revision) {
-    return `ui://forgerelay/workspace-lifecycle-app-${encodeURIComponent(revision)}.html`;
-}
+// whenever either side changes so a Host never reuses stale UI bytes.
+export const MCP_APP_RESOURCE_TEMPLATE_REVISION = "5";
 export function activityPanelAppUriForRevision(revision) {
     return `ui://forgerelay/activity-panel-app-${encodeURIComponent(revision)}.html`;
 }
@@ -64,12 +48,6 @@ export function readMcpAppManifestEntry(manifestUrl, manifestEntry) {
         ...(entry.isEntry !== undefined ? { isEntry: entry.isEntry } : {}),
     };
 }
-export function readWorkspaceAppManifestEntry(manifestUrl) {
-    return readMcpAppManifestEntry(manifestUrl, WORKSPACE_APP_MANIFEST_ENTRY);
-}
-export function readWorkspaceLifecycleAppManifestEntry(manifestUrl) {
-    return readMcpAppManifestEntry(manifestUrl, WORKSPACE_LIFECYCLE_APP_MANIFEST_ENTRY);
-}
 export function readActivityPanelAppManifestEntry(manifestUrl) {
     return readMcpAppManifestEntry(manifestUrl, ACTIVITY_PANEL_APP_MANIFEST_ENTRY);
 }
@@ -118,20 +96,6 @@ function resolveAppIdentity(options) {
         };
     }
 }
-export function resolveWorkspaceAppIdentity(options) {
-    return resolveAppIdentity({
-        ...options,
-        manifestEntry: WORKSPACE_APP_MANIFEST_ENTRY,
-        uriForRevision: workspaceAppUriForRevision,
-    });
-}
-export function resolveWorkspaceLifecycleAppIdentity(options) {
-    return resolveAppIdentity({
-        ...options,
-        manifestEntry: WORKSPACE_LIFECYCLE_APP_MANIFEST_ENTRY,
-        uriForRevision: workspaceLifecycleAppUriForRevision,
-    });
-}
 export function resolveActivityPanelAppIdentity(options) {
     return resolveAppIdentity({
         ...options,

package/dist/{process-platform.js → mcp/process/process-platform.js}

@@ -11,23 +11,35 @@ const defaultProcessTreeRuntime = {
         return !result.error && result.status === 0;
     },
 };
-const LOGIN_SHELLS = new Set(["bash", "ksh", "zsh"]);
-const POSIX_SHELLS = new Set(["ash", "dash", "sh"]);
+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",
-            args: ["/d", "/s", "/c", command],
+            // 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,
         };
     }
-    const configuredShell = environment.SHELL;
-    const shellName = configuredShell ? basename(configuredShell) : "";
-    if (configuredShell && LOGIN_SHELLS.has(shellName)) {
-        return { executable: configuredShell, args: ["-lc", command] };
+    // 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 (configuredShell && POSIX_SHELLS.has(shellName)) {
-        return { executable: configuredShell, args: ["-c", command] };
+    if (shellName === "zsh") {
+        return { executable, args: ["-f", "-c", command] };
+    }
+    if (POSIX_SHELLS.has(shellName)) {
+        return { executable, args: ["-c", command] };
     }
     return { executable: "/bin/sh", args: ["-c", command] };
 }

package/dist/{process-sessions.js → mcp/process/process-sessions.js}

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { resolveShellCommand, terminateProcessTree } from "./process-platform.js";
 const DEFAULT_EXEC_YIELD_MS = 10_000;
 const DEFAULT_INTERACTIVE_YIELD_MS = 250;
-const DEFAULT_POLL_YIELD_MS = 5_000;
+export const DEFAULT_POLL_YIELD_MS = 60_000;
 const MAX_START_YIELD_MS = 300_000;
 const MAX_COMMAND_YIELD_MS = 300_000;
 const MAX_POLL_YIELD_MS = 300_000;
@@ -437,7 +437,7 @@ export class ProcessManager {
     startPipe(processEntry, input) {
         const shell = resolveShellCommand(input.command);
         const detached = process.platform !== "win32";
-        const child = spawn(input.command, {
+        const child = spawn(shell.executable, shell.args, {
             cwd: input.cwd,
             env: processEnvironment({
                 workspaceId: input.workspaceId,
@@ -446,8 +446,8 @@ export class ProcessManager {
             }),
             stdio: "pipe",
             windowsHide: true,
+            windowsVerbatimArguments: shell.windowsVerbatimArguments,
             detached,
-            shell: shell.executable,
         });
         processEntry.process = {
             write: (data) => child.stdin.write(data),

package/dist/mcp/process/runtime.js

@@ -0,0 +1,257 @@
+const PROCESS_RESPONSE_OUTPUT_LINES = 10;
+export function attachCompletedProcessNotices(processSessions, workspaceId, result, onCompleted) {
+    if (result instanceof Error) {
+        const completed = processSessions.takeCompleted(workspaceId);
+        for (const snapshot of completed)
+            onCompleted?.(snapshot);
+        if (completed.length > 0) {
+            result.message = [
+                result.message,
+                ...completed.map((snapshot) => completedProcessResult(snapshot)),
+            ].join("\n\n");
+        }
+        return result;
+    }
+    if (typeof result !== "object" || result === null)
+        return result;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return result;
+    const structured = result.structuredContent;
+    const currentProcessId = structured?.running === true
+        ? typeof structured.processId === "number"
+            ? structured.processId
+            : typeof structured.sessionId === "number"
+                ? structured.sessionId
+                : undefined
+        : undefined;
+    const completed = processSessions.takeCompleted(workspaceId, undefined, currentProcessId);
+    for (const snapshot of completed)
+        onCompleted?.(snapshot);
+    if (completed.length === 0)
+        return result;
+    return {
+        ...result,
+        content: [
+            ...content,
+            ...completed.map((snapshot) => textBlock(completedProcessResult(snapshot))),
+        ],
+    };
+}
+export function processToolResponse(tool, workspaceId, snapshot, summary) {
+    const compact = compactProcessOutput(snapshot.output);
+    const result = processResult(snapshot);
+    const content = [textBlock(result)];
+    const outputSummary = textSummary(compact.output ? [textBlock(compact.output)] : []);
+    return {
+        content,
+        _meta: {
+            tool,
+            card: {
+                workspaceId,
+                summary: { ...summary, ...outputSummary },
+                payload: { content },
+            },
+        },
+        structuredContent: {
+            result,
+            processId: snapshot.processId,
+            sessionId: snapshot.sessionId,
+            outputId: snapshot.outputId,
+            running: snapshot.running,
+            exitCode: snapshot.exitCode,
+            signal: snapshot.signal,
+            timedOut: snapshot.timedOut,
+            wallTimeMs: snapshot.wallTimeMs,
+            outputTruncated: snapshot.outputTruncated || compact.truncated,
+        },
+    };
+}
+export function durableOutputResponse(tool, workspaceId, record) {
+    const result = durableOutputResult(record);
+    const content = [textBlock(result)];
+    const finishedAt = record.finishedAt ? Date.parse(record.finishedAt) : Date.now();
+    const startedAt = Date.parse(record.startedAt);
+    return {
+        content,
+        _meta: {
+            tool,
+            card: {
+                workspaceId,
+                summary: textSummary(record.output ? [textBlock(record.output)] : []),
+                payload: { content },
+            },
+        },
+        structuredContent: {
+            result,
+            processId: record.processId,
+            sessionId: record.processId,
+            outputId: record.outputId,
+            running: record.status === "running",
+            exitCode: record.exitCode,
+            signal: record.signal,
+            timedOut: record.timedOut,
+            wallTimeMs: Math.max(0, Number.isFinite(finishedAt - startedAt) ? finishedAt - startedAt : 0),
+            outputTruncated: false,
+        },
+    };
+}
+export function readWorkspaceBashOutput(store, workspaceId, outputId) {
+    const record = store.read(outputId);
+    if (!record)
+        throw new Error(`Unknown Bash output: ${outputId}`);
+    if (record.workspaceId !== workspaceId) {
+        throw new Error(`Bash output ${outputId} does not belong to workspace ${workspaceId}.`);
+    }
+    return record;
+}
+export function markReturnedOutput(store, result) {
+    if (typeof result !== "object" || result === null)
+        return;
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return;
+    const record = structured;
+    if (record.running === true && typeof record.outputId === "string") {
+        store.markReturned(record.outputId);
+    }
+}
+export function recordBashCompletion(lifecycle, store, outputId) {
+    if (!outputId)
+        return;
+    const completion = store.claimCompletion(outputId);
+    if (!completion)
+        return;
+    lifecycle.recordLinked({
+        sourceActivityId: completion.activityId,
+        tool: "bash_result",
+        request: {
+            processId: completion.processId,
+            outputId: completion.outputId,
+        },
+        result: {
+            processId: completion.processId,
+            outputId: completion.outputId,
+            exitCode: completion.exitCode,
+            signal: completion.signal,
+            timedOut: completion.timedOut,
+        },
+        outcome: completion.status === "failed"
+            ? { type: "failed", error: bashCompletionError(completion) }
+            : { type: "succeeded" },
+    });
+}
+export function processActivityOutcome(result) {
+    if (toolResultIsError(result))
+        return { type: "failed", error: activityFailureMessage(result) };
+    if (typeof result !== "object" || result === null)
+        return { type: "succeeded" };
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return { type: "succeeded" };
+    const process = structured;
+    if (process.running === true)
+        return { type: "returned" };
+    if (process.timedOut === true ||
+        typeof process.signal === "string" ||
+        (typeof process.exitCode === "number" && process.exitCode !== 0)) {
+        return { type: "failed", error: activityFailureMessage(result) };
+    }
+    return { type: "succeeded" };
+}
+export function toolResultIsError(result) {
+    return typeof result === "object" && result !== null && result.isError === true;
+}
+function compactProcessOutput(output) {
+    if (!output)
+        return { output: "", truncated: false };
+    const trailingNewline = output.endsWith("\n");
+    const body = trailingNewline ? output.slice(0, -1) : output;
+    const lines = body.split("\n");
+    if (lines.length <= PROCESS_RESPONSE_OUTPUT_LINES)
+        return { output, truncated: false };
+    const compact = lines.slice(-PROCESS_RESPONSE_OUTPUT_LINES).join("\n");
+    return {
+        output: trailingNewline ? `${compact}\n` : compact,
+        truncated: true,
+    };
+}
+function processResult(snapshot) {
+    const status = snapshot.running
+        ? `Process running with process ID ${snapshot.processId}.`
+        : snapshot.timedOut
+            ? "Process timed out and was terminated."
+            : snapshot.signal
+                ? `Process exited after signal ${snapshot.signal}.`
+                : `Process exited with code ${snapshot.exitCode ?? "unknown"}.`;
+    const compact = compactProcessOutput(snapshot.output).output.replace(/\n$/, "");
+    return [compact, status, outputIdNotice(snapshot.outputId)].filter(Boolean).join("\n");
+}
+function completedProcessResult(snapshot) {
+    const status = snapshot.timedOut
+        ? `Background process ${snapshot.processId} timed out and was terminated.`
+        : snapshot.signal
+            ? `Background process ${snapshot.processId} exited after signal ${snapshot.signal}.`
+            : `Background process ${snapshot.processId} exited with code ${snapshot.exitCode ?? "unknown"}.`;
+    const command = `Command: ${snapshot.command}`;
+    const output = compactProcessOutput(snapshot.output).output.replace(/\n$/, "");
+    return [status, command, output, outputIdNotice(snapshot.outputId)].filter(Boolean).join("\n");
+}
+function outputIdNotice(outputId) {
+    return outputId ? `Full output ID: ${outputId}.` : "";
+}
+function durableOutputResult(record) {
+    const status = record.status === "running"
+        ? `Process ${record.processId} is still running.`
+        : record.timedOut
+            ? `Process ${record.processId} timed out and was terminated.`
+            : record.signal
+                ? `Process ${record.processId} exited after signal ${record.signal}.`
+                : `Process ${record.processId} exited with code ${record.exitCode ?? "unknown"}.`;
+    return [record.output.replace(/\n$/, ""), status, `Full output ID: ${record.outputId}.`]
+        .filter(Boolean)
+        .join("\n");
+}
+function bashCompletionError(record) {
+    if (record.error)
+        return record.error;
+    if (record.timedOut)
+        return `Background process ${record.processId} timed out.`;
+    if (record.signal)
+        return `Background process ${record.processId} exited after signal ${record.signal}.`;
+    return `Background process ${record.processId} exited with code ${record.exitCode ?? "unknown"}.`;
+}
+function activityFailureMessage(result) {
+    if (typeof result !== "object" || result === null)
+        return "Tool returned a failed result.";
+    const record = result;
+    if (Array.isArray(record.content)) {
+        const text = record.content
+            .map((entry) => {
+            if (typeof entry !== "object" || entry === null)
+                return "";
+            const value = entry.text;
+            return typeof value === "string" ? value : "";
+        })
+            .filter(Boolean)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    if (typeof record.structuredContent === "object" && record.structuredContent !== null) {
+        const value = record.structuredContent.result;
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return "Tool returned a failed result.";
+}
+function textBlock(text) {
+    return { type: "text", text };
+}
+function textSummary(content) {
+    const text = content.map((item) => item.text).join("\n");
+    return {
+        lines: text.length === 0 ? 0 : text.split("\n").length,
+        characters: text.length,
+    };
+}