@portel/photon 1.14.0 → 1.16.1

package/dist/auto-ui/beam.js

@@ -13,7 +13,7 @@ import * as path from 'path';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
-import { setSecurityHeaders, SimpleRateLimiter } from '../shared/security.js';
+import { setSecurityHeaders, SimpleRateLimiter, escapeHtml } from '../shared/security.js';
 /**
  * Check if shell integration has been installed (photon init cli).
  * Cached at module load since it won't change during a Beam session.
@@ -94,7 +94,7 @@ import { logger, createLogger } from '../shared/logger.js';
 import { getErrorMessage } from '../shared/error-handler.js';
 import { toEnvVarName } from '../shared/config-docs.js';
 import { MarketplaceManager } from '../marketplace-manager.js';
-import { subscribeChannel } from '../daemon/client.js';
+import { subscribeChannel, reloadDaemonPhoton } from '../daemon/client.js';
 import { ensurePhotonEditorDeclaration, writePhotonEditorDeclaration, } from '../photon-editor-declarations.js';
 import { ensureDaemon } from '../daemon/manager.js';
 import { SchemaExtractor, } from '@portel/photon-core';
@@ -144,6 +144,11 @@ const extractCspFromSource = extractCspFromModule;
  * Example: { "chat": ["mentions", "direct-messages"], "tasks": ["deadline", "assigned-to-me"] }
  */
 const photonNotificationSubscriptions = new Map();
