@leeoohoo/ui-apps-devkit 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leeoohoo/ui-apps-devkit",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "ChatOS UI Apps DevKit (CLI + templates + sandbox) for building installable ChatOS UI Apps plugins.",
   "license": "MIT",
   "type": "module",

package/src/sandbox/server.js

@@ -8,6 +8,8 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
+import { LoggingMessageNotificationSchema, NotificationSchema } from '@modelcontextprotocol/sdk/types.js';
+import * as z from 'zod/v4';
 
 import { copyDir, ensureDir, isDirectory, isFile } from '../lib/fs.js';
 import { loadPluginManifest, pickAppFromManifest } from '../lib/plugin.js';
@@ -273,6 +275,34 @@ function formatMcpToolResult(serverName, toolName, result) {
   return `${header}\n${segments.join('\n\n')}`;
 }
 
+const MCP_STREAM_NOTIFICATION_METHODS = [
+  'codex_app.window_run.stream',
+  'codex_app.window_run.done',
+  'codex_app.window_run.completed',
+];
+
+const buildLooseNotificationSchema = (method) =>
+  NotificationSchema.extend({
+    method: z.literal(method),
+    params: z.unknown().optional(),
+  });
+
+function registerMcpNotificationHandlers(client, { serverName, onNotification } = {}) {
+  if (!client || typeof client.setNotificationHandler !== 'function') return;
+  if (typeof onNotification !== 'function') return;
+  const emit = (notification) => {
+    try {
+      onNotification({ serverName, ...notification });
+    } catch {
+      // ignore notification relay errors
+    }
+  };
+  client.setNotificationHandler(LoggingMessageNotificationSchema, (notification) => emit(notification));
+  MCP_STREAM_NOTIFICATION_METHODS.forEach((method) => {
+    client.setNotificationHandler(buildLooseNotificationSchema(method), (notification) => emit(notification));
+  });
+}
+
 async function listAllMcpTools(client) {
   const collected = [];
   let cursor = null;
@@ -290,15 +320,17 @@ async function listAllMcpTools(client) {
   return collected;
 }
 
-async function connectMcpServer(entry) {
+async function connectMcpServer(entry, options = {}) {
   if (!entry || typeof entry !== 'object') return null;
   const serverName = normalizeText(entry.name) || 'mcp_server';
+  const onNotification = typeof options?.onNotification === 'function' ? options.onNotification : null;
   const env = { ...process.env };
   if (!env.MODEL_CLI_SESSION_ROOT) env.MODEL_CLI_SESSION_ROOT = process.cwd();
   if (!env.MODEL_CLI_WORKSPACE_ROOT) env.MODEL_CLI_WORKSPACE_ROOT = process.cwd();
 
   if (entry.command) {
     const client = new Client({ name: 'sandbox', version: '0.1.0' });
+    registerMcpNotificationHandlers(client, { serverName, onNotification });
     const transport = new StdioClientTransport({
       command: entry.command,
       args: Array.isArray(entry.args) ? entry.args : [],
@@ -318,6 +350,7 @@ async function connectMcpServer(entry) {
     if (parsed.protocol === 'ws:' || parsed.protocol === 'wss:') {
       const client = new Client({ name: 'sandbox', version: '0.1.0' });
       const transport = new WebSocketClientTransport(parsed);
+      registerMcpNotificationHandlers(client, { serverName, onNotification });
       await client.connect(transport);
       const tools = await listAllMcpTools(client);
       return { serverName, client, transport, tools };
@@ -327,6 +360,7 @@ async function connectMcpServer(entry) {
     try {
       const client = new Client({ name: 'sandbox', version: '0.1.0' });
       const transport = new StreamableHTTPClientTransport(parsed);
+      registerMcpNotificationHandlers(client, { serverName, onNotification });
       await client.connect(transport);
       const tools = await listAllMcpTools(client);
       return { serverName, client, transport, tools };
@@ -336,6 +370,7 @@ async function connectMcpServer(entry) {
     try {
       const client = new Client({ name: 'sandbox', version: '0.1.0' });
       const transport = new SSEClientTransport(parsed);
+      registerMcpNotificationHandlers(client, { serverName, onNotification });
       await client.connect(transport);
       const tools = await listAllMcpTools(client);
       return { serverName, client, transport, tools };
@@ -1918,6 +1953,19 @@ const scheduleReload = (() => {
 try {
   const es = new EventSource('/events');
   es.addEventListener('reload', () => scheduleReload());
+  es.addEventListener('mcp-notification', (event) => {
+    if (!event?.data) return;
+    let payload = null;
+    try {
+      payload = JSON.parse(event.data);
+    } catch {
+      payload = { raw: event.data };
+    }
+    if (!payload) return;
+    const server = payload?.serverName ? String(payload.serverName) : 'mcp';
+    const method = payload?.method ? String(payload.method) : 'notification';
+    appendMcpOutput(`${server} ${method}`, payload?.params?.text || payload);
+  });
 } catch {
   // ignore
 }
@@ -1970,6 +2018,7 @@ export async function startSandboxServer({ pluginDir, port = 4399, appId = '' })
   let mcpRuntime = null;
   let mcpRuntimePromise = null;
   let sandboxCallMeta = null;
+  let relayMcpNotification = null;
 
   const resetMcpRuntime = async () => {
     const runtime = mcpRuntime;
@@ -1996,7 +2045,9 @@ export async function startSandboxServer({ pluginDir, port = 4399, appId = '' })
     if (mcpRuntime) return mcpRuntime;
     if (!mcpRuntimePromise) {
       mcpRuntimePromise = (async () => {
-        const handle = await connectMcpServer(appMcpEntry);
+        const handle = await connectMcpServer(appMcpEntry, {
+          onNotification: relayMcpNotification,
+        });
         if (!handle) return null;
         const toolEntries = Array.isArray(handle.tools)
           ? handle.tools.map((tool) => {
@@ -2203,6 +2254,13 @@ export async function startSandboxServer({ pluginDir, port = 4399, appId = '' })
       sseWrite(res, event, data);
     }
   };
+  relayMcpNotification = (notification) => {
+    if (!notification) return;
+    sseBroadcast('mcp-notification', {
+      ...notification,
+      receivedAt: new Date().toISOString(),
+    });
+  };
 
   let changeSeq = 0;
   const stopWatch = startRecursiveWatcher(pluginDir, ({ eventType, filePath }) => {