+/**
+ * Track which state-changed channels we've already subscribed to,
+ * so dynamically discovered photons can be subscribed without duplicates.
+ */
+const subscribedStateChannels = new Set();
 /**
  * Generate the service worker JS that validates the Beam backend
  * on PWA launch and shows a diagnostic page if something is wrong.
@@ -192,6 +197,7 @@ self.addEventListener('fetch', (event) => {
     url.pathname.startsWith('/api/') ||
     url.pathname === '/sw.js' ||
     url.pathname === '/beam.bundle.js' ||
+    url.pathname === '/beam-form.bundle.js' ||
     url.pathname === '/beam-ts-worker.js'
   ) return;
 
@@ -479,18 +485,43 @@ export async function startBeam(rawWorkingDir, port) {
         logger.warn(`Asset repair check failed: ${getErrorMessage(error)}`);
     }
     // Discover all photons with namespace metadata (user photons + bundled photons)
-    const userPhotonListDetailed = await listPhotonFilesWithNamespace(workingDir);
-    // Detect name collisions to decide sidebar display names
+    const scannedPhotonList = await listPhotonFilesWithNamespace(workingDir);
+    // Deduplicate aliases that resolve to the same underlying file (for example,
+    // a marketplace photon and a local alias/symlink that both point at the same
+    // source). Beam should not show both copies in the sidebar.
+    const userPhotonListDetailed = [];
+    const seenPhotonKeys = new Set();
+    for (const photon of scannedPhotonList) {
+        let realPath = photon.filePath;
+        try {
+            realPath = realpathSync(photon.filePath);
+        }
+        catch {
+            // Fall back to the discovered path if realpath resolution fails.
+        }
+        const dedupeKey = `${photon.name}::${realPath}`;
+        if (seenPhotonKeys.has(dedupeKey))
+            continue;
+        seenPhotonKeys.add(dedupeKey);
+        userPhotonListDetailed.push(photon);
+    }
+    // Detect name collisions and generate friendly duplicate labels. We should
+    // never leak namespace/owner names into the sidebar just because there are
+    // multiple copies of a photon with the same short name.
     const nameOccurrences = new Map();
     for (const p of userPhotonListDetailed) {
         nameOccurrences.set(p.name, (nameOccurrences.get(p.name) || 0) + 1);
     }
-    // Build photon list: use qualifiedName when collision, short name when unique
-    // Also track resolved paths from namespace scan
+    // Build photon list with short names plus a numeric suffix for duplicates.
+    // Also track resolved paths from namespace scan.
     const namespacePaths = new Map(); // displayName → filePath
     const userPhotonList = [];
+    const duplicateIndex = new Map();
     for (const p of userPhotonListDetailed) {
-        const displayName = (nameOccurrences.get(p.name) || 0) > 1 ? p.qualifiedName : p.name;
+        const duplicateCount = nameOccurrences.get(p.name) || 0;
+        const nextIndex = (duplicateIndex.get(p.name) || 0) + 1;
+        duplicateIndex.set(p.name, nextIndex);
+        const displayName = duplicateCount > 1 ? `${p.name} (${nextIndex})` : p.name;
         userPhotonList.push(displayName);
         namespacePaths.set(displayName, p.filePath);
     }
@@ -643,6 +674,25 @@ export async function startBeam(rawWorkingDir, port) {
             }
             // Get UI assets for linking
             const uiAssets = mcp.assets?.ui || [];
+            // If loader didn't resolve UI assets but source has @ui tags,
+            // extract them from source to populate linkedUi for sidebar
+            if (uiAssets.length === 0 && schemaSource) {
+                const uiTagRegex = /^\s*\*\s*@ui\s+(\S+)(?:\s+(\S+))?/gm;
+                let uiMatch;
+                const classUiMatch = schemaSource.match(/^\s*\*\s*@ui\s+(\S+)\s+(\.\/\S+)/m);
+                if (classUiMatch) {
+                    // Class-level @ui tag with file path: @ui dashboard ./ui/dashboard.html
+                    const uiId = classUiMatch[1]; // e.g., "dashboard"
+                    // Add synthetic asset entry for all methods tagged with this @ui id
+                    schemas.forEach((schema) => {
+                        // Check if method has @ui tag matching this id
+                        const methodSource = schemaSource.match(new RegExp(`@ui\\s+${uiId}[\\s\\n]*\\*/[\\s\\n]*(?:async\\s+)?${schema.name}\\s*\\(`, 'm'));
+                        if (methodSource) {
+                            uiAssets.push({ id: uiId, linkedTool: schema.name });
+                        }
+                    });
+                }
+            }
             // Filter out lifecycle methods
             const lifecycleMethods = ['onInitialize', 'onShutdown', 'constructor'];
             const methods = schemas
@@ -994,7 +1044,12 @@ export async function startBeam(rawWorkingDir, port) {
                         return configurePhotonViaMCP(photonName, config, photons, photonMCPs, loader, savedConfig, workingDir, activeLoads);
                     },
                     reloadPhoton: async (photonName) => {
-                        return reloadPhotonViaMCP(photonName, photons, photonMCPs, loader, savedConfig, broadcastPhotonChange, activeLoads);
+                        return reloadPhotonViaMCP(photonName, photons, photonMCPs, loader, savedConfig, broadcastPhotonChange, activeLoads, (name, path, isStateful) => {
+                            if (isStateful) {
+                                subscribeStatefulPhoton(name).catch(() => { });
+                                reloadDaemonPhoton(name, path, workingDir).catch(() => { });
+                            }
+                        });
                     },
                     removePhoton: async (photonName) => {
                         return removePhotonViaMCP(photonName, photons, photonMCPs, savedConfig, broadcastPhotonChange, workingDir);
@@ -1174,7 +1229,24 @@ export async function startBeam(rawWorkingDir, port) {
                 }
                 catch {
                     res.writeHead(404);
-                    res.end('Bundle not found. Run npm run build:beam first.');
+                    res.end('Bundle not found. Run the beam build script first.');
+                }
+                return;
+            }
+            // Serve form components bundle (invoke-form + custom inputs for pure-view)
+            if (url.pathname === '/beam-form.bundle.js') {
+                try {
+                    const formBundlePath = path.join(__dirname, '../../dist/beam-form.bundle.js');
+                    const content = await fs.readFile(formBundlePath, 'utf-8');
+                    res.writeHead(200, {
+                        'Content-Type': 'text/javascript',
+                        'Cache-Control': 'no-cache',
+                    });
+                    res.end(content);
+                }
+                catch {
+                    res.writeHead(404);
+                    res.end('Form bundle not found. Run the beam build script first.');
                 }
                 return;
             }
@@ -1190,7 +1262,7 @@ export async function startBeam(rawWorkingDir, port) {
                 }
                 catch {
                     res.writeHead(404);
-                    res.end('TS worker not found. Run npm run build:beam first.');
+                    res.end('TS worker not found. Run the beam build script first.');
                 }
                 return;
             }
@@ -1637,6 +1709,43 @@ export async function startBeam(rawWorkingDir, port) {
                 res.end(html);
                 return;
             }
+            // Pure view mode — serve lightweight bridge-powered page (no beam-app shell).
+            // All view modes (form, result, embed) use pure-view.html with the bridge.
+            // Form views lazy-load the form-components bundle for custom inputs.
+            const viewParam = url.searchParams.get('view');
+            if ((viewParam === 'result' || viewParam === 'embed' || viewParam === 'form') &&
+                url.pathname !== '/' &&
+                !url.pathname.startsWith('/api')) {
+                try {
+                    const pathParts = url.pathname.split('/').filter(Boolean);
+                    const photonName = pathParts[0] || '';
+                    const methodName = pathParts[1] || '';
+                    const params = {};
+                    for (const [k, v] of url.searchParams) {
+                        if (k !== 'view')
+                            params[k] = v;
+                    }
+                    const pureViewPath = path.join(__dirname, 'frontend/pure-view.html');
+                    let html = await fs.readFile(pureViewPath, 'utf-8');
+                    // Replace placeholders
+                    const argsJson = escapeHtml(JSON.stringify(params));
+                    html = html
+                        .replaceAll('__PHOTON__', encodeURIComponent(photonName))
+                        .replaceAll('__METHOD__', escapeHtml(methodName))
+                        .replaceAll('__ARGS__', argsJson);
+                    // Add data-view for form and result modes
+                    if (viewParam === 'form' || viewParam === 'result') {
+                        html = html.replace('data-method=', `data-view="${escapeHtml(viewParam)}" data-method=`);
+                    }
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(html);
+                }
+                catch (err) {
+                    res.writeHead(500);
+                    res.end('Error serving pure view: ' + String(err));
+                }
+                return;
+            }
             // Default route: Serve Lit App
             if (url.pathname === '/' || !url.pathname.startsWith('/api')) {
                 try {
@@ -1646,6 +1755,8 @@ export async function startBeam(rawWorkingDir, port) {
                     if (_shellIntegrationInstalled) {
                         content = content.replace('</head>', '<script>window.__PHOTON_SHELL_INIT=true</script></head>');
                     }
+                    // Note: ?view=form and ?view=result are handled by pure-view.html above.
+                    // This default route only serves the full Beam app for the main UI.
                     res.writeHead(200, { 'Content-Type': 'text/html' });
                     res.end(content);
                 }
@@ -2049,6 +2160,16 @@ export async function startBeam(rawWorkingDir, port) {
                             }
                             // else: photon was removed while we were reloading — discard result
                         }
+                        // Subscribe to state-changed events for newly discovered stateful photons
+                        if (isStateful) {
+                            subscribeStatefulPhoton(photonName).catch((err) => {
+                                logger.warn(`Failed to subscribe dynamically to ${photonName}: ${getErrorMessage(err)}`);
+                            });
+                            // Tell daemon to reload so its instance has the new methods/code
+                            reloadDaemonPhoton(photonName, photonPath, workingDir).catch((err) => {
+                                logger.debug(`Daemon reload for ${photonName}: ${getErrorMessage(err)}`);
+                            });
+                        }
                         // If this photon is symlinked and was previously errored (or new), set up
                         // source-directory watchers that may have been skipped at startup.
                         if (isNewPhoton || !previouslyConfigured) {
@@ -2265,6 +2386,79 @@ export async function startBeam(rawWorkingDir, port) {
     startup.ready();
     // Notify connected clients that photon list is now available
     broadcastPhotonChange();
+    // Subscribe a single stateful photon to its state-changed daemon channel.
+    // Extracted so it can be called both at startup and when new photons are discovered.
+    async function subscribeStatefulPhoton(photonName) {
+        const instanceNames = ['default'];
+        for (const instanceName of instanceNames) {
+            const channel = `${photonName}:${instanceName}:state-changed`;
+            if (subscribedStateChannels.has(channel))
+                continue;
+            subscribedStateChannels.add(channel);
+            subscribeChannel(photonName, channel, (message) => {
+                // Sync Beam's local instance from the daemon-persisted state file BEFORE
+                // notifying the frontend. The daemon persists state to disk after mutations,
+                // and Beam's local instance must match before _silentRefresh re-queries it.
+                void (async () => {
+                    if (message?.patch?.length > 0) {
+                        const mcp = photonMCPs.get(photonName);
+                        if (mcp?.instance) {
+                            const instName = instanceName || 'default';
+                            const stateFile = path.join(workingDir, 'state', photonName, `${instName}.json`);
+                            try {
+                                const json = await fs.readFile(stateFile, 'utf-8');
+                                const state = JSON.parse(json);
+                                for (const [key, value] of Object.entries(state)) {
+                                    const target = mcp.instance[key];
+                                    if (target && typeof target.splice === 'function' && Array.isArray(value)) {
+                                        target.splice(0, target.length, ...value);
+                                    }
+                                    else {
+                                        mcp.instance[key] = value;
+                                    }
+                                }
+                            }
+                            catch {
+                                // State file not yet written — ignore
+                                // State file not yet written — ignore
+                            }
+                        }
+                    }
+                    if (message?.instance === instanceName || !message?.instance) {
+                        broadcastNotification('state-changed', {
+                            photon: photonName,
+                            instance: instanceName,
+                            patches: message?.patches,
+                            method: message?.method,
+                            params: message?.params,
+                            data: message?.data,
+                            ...(message?.patch && { patch: message.patch }),
+                            ...(message?.inversePatch && { inversePatch: message.inversePatch }),
+                        });
+                    }
+                })();
+            }, {
+                reconnect: true,
+                workingDir,
+                onReconnect: () => logger.debug(`📡 Reconnected ${channel} subscription`),
+                onRefreshNeeded: () => {
+                    logger.info(`📡 Refresh needed for ${channel} (events lost during daemon restart)`);
+                    broadcastNotification('state-changed', {
+                        photon: photonName,
+                        instance: instanceName,
+                        method: '_refresh',
+                        patches: undefined,
+                    });
+                },
+            })
+                .then(() => {
+                logger.info(`📡 Subscribed to ${channel} for cross-client sync`);
+            })
+                .catch((err) => {
+                logger.warn(`Failed to subscribe to ${channel}: ${getErrorMessage(err)}`);
+            });
+        }
+    }
     // Auto-start daemon and subscribe to state-changed events for stateful photons
     // Uses reconnect: true so subscriptions survive daemon restarts
     const statefulPhotons = photons.filter((p) => p.stateful && p.configured);
@@ -2272,52 +2466,7 @@ export async function startBeam(rawWorkingDir, port) {
         try {
             await ensureDaemon();
             for (const photon of statefulPhotons) {
-                const photonName = photon.name;
-                // Subscribe to 'default' instance + any other instances that appear
-                const instanceNames = ['default'];
-                for (const instanceName of instanceNames) {
-                    // Channel is now instance-specific: photon:instance:state-changed
-                    const channel = `${photonName}:${instanceName}:state-changed`;
-                    subscribeChannel(photonName, channel, (message) => {
-                        // Only broadcast if instance matches (prevents cross-instance leakage)
-                        if (message?.instance === instanceName || !message?.instance) {
-                            // Minimal transmission: include instance and patches for global sync
-                            broadcastNotification('state-changed', {
-                                photon: photonName,
-                                instance: instanceName,
-                                // JSON Patch array for client-side state sync
-                                patches: message?.patches,
-                                // Keep legacy fields for backward compatibility
-                                method: message?.method,
-                                params: message?.params,
-                                data: message?.data,
-                                // Optional fields for undo/redo support
-                                ...(message?.patch && { patch: message.patch }),
-                                ...(message?.inversePatch && { inversePatch: message.inversePatch }),
-                            });
-                        }
-                    }, {
-                        reconnect: true,
-                        workingDir,
-                        onReconnect: () => logger.debug(`📡 Reconnected ${channel} subscription`),
-                        onRefreshNeeded: () => {
-                            logger.info(`📡 Refresh needed for ${channel} (events lost during daemon restart)`);
-                            // Broadcast minimal refresh signal to all clients
-                            broadcastNotification('state-changed', {
-                                photon: photonName,
-                                instance: instanceName,
-                                method: '_refresh',
-                                patches: undefined, // No patches, signal full refresh needed
-                            });
-                        },
-                    })
-                        .then(() => {
-                        logger.info(`📡 Subscribed to ${channel} for cross-client sync`);
-                    })
-                        .catch((err) => {
-                        logger.warn(`Failed to subscribe to ${channel}: ${getErrorMessage(err)}`);
-                    });
-                }
+                await subscribeStatefulPhoton(photon.name);
             }
         }
         catch (err) {